dycw-utilities 0.110.8__tar.gz → 0.111.1__tar.gz

{dycw_utilities-0.110.8 → dycw_utilities-0.111.1}/PKG-INFO

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

{dycw_utilities-0.110.8 → dycw_utilities-0.111.1}/pyproject.toml

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

{dycw_utilities-0.110.8 → dycw_utilities-0.111.1}/src/tests/test_datetime.py

@@ -107,10 +107,8 @@ from utilities.datetime import (
     get_today_local,
     get_today_tokyo,
     get_years,
-    is_instance_date_not_datetime,
     is_integral_timedelta,
     is_local_datetime,
-    is_subclass_date_not_datetime,
     is_weekday,
     is_zero_time,
     is_zoned_datetime,
@@ -751,16 +749,6 @@ class TestGetToday:
         assert isinstance(today, dt.date)
 
 
-class TestIsInstanceDateNotDateTime:
-    @given(date=dates())
-    def test_date(self, *, date: dt.date) -> None:
-        assert is_instance_date_not_datetime(date)
-
-    @given(datetime=datetimes())
-    def test_datetime(self, *, datetime: dt.datetime) -> None:
-        assert not is_instance_date_not_datetime(datetime)
-
-
 class TestIsIntegralTimeDelta:
     @given(n=integers())
     def test_integral(self, *, n: int) -> None:
@@ -794,13 +782,6 @@ class TestIsLocalDateTime:
         assert result is expected
 
 
-class TestIsSubClassDateNotDateTime:
-    @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:
     @given(date=dates())
     def test_main(self, *, date: dt.date) -> None:

{dycw_utilities-0.110.8 → dycw_utilities-0.111.1}/src/tests/test_functions.py

@@ -12,7 +12,6 @@ from typing import TYPE_CHECKING, Any, ClassVar, ParamSpec, TypeVar, cast
 from hypothesis import given
 from hypothesis.strategies import (
     DataObject,
-    SearchStrategy,
     booleans,
     builds,
     data,
@@ -74,7 +73,6 @@ from utilities.functions import (
     is_dataclass_class,
     is_dataclass_instance,
     is_hashable,
-    is_instance_not_bool_int,
     is_iterable_of,
     is_none,
     is_not_none,
@@ -83,7 +81,6 @@ from utilities.functions import (
     is_sized,
     is_sized_not_str,
     is_string_mapping,
-    is_subclass_not_bool_int,
     is_tuple,
     is_tuple_or_str_mapping,
     make_isinstance,
@@ -622,39 +619,6 @@ class TestIsHashable:
         assert is_hashable(obj) is expected
 
 
-class TestIsInstanceNotIntBool:
-    @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),
-        ]),
-    )
-    def test_main(
-        self, *, data: DataObject, case: tuple[SearchStrategy[Any], type[Any], bool]
-    ) -> None:
-        strategy, type_, expected = case
-        value = data.draw(strategy)
-        assert is_instance_not_bool_int(value, type_) is expected
-
-    @given(bool_=booleans())
-    def test_bool_value_vs_custom_int(self, *, bool_: bool) -> None:
-        class MyInt(int): ...
-
-        assert not is_instance_not_bool_int(bool_, MyInt)
-
-    @given(int_=integers())
-    def test_int_value_vs_custom_int(self, *, int_: int) -> None:
-        class MyInt(int): ...
-
-        assert not is_instance_not_bool_int(int_, MyInt)
-        assert is_instance_not_bool_int(MyInt(int_), MyInt)
-
-
 class TestIsIterableOf:
     @given(
         case=sampled_from([
@@ -775,31 +739,6 @@ class TestIsStringMapping:
         assert result is expected
 
 
-class TestIsSubclassNotBoolInt:
-    @given(
-        case=sampled_from([
-            (bool, bool, True),
-            (bool, int, False),
-            (int, bool, False),
-            (int, int, True),
-            (bool, (bool, int), True),
-            (int, (bool, int), True),
-        ])
-    )
-    def test_main(self, *, case: tuple[type[Any], type[Any], bool]) -> None:
-        child, parent, expected = case
-        assert is_subclass_not_bool_int(child, parent) is expected
-
-    def test_custom_int(self) -> None:
-        class MyInt(int): ...
-
-        assert not is_subclass_not_bool_int(bool, MyInt)
-        assert not is_subclass_not_bool_int(MyInt, bool)
-        assert not is_subclass_not_bool_int(int, MyInt)
-        assert is_subclass_not_bool_int(MyInt, int)
-        assert is_subclass_not_bool_int(MyInt, MyInt)
-
-
 class TestIsTuple:
     @given(case=sampled_from([(None, False), ((1, 2, 3), True), ([1, 2, 3], False)]))
     def test_main(self, *, case: tuple[Any, bool]) -> None:

{dycw_utilities-0.110.8 → dycw_utilities-0.111.1}/src/tests/test_orjson.py

@@ -23,7 +23,7 @@ from hypothesis.strategies import (
 )
 from orjson import JSONDecodeError
 from polars import Object, String, UInt64
-from pytest import approx, mark, raises
+from pytest import approx, raises
 
 from tests.conftest import SKIPIF_CI_AND_WINDOWS
 from tests.test_operator import (
@@ -147,7 +147,6 @@ class TestGetLogRecords:
         ),
         root=temp_paths(),
     )
-    @mark.flaky
     def test_dataframe(
         self, *, root: Path, items: Sequence[tuple[LogLevel, str, StrMapping]]
     ) -> None:
@@ -205,7 +204,6 @@ class TestGetLogRecords:
         min_log_file_line_num=integers() | none(),
         max_log_file_line_num=integers() | none(),
     )
-    @mark.flaky
     def test_filter(
         self,
         *,

{dycw_utilities-0.110.8 → dycw_utilities-0.111.1}/src/tests/test_parse.py

@@ -300,6 +300,43 @@ class TestSerializeAndParseObject:
 
 
 class TestParseObject:
+    @given(text=sampled_from(["F_a_l_s_e", "T_r_u_e"]))
+    def test_bool_custom(self, *, text: str) -> None:
+        def parser(text: str, /) -> bool:
+            match text:
+                case "F_a_l_s_e":
+                    return False
+                case "T_r_u_e":
+                    return True
+                case _:
+                    raise ImpossibleCaseError(case=[f"{text=}"])
+
+        bool_ = parse_object(bool, text, extra={bool: parser})
+        match text:
+            case "F_a_l_s_e":
+                expected = False
+            case "T_r_u_e":
+                expected = True
+            case _:
+                raise ImpossibleCaseError(case=[f"{text=}"])
+        assert bool_ is expected
+
+    @given(text=sampled_from(["F_a_l_s_e", "T_r_u_e"]))
+    def test_bool_extra_not_used(self, *, text: str) -> None:
+        def parser(text: str, /) -> bool:
+            match text:
+                case "F_a_l_s_e":
+                    return False
+                case "T_r_u_e":
+                    return True
+                case _:
+                    raise ImpossibleCaseError(case=[f"{text=}"])
+
+        with raises(
+            _ParseObjectParseError, match="Unable to parse <class 'bool'>; got '.*'"
+        ):
+            _ = parse_object(bool, text, extra={int: parser})
+
     def test_error_bool(self) -> None:
         with raises(
             _ParseObjectParseError,
@@ -531,6 +568,32 @@ class TestParseObject:
 
 
 class TestSerializeObject:
+    @given(bool_=booleans())
+    def test_bool_custom(self, *, bool_: bool) -> None:
+        def serializer(bool_: bool, /) -> str:  # noqa: FBT001
+            match bool_:
+                case True:
+                    return "1"
+                case False:
+                    return "0"
+
+        serialized = serialize_object(bool_, extra={bool: serializer})
+        match bool_:
+            case True:
+                expected = "1"
+            case False:
+                expected = "0"
+        assert serialized == expected
+
+    @given(bool_=booleans())
+    def test_bool_extra_not_used(self, *, bool_: bool) -> None:
+        def serializer(int_: int, /) -> str:
+            return f"({int_})"
+
+        serialized = serialize_object(bool_, extra={int: serializer})
+        expected = str(bool_)
+        assert serialized == expected
+
     @given(int_=integers())
     def test_type_with_extra(self, *, int_: int) -> None:
         obj = DataClassFutureInt(int_=int_)

{dycw_utilities-0.110.8 → dycw_utilities-0.111.1}/src/tests/test_typing.py

@@ -10,7 +10,19 @@ from typing import TYPE_CHECKING, Any, Literal, NamedTuple, Self
 from uuid import UUID
 
 from hypothesis import given
-from hypothesis.strategies import DataObject, data, just, none, sampled_from
+from hypothesis.strategies import (
+    DataObject,
+    SearchStrategy,
+    booleans,
+    data,
+    dates,
+    datetimes,
+    floats,
+    integers,
+    just,
+    none,
+    sampled_from,
+)
 from pytest import mark, param, raises
 
 from tests.test_typing_funcs.no_future import (
@@ -42,15 +54,19 @@ 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 (
-    _GetUnionTypeClassesNotATypeError,
-    _GetUnionTypeClassesNotAUnionTypeError,
+    _GetTypeClassesTupleError,
+    _GetTypeClassesTypeError,
+    _GetUnionTypeClassesInternalTypeError,
+    _GetUnionTypeClassesUnionTypeError,
     contains_self,
     get_args,
     get_literal_elements,
+    get_type_classes,
     get_type_hints,
     get_union_type_classes,
     is_dict_type,
     is_frozenset_type,
+    is_instance_gen,
     is_list_type,
     is_literal_type,
     is_mapping_type,
@@ -59,6 +75,7 @@ from utilities.typing import (
     is_optional_type,
     is_sequence_type,
     is_set_type,
+    is_subclass_gen,
     is_tuple_type,
     is_union_type,
 )
@@ -118,6 +135,38 @@ class TestGetLiteralElements:
         assert result == expected
 
 
+class TestGetTypeClasses:
+    @given(
+        case=sampled_from([
+            (int, (int,)),
+            ((int, float), (int, float)),
+            (Duration, (int, float, dt.timedelta)),
+            (Number, (int, float)),
+            (Seed, (int, float, str, bytes, bytearray, Random)),
+            ((int, Number), (int, int, float)),
+            ((int, (Number,)), (int, int, float)),
+        ])
+    )
+    def test_main(self, *, case: tuple[Any, tuple[type[Any], ...]]) -> None:
+        obj, expected = case
+        result = get_type_classes(obj)
+        assert result == expected
+
+    def test_error_type(self) -> None:
+        with raises(
+            _GetTypeClassesTypeError,
+            match="Object must be a type, tuple or Union type; got None",
+        ):
+            _ = get_type_classes(None)
+
+    def test_error_tuple(self) -> None:
+        with raises(
+            _GetTypeClassesTupleError,
+            match="Tuple must contain types, tuples or Union types only; got None",
+        ):
+            _ = get_type_classes((None,))
+
+
 class TestGetTypeHints:
     @given(data=data())
     def test_date(self, *, data: DataObject) -> None:
@@ -352,16 +401,16 @@ class TestGetUnionTypeClasses:
         result = get_union_type_classes(obj)
         assert result == expected
 
-    def test_error_not_a_union_type(self) -> None:
+    def test_error_union_type(self) -> None:
         with raises(
-            _GetUnionTypeClassesNotAUnionTypeError,
+            _GetUnionTypeClassesUnionTypeError,
             match="Object must be a Union type; got None",
         ):
             _ = get_union_type_classes(None)
 
-    def test_error_not_a_type(self) -> None:
+    def test_error_interal_type(self) -> None:
         with raises(
-            _GetUnionTypeClassesNotATypeError,
+            _GetUnionTypeClassesInternalTypeError,
             match=r"Union type must contain types only; got typing\.Literal\[True\]",
         ):
             _ = get_union_type_classes(Literal[True] | None)
@@ -438,6 +487,46 @@ class TestIsAnnotationOfType:
         assert func(obj) is expected
 
 
+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),
+        ]),
+    )
+    def test_main(
+        self, *, data: DataObject, case: tuple[SearchStrategy[Any], Any, bool]
+    ) -> None:
+        strategy, type_, expected = case
+        value = data.draw(strategy)
+        assert is_instance_gen(value, type_) is expected
+
+    @given(bool_=booleans())
+    def test_bool_value_vs_custom_int(self, *, bool_: bool) -> None:
+        class MyInt(int): ...
+
+        assert not is_instance_gen(bool_, MyInt)
+
+    @given(int_=integers())
+    def test_int_value_vs_custom_int(self, *, int_: int) -> None:
+        class MyInt(int): ...
+
+        assert not is_instance_gen(int_, MyInt)
+        assert is_instance_gen(MyInt(int_), MyInt)
+
+
 class TestIsNamedTuple:
     def test_main(self) -> None:
         class Example(NamedTuple):
@@ -453,3 +542,35 @@ class TestIsNamedTuple:
 
         assert not is_namedtuple_class(Example)
         assert not is_namedtuple_instance(Example(x=0))
+
+
+class TestIsSubclassGen:
+    @given(
+        case=sampled_from([
+            (bool, bool, True),
+            (bool, int, False),
+            (int, bool, False),
+            (int, int, True),
+            (bool, (bool, int), True),
+            (int, (bool, int), True),
+            (dt.date, dt.date, True),
+            (dt.date, dt.datetime, False),
+            (dt.datetime, dt.date, False),
+            (dt.datetime, dt.datetime, True),
+            (bool, Number, False),
+            (int, Number, True),
+            (float, Number, True),
+        ])
+    )
+    def test_main(self, *, case: tuple[type[Any], Any, bool]) -> None:
+        child, parent, expected = case
+        assert is_subclass_gen(child, parent) is expected
+
+    def test_custom_int(self) -> None:
+        class MyInt(int): ...
+
+        assert not is_subclass_gen(bool, MyInt)
+        assert not is_subclass_gen(MyInt, bool)
+        assert not is_subclass_gen(int, MyInt)
+        assert is_subclass_gen(MyInt, int)
+        assert is_subclass_gen(MyInt, MyInt)

{dycw_utilities-0.110.8 → dycw_utilities-0.111.1}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.110.8"
+__version__ = "0.111.1"

{dycw_utilities-0.110.8 → dycw_utilities-0.111.1}/src/utilities/datetime.py

@@ -22,6 +22,7 @@ from utilities.math import SafeRoundError, round_, safe_round
 from utilities.platform import SYSTEM
 from utilities.sentinel import Sentinel, sentinel
 from utilities.types import MaybeStr
+from utilities.typing import is_instance_gen
 from utilities.zoneinfo import (
     UTC,
     HongKong,
@@ -140,9 +141,9 @@ def are_equal_dates_or_datetimes(
     x: DateOrDateTime, y: DateOrDateTime, /, *, strict: bool = False
 ) -> bool:
     """Check if x == y for dates/datetimes."""
-    if is_instance_date_not_datetime(x) and is_instance_date_not_datetime(y):
+    if is_instance_gen(x, dt.date) and is_instance_gen(y, dt.date):
         return x == y
-    if isinstance(x, dt.datetime) and isinstance(y, dt.datetime):
+    if is_instance_gen(x, dt.datetime) and is_instance_gen(y, dt.datetime):
         return are_equal_datetimes(x, y, strict=strict)
     raise AreEqualDatesOrDateTimesError(x=x, y=y)
 
@@ -210,7 +211,7 @@ def are_equal_months(x: DateOrMonth, y: DateOrMonth, /) -> bool:
 
 def check_date_not_datetime(date: dt.date, /) -> None:
     """Check if a date is not a datetime."""
-    if not is_instance_date_not_datetime(date):
+    if not is_instance_gen(date, dt.date):
         raise CheckDateNotDateTimeError(date=date)
 
 
@@ -604,14 +605,6 @@ YEAR = get_years(n=1)
 ##
 
 
-def is_instance_date_not_datetime(obj: Any, /) -> TypeGuard[dt.date]:
-    """Check if an object is a date, and not a datetime."""
-    return isinstance(obj, dt.date) and not isinstance(obj, dt.datetime)
-
-
-##
-
-
 def is_integral_timedelta(timedelta: dt.timedelta, /) -> bool:
     """Check if a timedelta is integral."""
     return (timedelta.seconds == 0) and (timedelta.microseconds == 0)
@@ -628,14 +621,6 @@ def is_local_datetime(obj: Any, /) -> TypeGuard[dt.datetime]:
 ##
 
 
-def is_subclass_date_not_datetime(cls: type[Any], /) -> TypeGuard[type[dt.date]]:
-    """Check if a class is a date, and not a datetime."""
-    return issubclass(cls, dt.date) and not issubclass(cls, dt.datetime)
-
-
-##
-
-
 _FRIDAY = 5
 
 
@@ -1359,10 +1344,8 @@ __all__ = [
     "get_today_local",
     "get_today_tokyo",
     "get_years",
-    "is_instance_date_not_datetime",
     "is_integral_timedelta",
     "is_local_datetime",
-    "is_subclass_date_not_datetime",
     "is_weekday",
     "is_zero_time",
     "is_zoned_datetime",

{dycw_utilities-0.110.8 → dycw_utilities-0.111.1}/src/utilities/functions.py

@@ -22,7 +22,6 @@ from typing import (
     Literal,
     TypeGuard,
     TypeVar,
-    assert_never,
     cast,
     overload,
     override,
@@ -660,28 +659,6 @@ def is_hashable(obj: Any, /) -> TypeGuard[Hashable]:
 ##
 
 
-def is_instance_not_bool_int(
-    obj: Any, class_or_tuple: TypeLike[Any], /
-) -> TypeGuard[int]:
-    """Check if an instance relationship holds, except bool<int."""
-    match class_or_tuple:
-        case type() as type_:
-            return _is_instance_not_bool_int(obj, type_)
-        case tuple() as types:
-            return any(_is_instance_not_bool_int(obj, p) for p in types)
-        case _ as never:
-            assert_never(never)
-
-
-def _is_instance_not_bool_int(obj: Any, type_: type[Any], /) -> bool:
-    return isinstance(obj, type_) and not (
-        isinstance(obj, bool) and issubclass(type_, int) and not issubclass(type_, bool)
-    )
-
-
-##
-
-
 @overload
 def is_iterable_of(obj: Any, cls: type[_T], /) -> TypeGuard[Iterable[_T]]: ...
 @overload
@@ -796,28 +773,6 @@ def is_string_mapping(obj: Any, /) -> TypeGuard[StrMapping]:
 ##
 
 
-def is_subclass_not_bool_int(cls: type[Any], class_or_tuple: TypeLike[Any], /) -> bool:
-    """Check if a subclass relationship holds, except bool<int."""
-    match class_or_tuple:
-        case type() as parent:
-            return _is_subclass_int_not_bool_one(cls, parent)
-        case tuple() as parents:
-            return any(_is_subclass_int_not_bool_one(cls, p) for p in parents)
-        case _ as never:
-            assert_never(never)
-
-
-def _is_subclass_int_not_bool_one(cls: type[Any], parent: type[Any], /) -> bool:
-    return issubclass(cls, parent) and not (
-        issubclass(cls, bool)
-        and issubclass(parent, int)
-        and not issubclass(parent, bool)
-    )
-
-
-##
-
-
 def is_tuple(obj: Any, /) -> TypeGuard[tuple[Any, ...]]:
     """Check if an object is a tuple or string mapping."""
     return make_isinstance(tuple)(obj)
@@ -1075,7 +1030,6 @@ __all__ = [
     "is_dataclass_class",
     "is_dataclass_instance",
     "is_hashable",
-    "is_instance_not_bool_int",
     "is_iterable_of",
     "is_none",
     "is_not_none",
@@ -1083,7 +1037,6 @@ __all__ = [
     "is_sized",
     "is_sized_not_str",
     "is_string_mapping",
-    "is_subclass_not_bool_int",
     "is_tuple",
     "is_tuple_or_str_mapping",
     "make_isinstance",

{dycw_utilities-0.110.8 → dycw_utilities-0.111.1}/src/utilities/orjson.py

@@ -692,6 +692,7 @@ _LOG_RECORD_DEFAULT_ATTRS = {
     "exc_text",
     "filename",
     "funcName",
+    "getMessage",
     "levelname",
     "levelno",
     "lineno",