dycw-utilities 0.109.27__tar.gz → 0.109.29__tar.gz

{dycw_utilities-0.109.27 → dycw_utilities-0.109.29}/PKG-INFO

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

{dycw_utilities-0.109.27 → dycw_utilities-0.109.29}/pyproject.toml

@@ -40,6 +40,7 @@ dev = [
   "optuna >= 4.3.0, < 4.4",
   "orjson >= 3.10.16, < 3.11",
   "pathvalidate >= 3.2.3, < 3.3",
+  "polars >= 1.27.1, < 1.28",
   "polars-lts-cpu >= 1.27.1, < 1.28",
   "polars-ols >= 0.3.5, < 0.4",
   "pqdm >= 0.2.0, < 0.3",
@@ -93,7 +94,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.109.27"
+version = "0.109.29"
 
 [project.optional-dependencies]
 test = [
@@ -336,7 +337,7 @@ zzz-test-zoneinfo = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.109.27"
+current_version = "0.109.29"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.109.27 → dycw_utilities-0.109.29}/src/tests/test_datetime.py

@@ -995,7 +995,7 @@ class TestMonth:
             _ = Month(2000, 13)
 
 
-class TestParseAndSerializeMonth:
+class TestSerializeAndParseMonth:
     @given(month=months())
     def test_main(self, *, month: Month) -> None:
         serialized = serialize_month(month)

{dycw_utilities-0.109.27 → dycw_utilities-0.109.29}/src/tests/test_parse.py

@@ -5,10 +5,21 @@ from collections.abc import Iterable
 from dataclasses import dataclass
 from pathlib import Path
 from types import NoneType
-from typing import Literal
+from typing import Final, Literal
 
 from hypothesis import given
-from hypothesis.strategies import booleans, dates, floats, integers, sampled_from, times
+from hypothesis.strategies import (
+    booleans,
+    dates,
+    dictionaries,
+    floats,
+    frozensets,
+    integers,
+    lists,
+    sampled_from,
+    sets,
+    times,
+)
 from pytest import raises
 
 from tests.test_operator import TruthEnum
@@ -38,53 +49,53 @@ from utilities.parse import (
     _ParseTextExtraNonUniqueError,
     _ParseTextParseError,
     parse_text,
+    to_text,
 )
 from utilities.sentinel import Sentinel, sentinel
 from utilities.types import Duration, Number
 from utilities.version import Version
-from utilities.whenever import (
-    serialize_date,
-    serialize_datetime,
-    serialize_duration,
-    serialize_time,
-    serialize_timedelta,
-)
 
 
-class TestParseText:
+class TestToAndParseText:
     @given(value=booleans())
     def test_bool(self, *, value: bool) -> None:
-        text = str(value)
+        text = to_text(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)
+        text = to_text(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)
+        text = to_text(datetime)
         result = parse_text(dt.datetime, text)
         assert result == datetime
 
+    @given(value=dictionaries(dates(), zoned_datetimes()))
+    def test_dict(self, *, value: dict[dt.date, dt.datetime]) -> None:
+        text = to_text(value)
+        result = parse_text(dict[dt.date, dt.datetime], text)
+        assert result == value
+
     @given(duration=datetime_durations(two_way=True))
     def test_duration(self, *, duration: Duration) -> None:
-        text = serialize_duration(duration)
+        text = to_text(duration)
         result = parse_text(Duration, text)
         assert result == duration
 
     @given(truth=sampled_from(TruthEnum))
     def test_enum(self, *, truth: TruthEnum) -> None:
-        text = truth.name
+        text = to_text(truth)
         result = parse_text(TruthEnum, text)
         assert result is truth
 
     @given(value=integers())
     def test_extra_type(self, *, value: int) -> None:
-        text = str(value)
+        text = to_text(value)
         result = parse_text(
             DataClassFutureInt,
             text,
@@ -95,108 +106,126 @@ class TestParseText:
 
     @given(value=floats())
     def test_float(self, *, value: float) -> None:
-        text = str(value)
+        text = to_text(value)
         result = parse_text(float, text)
         assert is_equal(result, value)
 
+    @given(values=frozensets(dates()))
+    def test_frozenset(self, *, values: frozenset[dt.date]) -> None:
+        text = to_text(values)
+        result = parse_text(frozenset[dt.date], text)
+        assert result == values
+
     @given(value=integers())
     def test_int(self, *, value: int) -> None:
-        text = str(value)
+        text = to_text(value)
         result = parse_text(int, text)
         assert result == value
 
+    @given(values=lists(dates()))
+    def test_list(self, *, values: list[dt.date]) -> None:
+        text = to_text(values)
+        result = parse_text(list[dt.date], text)
+        assert result == values
+
     @given(truth=sampled_from(["true", "false"]))
     def test_literal(self, *, truth: Literal["true", "false"]) -> None:
         result = parse_text(TrueOrFalseFutureLit, truth)
         assert result == truth
 
     def test_none(self) -> None:
-        text = str(None)
+        text = to_text(None)
         result = parse_text(None, text)
         assert result is None
 
     def test_none_type(self) -> None:
-        text = str(None)
+        text = to_text(None)
         result = parse_text(NoneType, text)
         assert result is None
 
     @given(number=numbers())
     def test_number(self, *, number: Number) -> None:
-        text = str(number)
+        text = to_text(number)
         result = parse_text(Number, text)
         assert result == number
 
     @given(path=paths())
     def test_path(self, *, path: Path) -> None:
-        text = str(path)
+        text = to_text(path)
         result = parse_text(Path, text)
         assert result == path
 
     @given(path=paths())
     def test_path_expanded(self, *, path: Path) -> None:
         path_use = Path("~", path)
-        text = str(path_use)
+        text = to_text(path_use)
         result = ensure_path(parse_text(Path, text))
         assert result == result.expanduser()
 
     def test_nullable_number_none(self) -> None:
-        text = str(None)
+        text = to_text(None)
         result = parse_text(Number | None, text)
         assert result is None
 
     @given(number=numbers())
     def test_nullable_number_number(self, *, number: Number) -> None:
-        text = str(number)
+        text = to_text(number)
         result = parse_text(Number | None, text)
         assert result == number
 
     def test_nullable_duration_none(self) -> None:
-        text = str(None)
+        text = to_text(None)
         result = parse_text(Duration | None, text)
         assert result is None
 
     @given(duration=datetime_durations(two_way=True))
     def test_nullable_duration_duration(self, *, duration: Duration) -> None:
-        text = serialize_duration(duration)
+        text = to_text(duration)
         result = parse_text(Duration | None, text)
         assert result == duration
 
     def test_nullable_int_none(self) -> None:
-        text = str(None)
+        text = to_text(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)
+        text = to_text(value)
         result = parse_text(int | None, text)
         assert result == value
 
     def test_sentinel(self) -> None:
-        text = str(sentinel)
+        text = to_text(sentinel)
         result = parse_text(Sentinel, text)
         assert result is sentinel
 
+    @given(values=sets(dates()))
+    def test_set(self, *, values: set[dt.date]) -> None:
+        text = to_text(values)
+        result = parse_text(set[dt.date], text)
+        assert result == values
+
     @given(text=text_ascii())
-    def test_str(self, *, text: str) -> None:
+    def test_to_text(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)
+        text = to_text(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)
+        text = to_text(timedelta)
         result = parse_text(dt.timedelta, text)
         assert result == timedelta
 
     @given(x=integers(), y=integers())
     def test_tuple(self, *, x: int, y: int) -> None:
-        text = f"({x}, {y})"
+        text = to_text((x, y))
         result = parse_text(tuple[int, int], text)
         assert result == (x, y)
 
@@ -217,7 +246,7 @@ class TestParseText:
                 case _:
                     raise ImpossibleCaseError(case=[f"{value=}"])
 
-        text = str(value)
+        text = to_text(value)
         result = parse_text(
             DataClassFutureIntEvenOrOddTypeUnion,
             text,
@@ -244,7 +273,7 @@ class TestParseText:
                 case _:
                     raise ImpossibleCaseError(case=[f"{value=}"])
 
-        text = str(value)
+        text = to_text(value)
         result = parse_text(
             DataClassFutureIntEvenOrOddUnion,
             text,
@@ -261,10 +290,12 @@ class TestParseText:
 
     @given(version=versions())
     def test_version(self, *, version: Version) -> None:
-        text = str(version)
+        text = to_text(version)
         result = parse_text(Version, text)
         assert result == version
 
+
+class TestParseText:
     def test_error_bool(self) -> None:
         with raises(
             _ParseTextParseError, match="Unable to parse <class 'bool'>; got 'invalid'"
@@ -285,6 +316,20 @@ class TestParseText:
         ):
             _ = parse_text(dt.datetime, "invalid")
 
+    def test_error_dict_extract_group(self) -> None:
+        with raises(
+            _ParseTextParseError,
+            match=r"Unable to parse dict\[int, int\]; got 'invalid'",
+        ):
+            _ = parse_text(dict[int, int], "invalid")
+
+    def test_error_dict_internal(self) -> None:
+        with raises(
+            _ParseTextParseError,
+            match=r"Unable to parse dict\[int, int\]; got '\{invalid=invalid\}'",
+        ):
+            _ = parse_text(dict[int, int], "{invalid=invalid}")
+
     def test_error_duration(self) -> None:
         with raises(
             _ParseTextParseError, match=r"Unable to parse Duration; got 'invalid'"
@@ -324,7 +369,7 @@ class TestParseText:
         ):
             _ = parse_text(
                 Child,
-                str(value),
+                to_text(value),
                 extra={
                     Parent1: lambda text: Child(x=int(text)),
                     Parent2: lambda text: Child(y=int(text)),
@@ -344,12 +389,39 @@ class TestParseText:
         ):
             _ = parse_text(float, "invalid")
 
+    def test_error_frozenset_extract_group(self) -> None:
+        with raises(
+            _ParseTextParseError,
+            match=r"Unable to parse frozenset\[int\]; got 'invalid'",
+        ):
+            _ = parse_text(frozenset[int], "invalid")
+
+    def test_error_frozenset_internal(self) -> None:
+        with raises(
+            _ParseTextParseError,
+            match=r"Unable to parse frozenset\[int\]; got '\{invalid\}'",
+        ):
+            _ = parse_text(frozenset[int], "{invalid}")
+
     def test_error_int(self) -> None:
         with raises(
             _ParseTextParseError, match="Unable to parse <class 'int'>; got 'invalid'"
         ):
             _ = parse_text(int, "invalid")
 
+    def test_error_list_extract_group(self) -> None:
+        with raises(
+            _ParseTextParseError, match=r"Unable to parse list\[int\]; got 'invalid'"
+        ):
+            _ = parse_text(list[int], "invalid")
+
+    def test_error_list_internal(self) -> None:
+        with raises(
+            _ParseTextParseError,
+            match=r"Unable to parse list\[int\]; got '\[invalid\]'",
+        ):
+            _ = parse_text(list[int], "[invalid]")
+
     def test_error_none(self) -> None:
         with raises(_ParseTextParseError, match="Unable to parse None; got 'invalid'"):
             _ = parse_text(None, "invalid")
@@ -387,6 +459,18 @@ class TestParseText:
         ):
             _ = parse_text(Sentinel, "invalid")
 
+    def test_error_set_extract_group(self) -> None:
+        with raises(
+            _ParseTextParseError, match=r"Unable to parse set\[int\]; got 'invalid'"
+        ):
+            _ = parse_text(set[int], "invalid")
+
+    def test_error_set_internal(self) -> None:
+        with raises(
+            _ParseTextParseError, match=r"Unable to parse set\[int\]; got '\{invalid\}'"
+        ):
+            _ = parse_text(set[int], "{invalid}")
+
     def test_error_time(self) -> None:
         with raises(
             _ParseTextParseError,
@@ -401,34 +485,35 @@ class TestParseText:
         ):
             _ = parse_text(dt.timedelta, "invalid")
 
-    def test_error_tuple_invalid_text(self) -> None:
+    def test_error_tuple_extract_group(self) -> None:
         with raises(
             _ParseTextParseError,
             match=r"Unable to parse tuple\[int, int\]; got 'invalid'",
         ):
             _ = parse_text(tuple[int, int], "invalid")
 
-    def test_error_tuple_inconsistent_args_and_texts(self) -> None:
+    def test_error_tuple_internal(self) -> None:
         with raises(
             _ParseTextParseError,
-            match=r"Unable to parse tuple\[int, int\]; got '\(text1, text2, text3\)'",
+            match=r"Unable to parse tuple\[int, int\]; got '\(invalid,invalid\)'",
         ):
-            _ = parse_text(tuple[int, int], "(text1, text2, text3)")
+            _ = parse_text(tuple[int, int], "(invalid,invalid)")
 
-    def test_error_unknown_annotation(self) -> None:
+    def test_error_tuple_inconsistent_args_and_texts(self) -> None:
         with raises(
-            _ParseTextParseError, match=r"Unable to parse int \| str; got 'invalid'"
+            _ParseTextParseError,
+            match=r"Unable to parse tuple\[int, int\]; got '\(text1, text2, text3\)'",
         ):
-            _ = parse_text(int | str, "invalid")
+            _ = parse_text(tuple[int, int], "(text1, text2, text3)")
 
-    def test_error_unknown_type(self) -> None:
+    def test_error_type_not_implemented(self) -> None:
         with raises(
             _ParseTextParseError,
             match=r"Unable to parse <class 'tests\.test_typing_funcs\.with_future\.DataClassFutureInt'>; got 'invalid'",
         ):
             _ = parse_text(DataClassFutureInt, "invalid")
 
-    def test_error_unknown_union_type(self) -> None:
+    def test_error_union_not_implemented(self) -> None:
         with raises(
             _ParseTextParseError,
             match=r"Unable to parse tests\.test_typing_funcs\.with_future\.DataClassFutureIntEven \| tests\.test_typing_funcs\.with_future\.DataClassFutureIntOdd; got 'invalid'",
@@ -441,3 +526,9 @@ class TestParseText:
             match=r"Unable to parse <class 'utilities\.version\.Version'>; got 'invalid'",
         ):
             _ = parse_text(Version, "invalid")
+
+
+class TestToText:
+    def test_error_not_implemented(self) -> None:
+        with raises(NotImplementedError):
+            _ = to_text(Final)

{dycw_utilities-0.109.27 → dycw_utilities-0.109.29}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.109.27"
+__version__ = "0.109.29"