dycw-utilities 0.153.15__tar.gz → 0.155.0__tar.gz

{dycw_utilities-0.153.15 → dycw_utilities-0.155.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.153.15
+Version: 0.155.0
 Author-email: Derek Wan <d.wan@icloud.com>
 License-File: LICENSE
 Requires-Python: >=3.12
@@ -12,7 +12,7 @@ Provides-Extra: logging
 Requires-Dist: coloredlogs<15.1,>=15.0.1; extra == 'logging'
 Provides-Extra: test
 Requires-Dist: dycw-pytest-only<2.2,>=2.1.1; extra == 'test'
-Requires-Dist: hypothesis<6.137,>=6.136.7; extra == 'test'
+Requires-Dist: hypothesis<6.138,>=6.137.1; extra == 'test'
 Requires-Dist: pudb<2025.2,>=2025.1; extra == 'test'
 Requires-Dist: pytest-asyncio<1.2,>=1.1.0; extra == 'test'
 Requires-Dist: pytest-cov<6.3,>=6.2.1; extra == 'test'

{dycw_utilities-0.153.15 → dycw_utilities-0.155.0}/pyproject.toml

@@ -69,7 +69,7 @@ http-test = [
   "orjson",
 ]
 hypothesis = [
-  "hypothesis >=6.136.7, <6.137",
+  "hypothesis >=6.137.1, <6.138",
 ]
 hypothesis-test = [
   "libcst",
@@ -119,7 +119,7 @@ orjson-test = [
   "polars",
 ]
 polars = [
-  "polars >=1.32.0, <1.33",
+  "polars >=1.32.2, <1.33",
 ]
 polars-ols = [
   "polars-ols >=0.3.5, <0.4",
@@ -168,7 +168,7 @@ pytest-test = [
   "pytest-rerunfailures",
 ]
 redis = [
-  "redis >=6.2.0, <6.3",
+  "redis >=6.4.0, <6.5",
   "orjson",
 ]
 redis-test = [
@@ -229,7 +229,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.153.15"
+version = "0.155.0"
 
 [project.entry-points.pytest11]
 pytest-randomly = "utilities.pytest_plugins.pytest_randomly"
@@ -241,7 +241,7 @@ logging = [
 ]
 test = [
   "dycw-pytest-only >=2.1.1, <2.2",
-  "hypothesis >=6.136.7, <6.137",
+  "hypothesis >=6.137.1, <6.138",
   "pudb >=2025.1, <2025.2",
   "pytest >=8.4.1, <8.5",
   "pytest-asyncio >=1.1.0, <1.2",
@@ -262,7 +262,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.153.15"
+current_version = "0.155.0"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.153.15 → dycw_utilities-0.155.0}/src/tests/conftest.py

@@ -7,13 +7,11 @@ from typing import TYPE_CHECKING
 
 from hypothesis import HealthCheck
 from pytest import fixture, mark, param, skip
-from whenever import PlainDateTime
 
 from utilities.contextlib import enhanced_context_manager
 from utilities.platform import IS_MAC, IS_NOT_LINUX, IS_WINDOWS
 from utilities.re import ExtractGroupError, extract_group
-from utilities.tzlocal import LOCAL_TIME_ZONE_NAME
-from utilities.whenever import MINUTE, get_now
+from utilities.whenever import MINUTE, get_now, parse_plain_local
 
 if TYPE_CHECKING:
     from collections.abc import AsyncIterator, Iterator, Sequence
@@ -174,11 +172,7 @@ def _is_to_drop(table: str, /) -> bool:
         datetime_str = extract_group(r"^(\d{8}T\d{6})_", table)
     except ExtractGroupError:
         return True
-    datetime = PlainDateTime.parse_common_iso(datetime_str).assume_tz(
-        LOCAL_TIME_ZONE_NAME
-    )
-    now = get_now()
-    return (now - datetime) >= MINUTE
+    return (get_now() - parse_plain_local(datetime_str)) >= MINUTE
 
 
 def _select_tables() -> TextClause:

{dycw_utilities-0.153.15 → dycw_utilities-0.155.0}/src/tests/test_altair.py

@@ -27,7 +27,7 @@ from utilities.altair import (
     vconcat_charts,
 )
 from utilities.functions import ensure_class
-from utilities.hypothesis import dates, text_ascii, zoned_datetimes
+from utilities.hypothesis import dates, text_ascii, zoned_date_times
 from utilities.polars import DatetimeUTC, zoned_datetime_dtype
 from utilities.tzdata import HongKong, Tokyo
 from utilities.whenever import get_now
@@ -119,7 +119,7 @@ class TestPlotDataFrames:
         )
         _ = plot_dataframes(df, x="index", y="value")
 
-    @given(data=lists(tuples(zoned_datetimes(), floats(-10, 10))))
+    @given(data=lists(tuples(zoned_date_times(), floats(-10, 10))))
     def test_tooltip_format_date_time(
         self, *, data: list[tuple[ZonedDateTime, float]]
     ) -> None:

{dycw_utilities-0.153.15 → dycw_utilities-0.155.0}/src/tests/test_click.py

@@ -57,12 +57,12 @@ from utilities.hypothesis import (
     date_time_deltas,
     dates,
     month_days,
-    plain_datetimes,
+    plain_date_times,
     text_ascii,
     time_deltas,
     times,
     year_months,
-    zoned_datetimes,
+    zoned_date_times,
 )
 from utilities.text import join_strs, strip_and_dedent
 
@@ -304,7 +304,7 @@ class TestParameters:
         _Case(
             param=PlainDateTime(),
             name="plain date-time",
-            strategy=plain_datetimes(),
+            strategy=plain_date_times(),
             serialize=whenever.PlainDateTime.format_common_iso,
             failable=True,
         ),
@@ -335,7 +335,7 @@ class TestParameters:
         _Case(
             param=ZonedDateTime(),
             name="zoned date-time",
-            strategy=zoned_datetimes(),
+            strategy=zoned_date_times(),
             serialize=whenever.ZonedDateTime.format_common_iso,
             failable=True,
         ),

{dycw_utilities-0.153.15 → dycw_utilities-0.155.0}/src/tests/test_hypothesis.py

@@ -5,7 +5,7 @@ from pathlib import Path
 from re import search
 from typing import TYPE_CHECKING, Any, cast
 
-from hypothesis import Phase, assume, given, settings
+from hypothesis import assume, given, settings
 from hypothesis.errors import InvalidArgument
 from hypothesis.extra.numpy import array_shapes
 from hypothesis.strategies import (
@@ -46,6 +46,7 @@ from utilities.hypothesis import (
     assume_does_not_raise,
     bool_arrays,
     date_deltas,
+    date_periods,
     date_time_deltas,
     dates,
     draw2,
@@ -57,6 +58,8 @@ from utilities.hypothesis import (
     hashables,
     import_froms,
     imports,
+    int8s,
+    int16s,
     int32s,
     int64s,
     int_arrays,
@@ -65,7 +68,7 @@ from utilities.hypothesis import (
     numbers,
     pairs,
     paths,
-    plain_datetimes,
+    plain_date_times,
     random_states,
     sentinels,
     sets_fixed_length,
@@ -82,6 +85,7 @@ from utilities.hypothesis import (
     text_digits,
     text_printable,
     time_deltas,
+    time_periods,
     times,
     triples,
     uint8s,
@@ -91,13 +95,16 @@ from utilities.hypothesis import (
     urls,
     versions,
     year_months,
-    zoned_datetimes,
+    zoned_date_time_periods,
+    zoned_date_times,
 )
 from utilities.iterables import one
 from utilities.libcst import parse_import
 from utilities.math import (
     MAX_FLOAT32,
     MAX_FLOAT64,
+    MAX_INT8,
+    MAX_INT16,
     MAX_INT32,
     MAX_INT64,
     MAX_UINT8,
@@ -106,6 +113,8 @@ from utilities.math import (
     MAX_UINT64,
     MIN_FLOAT32,
     MIN_FLOAT64,
+    MIN_INT8,
+    MIN_INT16,
     MIN_INT32,
     MIN_INT64,
     MIN_UINT8,
@@ -120,12 +129,14 @@ from utilities.version import Version
 from utilities.whenever import (
     DATE_TWO_DIGIT_YEAR_MAX,
     DATE_TWO_DIGIT_YEAR_MIN,
+    DatePeriod,
+    TimePeriod,
+    ZonedDateTimePeriod,
     to_days,
     to_nanoseconds,
 )
 
 if TYPE_CHECKING:
-    from collections.abc import Iterable
     from collections.abc import Set as AbstractSet
     from zoneinfo import ZoneInfo
 
@@ -195,6 +206,20 @@ class TestDateDeltas:
             assert DateDelta.parse_common_iso(delta.format_common_iso()) == delta
 
 
+class TestDatePeriods:
+    @given(data=data())
+    def test_main(self, *, data: DataObject) -> None:
+        min_value = data.draw(dates() | none())
+        max_value = data.draw(dates() | none())
+        with assume_does_not_raise(InvalidArgument):
+            period = data.draw(date_periods(min_value=min_value, max_value=max_value))
+        assert isinstance(period, DatePeriod)
+        if min_value is not None:
+            assert period.start >= min_value
+        if max_value is not None:
+            assert period.end <= max_value
+
+
 class TestDateTimeDeltas:
     @given(data=data(), parsable=booleans())
     def test_main(self, *, data: DataObject, parsable: bool) -> None:
@@ -347,17 +372,27 @@ class TestDraw2:
 class TestFloat32s:
     @given(data=data())
     def test_main(self, *, data: DataObject) -> None:
-        min_value, max_value = data.draw(pairs(float32s(), sorted=True))
-        x = data.draw(float32s(min_value=min_value, max_value=max_value))
-        assert max(min_value, MIN_FLOAT32) <= x <= min(max_value, MAX_FLOAT32)
+        min_value, max_value = data.draw(pairs(float32s() | none()))
+        with assume_does_not_raise(InvalidArgument):
+            x = data.draw(float32s(min_value=min_value, max_value=max_value))
+        assert MIN_FLOAT32 <= x <= MAX_FLOAT32
+        if min_value is not None:
+            assert x >= min_value
+        if max_value is not None:
+            assert x <= max_value
 
 
 class TestFloat64s:
     @given(data=data())
     def test_main(self, *, data: DataObject) -> None:
-        min_value, max_value = data.draw(pairs(float64s(), sorted=True))
-        x = data.draw(float64s(min_value=min_value, max_value=max_value))
-        assert max(min_value, MIN_FLOAT64) <= x <= min(max_value, MAX_FLOAT64)
+        min_value, max_value = data.draw(pairs(float64s() | none()))
+        with assume_does_not_raise(InvalidArgument):
+            x = data.draw(float64s(min_value=min_value, max_value=max_value))
+        assert MIN_FLOAT64 <= x <= MAX_FLOAT64
+        if min_value is not None:
+            assert x >= min_value
+        if max_value is not None:
+            assert x <= max_value
 
 
 class TestFloatArrays:
@@ -574,20 +609,56 @@ class TestIntArrays:
             assert len(set(flat)) == len(flat)
 
 
+class TestInt8s:
+    @given(data=data())
+    def test_main(self, *, data: DataObject) -> None:
+        min_value, max_value = data.draw(pairs(int8s() | none()))
+        with assume_does_not_raise(InvalidArgument):
+            x = data.draw(int8s(min_value=min_value, max_value=max_value))
+        assert MIN_INT8 <= x <= MAX_INT8
+        if min_value is not None:
+            assert x >= min_value
+        if max_value is not None:
+            assert x <= max_value
+
+
+class TestInt16s:
+    @given(data=data())
+    def test_main(self, *, data: DataObject) -> None:
+        min_value, max_value = data.draw(pairs(int16s() | none()))
+        with assume_does_not_raise(InvalidArgument):
+            x = data.draw(int16s(min_value=min_value, max_value=max_value))
+        assert MIN_INT16 <= x <= MAX_INT16
+        if min_value is not None:
+            assert x >= min_value
+        if max_value is not None:
+            assert x <= max_value
+
+
 class TestInt32s:
     @given(data=data())
     def test_main(self, *, data: DataObject) -> None:
-        min_value, max_value = data.draw(pairs(int32s(), sorted=True))
-        x = data.draw(int32s(min_value=min_value, max_value=max_value))
-        assert max(min_value, MIN_INT32) <= x <= min(max_value, MAX_INT32)
+        min_value, max_value = data.draw(pairs(int32s() | none()))
+        with assume_does_not_raise(InvalidArgument):
+            x = data.draw(int32s(min_value=min_value, max_value=max_value))
+        assert MIN_INT32 <= x <= MAX_INT32
+        if min_value is not None:
+            assert x >= min_value
+        if max_value is not None:
+            assert x <= max_value
 
 
 class TestInt64s:
     @given(data=data())
     def test_main(self, *, data: DataObject) -> None:
-        min_value, max_value = data.draw(pairs(int64s(), sorted=True))
-        x = data.draw(int64s(min_value=min_value, max_value=max_value))
-        assert max(min_value, MIN_INT64) <= x <= min(max_value, MAX_INT64)
+        min_value, max_value = data.draw(pairs(int64s() | none()))
+        with assume_does_not_raise(InvalidArgument):
+            x = data.draw(int64s(min_value=min_value, max_value=max_value))
+        assert MIN_INT64 <= x <= MAX_INT64
+        if min_value is not None:
+            assert x >= min_value
+        if max_value is not None:
+            assert x <= max_value
 
 
 class TestListsFixedLength:
@@ -671,11 +742,11 @@ class TestPaths:
 class TestPlainDateTimes:
     @given(data=data())
     def test_main(self, *, data: DataObject) -> None:
-        min_value = data.draw(plain_datetimes() | none())
-        max_value = data.draw(plain_datetimes() | none())
+        min_value = data.draw(plain_date_times() | none())
+        max_value = data.draw(plain_date_times() | none())
         with assume_does_not_raise(InvalidArgument):
             datetime = data.draw(
-                plain_datetimes(min_value=min_value, max_value=max_value)
+                plain_date_times(min_value=min_value, max_value=max_value)
             )
         assert isinstance(datetime, PlainDateTime)
         assert PlainDateTime.parse_common_iso(datetime.format_common_iso()) == datetime
@@ -722,13 +793,11 @@ class TestSetupHypothesisProfiles:
     def test_main(self) -> None:
         setup_hypothesis_profiles()
         curr = settings()
-        assert Phase.shrink in cast("Iterable[Phase]", curr.phases)
         assert curr.max_examples in {10, 100, 1000}
 
     def test_no_shrink(self) -> None:
         with temp_environ({"HYPOTHESIS_NO_SHRINK": "1"}):
             setup_hypothesis_profiles()
-        assert Phase.shrink not in cast("Iterable[Phase]", settings().phases)
 
     @given(max_examples=integers(1, 100))
     def test_max_examples(self, *, max_examples: int) -> None:
@@ -926,6 +995,20 @@ class TestTimeDeltas:
             assert delta <= max_value
 
 
+class TestTimePeriods:
+    @given(data=data())
+    def test_main(self, *, data: DataObject) -> None:
+        min_value = data.draw(times() | none())
+        max_value = data.draw(times() | none())
+        with assume_does_not_raise(InvalidArgument):
+            period = data.draw(time_periods(min_value=min_value, max_value=max_value))
+        assert isinstance(period, TimePeriod)
+        if min_value is not None:
+            assert period.start >= min_value
+        if max_value is not None:
+            assert period.end <= max_value
+
+
 class TestTimes:
     @given(data=data())
     def test_main(self, *, data: DataObject) -> None:
@@ -958,33 +1041,53 @@ class TestTriples:
 class TestUInt8s:
     @given(data=data())
     def test_main(self, *, data: DataObject) -> None:
-        min_value, max_value = data.draw(pairs(uint8s(), sorted=True))
-        x = data.draw(uint8s(min_value=min_value, max_value=max_value))
-        assert max(min_value, MIN_UINT8) <= x <= min(max_value, MAX_UINT8)
+        min_value, max_value = data.draw(pairs(uint8s() | none()))
+        with assume_does_not_raise(InvalidArgument):
+            x = data.draw(uint8s(min_value=min_value, max_value=max_value))
+        assert MIN_UINT8 <= x <= MAX_UINT8
+        if min_value is not None:
+            assert x >= min_value
+        if max_value is not None:
+            assert x <= max_value
 
 
 class TestUInt16s:
     @given(data=data())
     def test_main(self, *, data: DataObject) -> None:
-        min_value, max_value = data.draw(pairs(uint16s(), sorted=True))
-        x = data.draw(uint16s(min_value=min_value, max_value=max_value))
-        assert max(min_value, MIN_UINT16) <= x <= min(max_value, MAX_UINT16)
+        min_value, max_value = data.draw(pairs(uint16s() | none()))
+        with assume_does_not_raise(InvalidArgument):
+            x = data.draw(uint16s(min_value=min_value, max_value=max_value))
+        assert MIN_UINT16 <= x <= MAX_UINT16
+        if min_value is not None:
+            assert x >= min_value
+        if max_value is not None:
+            assert x <= max_value
 
 
 class TestUInt32s:
     @given(data=data())
     def test_main(self, *, data: DataObject) -> None:
-        min_value, max_value = data.draw(pairs(uint32s(), sorted=True))
-        x = data.draw(uint32s(min_value=min_value, max_value=max_value))
-        assert max(min_value, MIN_UINT32) <= x <= min(max_value, MAX_UINT32)
+        min_value, max_value = data.draw(pairs(uint32s() | none()))
+        with assume_does_not_raise(InvalidArgument):
+            x = data.draw(uint32s(min_value=min_value, max_value=max_value))
+        assert MIN_UINT32 <= x <= MAX_UINT32
+        if min_value is not None:
+            assert x >= min_value
+        if max_value is not None:
+            assert x <= max_value
 
 
 class TestUInt64s:
     @given(data=data())
     def test_main(self, *, data: DataObject) -> None:
-        min_value, max_value = data.draw(pairs(uint64s(), sorted=True))
-        x = data.draw(uint64s(min_value=min_value, max_value=max_value))
-        assert max(min_value, MIN_UINT64) <= x <= min(max_value, MAX_UINT64)
+        min_value, max_value = data.draw(pairs(uint64s() | none()))
+        with assume_does_not_raise(InvalidArgument):
+            x = data.draw(uint64s(min_value=min_value, max_value=max_value))
+        assert MIN_UINT64 <= x <= MAX_UINT64
+        if min_value is not None:
+            assert x >= min_value
+        if max_value is not None:
+            assert x <= max_value
 
 
 class TestURLs:
@@ -1063,14 +1166,33 @@ class TestYearMonths:
             assert year_month.on_day(28) <= DATE_TWO_DIGIT_YEAR_MAX
 
 
+class TestZonedDateTimePeriods:
+    @given(data=data(), time_zone=timezones())
+    def test_main(self, *, data: DataObject, time_zone: ZoneInfo) -> None:
+        min_value = data.draw(zoned_date_times() | none())
+        max_value = data.draw(zoned_date_times() | none())
+        with assume_does_not_raise(InvalidArgument):
+            period = data.draw(
+                zoned_date_time_periods(
+                    min_value=min_value, max_value=max_value, time_zone=time_zone
+                )
+            )
+        assert isinstance(period, ZonedDateTimePeriod)
+        assert period.time_zone is time_zone
+        if min_value is not None:
+            assert period.start >= min_value
+        if max_value is not None:
+            assert period.end <= max_value
+
+
 class TestZonedDateTimes:
     @given(data=data(), time_zone=timezones())
     def test_main(self, *, data: DataObject, time_zone: ZoneInfo) -> None:
-        min_value = data.draw(zoned_datetimes() | none())
-        max_value = data.draw(zoned_datetimes() | none())
+        min_value = data.draw(zoned_date_times() | none())
+        max_value = data.draw(zoned_date_times() | none())
         with assume_does_not_raise(InvalidArgument):
             datetime = data.draw(
-                zoned_datetimes(
+                zoned_date_times(
                     min_value=min_value, max_value=max_value, time_zone=time_zone
                 )
             )
@@ -1087,5 +1209,5 @@ class TestZonedDateTimes:
     def test_examples(self, *, data: DataObject, time_zone: ZoneInfo) -> None:
         with assume_does_not_raise(TimeZoneNotFoundError):
             max_value = ZonedDateTime(1, 1, 2, tz=time_zone.key)
-        datetime = data.draw(zoned_datetimes(max_value=max_value, time_zone=time_zone))
+        datetime = data.draw(zoned_date_times(max_value=max_value, time_zone=time_zone))
         _ = datetime.py_datetime()

{dycw_utilities-0.153.15 → dycw_utilities-0.155.0}/src/tests/test_iterables.py

@@ -94,7 +94,6 @@ from utilities.iterables import (
     enumerate_with_edge,
     expanding_window,
     filter_include_and_exclude,
-    group_consecutive_integers,
     groupby_lists,
     hashable_to_iterable,
     is_iterable,
@@ -117,7 +116,6 @@ from utilities.iterables import (
     sum_mappings,
     take,
     transpose,
-    ungroup_consecutive_integers,
     unique_everseen,
 )
 from utilities.sentinel import Sentinel, sentinel
@@ -745,18 +743,6 @@ class TestFilterIncludeAndExclude:
         assert result == expected
 
 
-class TestGroupAndUngroupConsecutiveIntegers:
-    @given(xs=lists(integers(), unique=True).map(sorted))
-    def test_main(self, *, xs: list[int]) -> None:
-        result = list(ungroup_consecutive_integers(group_consecutive_integers(xs)))
-        assert result == xs
-
-    def test_example(self) -> None:
-        result = list(group_consecutive_integers([1, 2, 3, 6, 7, 10, 11, 12]))
-        expected = [(1, 3), (6, 7), (10, 12)]
-        assert result == expected
-
-
 class TestGroupbyLists:
     iterable: ClassVar[str] = "AAAABBBCCDAABB"