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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.154.0
+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.154.0 → 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.154.0"
+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.154.0"
+current_version = "0.155.0"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.154.0 → 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.154.0 → 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.154.0 → 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.154.0 → dycw_utilities-0.155.0}/src/tests/test_logging.py

@@ -12,7 +12,7 @@ from hypothesis.strategies import booleans, integers
 from pytest import LogCaptureFixture, mark, param, raises
 
 from tests.conftest import SKIPIF_CI_AND_WINDOWS
-from utilities.hypothesis import pairs, temp_paths, text_ascii, zoned_datetimes
+from utilities.hypothesis import pairs, temp_paths, text_ascii, zoned_date_times
 from utilities.iterables import one
 from utilities.logging import (
     GetLoggingLevelNumberError,
@@ -274,7 +274,7 @@ class TestRotatingLogFile:
         assert result.start is None
         assert result.end is None
 
-    @given(index=integers(min_value=1), end=zoned_datetimes())
+    @given(index=integers(min_value=1), end=zoned_date_times())
     def test_from_path_with_index_and_end(
         self, *, index: int, end: ZonedDateTime
     ) -> None:
@@ -287,7 +287,9 @@ class TestRotatingLogFile:
         assert result.start is None
         assert result.end == end.round()
 
-    @given(index=integers(min_value=1), datetimes=pairs(zoned_datetimes(), sorted=True))
+    @given(
+        index=integers(min_value=1), datetimes=pairs(zoned_date_times(), sorted=True)
+    )
     def test_from_path_with_index_start_and_end(
         self, *, index: int, datetimes: tuple[ZonedDateTime, ZonedDateTime]
     ) -> None:
@@ -315,7 +317,7 @@ class TestRotatingLogFile:
         file = _RotatingLogFile(directory=root, stem="log", suffix=".txt", index=index)
         assert file.path == root.joinpath(f"log.{index}.txt")
 
-    @given(root=temp_paths(), index=integers(min_value=1), end=zoned_datetimes())
+    @given(root=temp_paths(), index=integers(min_value=1), end=zoned_date_times())
     def test_path_with_index_and_end(
         self, *, root: Path, index: int, end: ZonedDateTime
     ) -> None:
@@ -327,7 +329,7 @@ class TestRotatingLogFile:
     @given(
         root=temp_paths(),
         index=integers(min_value=1),
-        datetimes=pairs(zoned_datetimes(), sorted=True),
+        datetimes=pairs(zoned_date_times(), sorted=True),
     )
     def test_path_with_index_start_and_end(
         self, *, root: Path, index: int, datetimes: tuple[ZonedDateTime, ZonedDateTime]

{dycw_utilities-0.154.0 → dycw_utilities-0.155.0}/src/tests/test_objects/objects.py

@@ -37,20 +37,23 @@ from tests.test_typing_funcs.with_future import (
 from utilities.hypothesis import (
     assume_does_not_raise,
     date_deltas,
+    date_periods,
     date_time_deltas,
     dates,
     int64s,
     month_days,
     paths,
-    plain_datetimes,
+    plain_date_times,
     py_datetimes,
     text_ascii,
     text_printable,
     time_deltas,
+    time_periods,
     times,
     versions,
     year_months,
-    zoned_datetimes,
+    zoned_date_time_periods,
+    zoned_date_times,
 )
 from utilities.math import MAX_INT64, MIN_INT64
 
@@ -82,6 +85,7 @@ def objects(
 ) -> SearchStrategy[Any]:
     base = (
         booleans()
+        | date_periods()
         | dates()
         | hypothesis.strategies.dates()
         | py_datetimes(zoned=booleans())
@@ -90,15 +94,17 @@ def objects(
         | month_days()
         | none()
         | paths()
-        | plain_datetimes()
+        | plain_date_times()
         | text_printable().filter(lambda x: not x.startswith("["))
         | time_deltas()
+        | time_periods()
         | times()
         | hypothesis.strategies.times()
         | uuids()
         | versions()
         | year_months()
-        | zoned_datetimes()
+        | zoned_date_time_periods()
+        | zoned_date_times()
     )
     if dataclass_custom_equality:
         base |= builds(DataClassFutureCustomEquality)

{dycw_utilities-0.154.0 → dycw_utilities-0.155.0}/src/tests/test_orjson.py

@@ -52,13 +52,15 @@ from tests.test_typing_funcs.with_future import (
 )
 from utilities.functions import is_sequence_of
 from utilities.hypothesis import (
+    date_periods,
     dates,
     int64s,
     paths,
     temp_paths,
     text_ascii,
     text_printable,
-    zoned_datetimes,
+    time_periods,
+    zoned_date_times,
 )
 from utilities.iterables import always_iterable, one
 from utilities.logging import get_logging_level_number
@@ -84,7 +86,7 @@ from utilities.sentinel import Sentinel, sentinel
 from utilities.types import LogLevel, MaybeIterable, PathLike
 from utilities.typing import get_args
 from utilities.tzlocal import LOCAL_TIME_ZONE
-from utilities.whenever import MINUTE, SECOND, get_now
+from utilities.whenever import MINUTE, SECOND, DatePeriod, TimePeriod, get_now
 
 if TYPE_CHECKING:
     from collections.abc import Sequence
@@ -203,9 +205,9 @@ class TestGetLogRecords:
         date=dates() | none(),
         min_date=dates() | none(),
         max_date=dates() | none(),
-        datetime=zoned_datetimes() | none(),
-        min_datetime=zoned_datetimes() | none(),
-        max_datetime=zoned_datetimes() | none(),
+        datetime=zoned_date_times() | none(),
+        min_datetime=zoned_date_times() | none(),
+        max_datetime=zoned_date_times() | none(),
         func_name=booleans() | text_ascii() | none(),
         extra=booleans() | text_ascii() | sets(text_ascii()) | none(),
         log_file=booleans() | paths() | text_ascii() | none(),
@@ -581,6 +583,11 @@ class TestSerializeAndDeserialize:
         ):
             _ = deserialize(ser, objects=set())
 
+    @given(period=date_periods())
+    def test_date_periods(self, *, period: DatePeriod) -> None:
+        result = deserialize(serialize(period))
+        assert result == period
+
     def test_deserialize_hook(self) -> None:
         obj = DataClassFutureDefaultInInitChild()
         ser = serialize(obj)
@@ -645,6 +652,11 @@ class TestSerializeAndDeserialize:
         result = deserialize(serialize(obj), objects={SubTuple})
         assert is_equal(result, obj)
 
+    @given(period=time_periods())
+    def test_time_periods(self, *, period: TimePeriod) -> None:
+        result = deserialize(serialize(period))
+        assert result == period
+
     def test_unserializable(self) -> None:
         ser = serialize(sentinel)
         exp_ser = b'{"[dc|Unserializable]":{"qualname":"Sentinel","repr":"<sentinel>","str":"<sentinel>"}}'
@@ -666,7 +678,7 @@ class TestSerialize:
     def test_dataclass(self) -> None:
         obj = DataClassFutureNone(none=None)
         result = serialize(obj)
-        expected = b'{"[dc|DataClassFutureNone]":{"none":"[none]"}}'
+        expected = b'{"[dc|DataClassFutureNone]":{"none":"[0]"}}'
         assert result == expected
 
     def test_dataclass_nested(self) -> None:
@@ -708,6 +720,11 @@ class TestSerialize:
         expected = b'{"[ex|TestSerialize.test_exception_instance.<locals>.CustomError]":{"[tu]":[1,2,3]}}'
         assert result == expected
 
+    def test_none(self) -> None:
+        result = serialize(None)
+        expected = b'"[0]"'
+        assert result == expected
+
     @given(x=sampled_from([MIN_INT64 - 1, MAX_INT64 + 1]))
     def test_pre_process(self, *, x: int) -> None:
         with raises(_SerializeIntegerError, match="Integer .* is out of range"):