dycw-utilities 0.154.0__py3-none-any.whl → 0.155.1__py3-none-any.whl

{dycw_utilities-0.154.0.dist-info → dycw_utilities-0.155.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.154.0
+Version: 0.155.1
 Author-email: Derek Wan <d.wan@icloud.com>
 License-File: LICENSE
 Requires-Python: >=3.12
@@ -12,8 +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: pudb<2025.2,>=2025.1; extra == 'test'
+Requires-Dist: hypothesis<6.138,>=6.137.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'
 Requires-Dist: pytest-instafail<0.6,>=0.5.0; extra == 'test'

{dycw_utilities-0.154.0.dist-info → dycw_utilities-0.155.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-utilities/__init__.py,sha256=AggdQNmHiytWszaBPt8g3NE_WaSx4IoGrhZ8f-NLdAI,60
+utilities/__init__.py,sha256=VUm6D-MbPENpEcdDNizwkQ7ZdWupTs1IZmUsMeC93k0,60
 utilities/altair.py,sha256=92E2lCdyHY4Zb-vCw6rEJIsWdKipuu-Tu2ab1ufUfAk,9079
 utilities/asyncio.py,sha256=QXkTtugXkqtYt7Do23zgYErqzdp6jwzPpV_SP9fJ1gI,16780
 utilities/atomicwrites.py,sha256=tPo6r-Rypd9u99u66B9z86YBPpnLrlHtwox_8Z7T34Y,5790
@@ -22,7 +22,7 @@ utilities/getpass.py,sha256=DfN5UgMAtFCqS3dSfFHUfqIMZX2shXvwphOz_6J6f6A,103
 utilities/gzip.py,sha256=fkGP3KdsBfXlstodT4wtlp-PwNyUsogpbDCVVVGdsm4,781
 utilities/hashlib.py,sha256=SVTgtguur0P4elppvzOBbLEjVM3Pea0eWB61yg2ilxo,309
 utilities/http.py,sha256=TsavEfHlRtlLaeV21Z6KZh0qbPw-kvD1zsQdZ7Kep5Q,977
-utilities/hypothesis.py,sha256=m44niSfuzuhgn7IQ1UOwUGgiu68xz4a6LHxB0IE6fNE,40341
+utilities/hypothesis.py,sha256=2lAUvuXj_zswg-8Ot0ZuBzTbZyaRYWRmeR8qSF7Mmys,43817
 utilities/importlib.py,sha256=mV1xT_O_zt_GnZZ36tl3xOmMaN_3jErDWY54fX39F6Y,429
 utilities/inflect.py,sha256=v7YkOWSu8NAmVghPcf4F3YBZQoJCS47_DLf9jbfWIs0,581
 utilities/ipython.py,sha256=V2oMYHvEKvlNBzxDXdLvKi48oUq2SclRg5xasjaXStw,763
@@ -39,13 +39,13 @@ utilities/more_itertools.py,sha256=rklJ5vpvXr_H5pAGpWmwVpqtBVehoJ0-jBGYsZbux3M,1
 utilities/numpy.py,sha256=Xn23sA2ZbVNqwUYEgNJD3XBYH6IbCri_WkHSNhg3NkY,26122
 utilities/operator.py,sha256=nhxn5q6CFNzUm1wpTwWPCu9JGCqVHSlaJf0o1-efoII,3616
 utilities/optuna.py,sha256=C-fhWYiXHVPo1l8QctYkFJ4DyhbSrGorzP1dJb_qvd8,1933
-utilities/orjson.py,sha256=Gzxn-s55pGFKV8DdsYXpp-Gr3r-5KdacYUd_GHMBogM,40088
+utilities/orjson.py,sha256=Ll0U172ITMqOJc3kjV90C0eI-EWzSXlMHSdUBaUSe80,41499
 utilities/os.py,sha256=mFvjydySvjtSXpk7tLStUJcndauAoujxUUmj_CO7LWY,3778
 utilities/parse.py,sha256=JcJn5yXKhIWXBCwgBdPsyu7Hvcuw6kyEdqvaebCaI9k,17951
 utilities/pathlib.py,sha256=qGuU8XPmdgGpy8tOMUgelfXx3kxI8h9IaV3TI_06QGE,8428
 utilities/pickle.py,sha256=MBT2xZCsv0pH868IXLGKnlcqNx2IRVKYNpRcqiQQqxw,653
 utilities/platform.py,sha256=pTn7gw6N4T6LdKrf0virwarof_mze9WtoQlrGMzhGVI,2798
-utilities/polars.py,sha256=I07Bk_Vp2T434qXkCKxSVQIkFJc1d8YkOH48fprypB0,78436
+utilities/polars.py,sha256=yedkwwcyX35lreA2CeOGVRyOrXrs8DKk98T9dWpnxCo,79844
 utilities/polars_ols.py,sha256=Uc9V5kvlWZ5cU93lKZ-cfAKdVFFw81tqwLW9PxtUvMs,5618
 utilities/postgres.py,sha256=ynCTTaF-bVEOSW-KEAR-dlLh_hYjeVVjm__-4pEU8Zk,12269
 utilities/pottery.py,sha256=HJ96oLRarTP37Vhg0WTyB3yAu2hETeg6HgRmpDIqyUs,6581
@@ -54,7 +54,7 @@ utilities/psutil.py,sha256=KUlu4lrUw9Zg1V7ZGetpWpGb9DB8l_SSDWGbANFNCPU,2104
 utilities/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 utilities/pyinstrument.py,sha256=NZCZz2nBo0BLJ9DTf7H_Q_KGxvsf2S2M3h0qYoYh2kw,804
 utilities/pytest.py,sha256=2HHfAWkzZeK2OAzL2F49EDKooMkfDoGqg8Ev4cHC_N8,7869
-utilities/pytest_regressions.py,sha256=ocjHTtfOeiGfQAKIei8pKNd61sxN9dawrJJ9gPt2wzA,4097
+utilities/pytest_regressions.py,sha256=8by5DWEL89Y469TI5AzX1pMy3NJWVtjEg2xQdOOdYuM,4169
 utilities/random.py,sha256=hZlH4gnAtoaofWswuJYjcygejrY8db4CzP-z_adO2Mo,4165
 utilities/re.py,sha256=S4h-DLL6ScMPqjboZ_uQ1BVTJajrqV06r_81D--_HCE,4573
 utilities/redis.py,sha256=2fdveFbqL2pEAeyiVuN_Je8nSM_IZHeahPduMHhFRzY,28381
@@ -72,23 +72,23 @@ utilities/tempfile.py,sha256=HxB2BF28CcecDJLQ3Bx2Ej-Pb6RJc6W9ngSpB9CnP4k,2018
 utilities/text.py,sha256=uwCDgpEunYruyh6sKMfNWK3Rp5H3ndpKRAkq86CBNys,13043
 utilities/threading.py,sha256=GvBOp4CyhHfN90wGXZuA2VKe9fGzMaEa7oCl4f3nnPU,1009
 utilities/timer.py,sha256=oXfTii6ymu57niP0BDGZjFD55LEHi2a19kqZKiTgaFQ,2588
-utilities/traceback.py,sha256=TjO7em98FDFLvROZ7gi2UJftFWNuSTkbCrf7mk-fg28,9416
+utilities/traceback.py,sha256=1k5JgumSMaqAGLd0dZ36CtPS0EGaglxTr29r2Dz4D60,9457
 utilities/typed_settings.py,sha256=SFWqS3lAzV7IfNRwqFcTk0YynTcQ7BmrcW2mr_KUnos,4466
 utilities/types.py,sha256=L4cjFPyFZX58Urfw0S_i-XRywPIFyuSLOieewj0qqsM,18516
-utilities/typing.py,sha256=Z-_XDaWyT_6wIo3qfNK-hvRlzxP2Jxa9PgXzm5rDYRA,13790
+utilities/typing.py,sha256=7ZgCNZwA6oaiwpSJIS9Rj3i3MbRBYHMqbC3jMe5KiNg,13992
 utilities/tzdata.py,sha256=fgNVj66yUbCSI_-vrRVzSD3gtf-L_8IEJEPjP_Jel5Y,266
 utilities/tzlocal.py,sha256=KyCXEgCTjqGFx-389JdTuhMRUaT06U1RCMdWoED-qro,728
 utilities/uuid.py,sha256=nQZs6tFX4mqtc2Ku3KqjloYCqwpTKeTj8eKwQwh3FQI,1572
 utilities/version.py,sha256=ipBj5-WYY_nelp2uwFlApfWWCzTLzPwpovUi9x_OBMs,5085
 utilities/warnings.py,sha256=un1LvHv70PU-LLv8RxPVmugTzDJkkGXRMZTE2-fTQHw,1771
-utilities/whenever.py,sha256=gPnFKWws4_tjiHPLzX1AukSwDjfMIO9Iim0DDNQyAqY,57532
+utilities/whenever.py,sha256=vsoVRd8-KXVn9Ik5PveIGgOCuIGnMNqSEoPCsR0sZ30,57755
 utilities/zipfile.py,sha256=24lQc9ATcJxHXBPc_tBDiJk48pWyRrlxO2fIsFxU0A8,699
 utilities/zoneinfo.py,sha256=FBMcUQ4662Aq8SsuCL1OAhDQiyANmVjtb-C30DRrWoE,1966
 utilities/pytest_plugins/__init__.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
 utilities/pytest_plugins/pytest_randomly.py,sha256=B1qYVlExGOxTywq2r1SMi5o7btHLk2PNdY_b1p98dkE,409
 utilities/pytest_plugins/pytest_regressions.py,sha256=9v8kAXDM2ycIXJBimoiF4EgrwbUvxTycFWJiGR_GHhM,1466
-dycw_utilities-0.154.0.dist-info/METADATA,sha256=34hYZf8Cdia0JBt2zwn4AaQY6m0S7qY5VfKXDDjw6OY,1696
-dycw_utilities-0.154.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dycw_utilities-0.154.0.dist-info/entry_points.txt,sha256=BOD_SoDxwsfJYOLxhrSXhHP_T7iw-HXI9f2WVkzYxvQ,135
-dycw_utilities-0.154.0.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
-dycw_utilities-0.154.0.dist-info/RECORD,,
+dycw_utilities-0.155.1.dist-info/METADATA,sha256=t4j9mkVdOy56nqyYGTiiODz6Zq0dOJUFTTz_4CTcQTg,1643
+dycw_utilities-0.155.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dycw_utilities-0.155.1.dist-info/entry_points.txt,sha256=BOD_SoDxwsfJYOLxhrSXhHP_T7iw-HXI9f2WVkzYxvQ,135
+dycw_utilities-0.155.1.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
+dycw_utilities-0.155.1.dist-info/RECORD,,

utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.154.0"
+__version__ = "0.155.1"

utilities/hypothesis.py

@@ -50,10 +50,12 @@ from whenever import (
     ZonedDateTime,
 )
 
-from utilities.functions import ensure_int, ensure_str
+from utilities.functions import ensure_int, ensure_str, max_nullable, min_nullable
 from utilities.math import (
     MAX_FLOAT32,
     MAX_FLOAT64,
+    MAX_INT8,
+    MAX_INT16,
     MAX_INT32,
     MAX_INT64,
     MAX_UINT8,
@@ -62,6 +64,8 @@ from utilities.math import (
     MAX_UINT64,
     MIN_FLOAT32,
     MIN_FLOAT64,
+    MIN_INT8,
+    MIN_INT16,
     MIN_INT32,
     MIN_INT64,
     MIN_UINT8,
@@ -90,6 +94,9 @@ from utilities.whenever import (
     DAY,
     TIME_DELTA_MAX,
     TIME_DELTA_MIN,
+    DatePeriod,
+    TimePeriod,
+    ZonedDateTimePeriod,
     to_date_time_delta,
     to_days,
     to_nanoseconds,
@@ -201,6 +208,26 @@ def date_deltas(
 ##
 
 
+@composite
+def date_periods(
+    draw: DrawFn,
+    /,
+    *,
+    min_value: MaybeSearchStrategy[Date | None] = None,
+    max_value: MaybeSearchStrategy[Date | None] = None,
+    two_digit: MaybeSearchStrategy[bool] = False,
+) -> DatePeriod:
+    """Strategy for generating date periods."""
+    min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
+    two_digit_ = draw2(draw, two_digit)
+    strategy = dates(min_value=min_value_, max_value=max_value_, two_digit=two_digit_)
+    start, end = draw(pairs(strategy, sorted=True))
+    return DatePeriod(start, end)
+
+
+##
+
+
 @composite
 def date_time_deltas(
     draw: DrawFn,
@@ -209,6 +236,7 @@ def date_time_deltas(
     min_value: MaybeSearchStrategy[DateTimeDelta | None] = None,
     max_value: MaybeSearchStrategy[DateTimeDelta | None] = None,
     parsable: MaybeSearchStrategy[bool] = False,
+    nativable: MaybeSearchStrategy[bool] = False,
 ) -> DateTimeDelta:
     """Strategy for generating date deltas."""
     min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
@@ -230,7 +258,13 @@ def date_time_deltas(
     if draw2(draw, parsable):
         min_nanos = max(min_nanos, to_nanoseconds(DATE_TIME_DELTA_PARSABLE_MIN))
         max_nanos = min(max_nanos, to_nanoseconds(DATE_TIME_DELTA_PARSABLE_MAX))
-    nanos = draw(integers(min_value=min_nanos, max_value=max_nanos))
+    if draw2(draw, nativable):
+        min_micros, _ = divmod(min_nanos, 1000)
+        max_micros, _ = divmod(max_nanos, 1000)
+        micros = draw(integers(min_value=min_micros + 1, max_value=max_micros))
+        nanos = 1000 * micros
+    else:
+        nanos = draw(integers(min_value=min_nanos, max_value=max_nanos))
     return to_date_time_delta(nanos)
 
 
@@ -373,13 +407,13 @@ def float32s(
     draw: DrawFn,
     /,
     *,
-    min_value: MaybeSearchStrategy[float] = MIN_FLOAT32,
-    max_value: MaybeSearchStrategy[float] = MAX_FLOAT32,
+    min_value: MaybeSearchStrategy[float | None] = None,
+    max_value: MaybeSearchStrategy[float | None] = None,
 ) -> float:
     """Strategy for generating float32s."""
     min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
-    min_value_ = max(min_value_, MIN_FLOAT32)
-    max_value_ = min(max_value_, MAX_FLOAT32)
+    min_value_ = max_nullable([min_value_, MIN_FLOAT32])
+    max_value_ = min_nullable([max_value_, MAX_FLOAT32])
     if is_zero(min_value_) and is_zero(max_value_):
         min_value_ = max_value_ = 0.0
     return draw(floats(min_value_, max_value_, width=32))
@@ -390,13 +424,13 @@ def float64s(
     draw: DrawFn,
     /,
     *,
-    min_value: MaybeSearchStrategy[float] = MIN_FLOAT64,
-    max_value: MaybeSearchStrategy[float] = MAX_FLOAT64,
+    min_value: MaybeSearchStrategy[float | None] = None,
+    max_value: MaybeSearchStrategy[float | None] = None,
 ) -> float:
     """Strategy for generating float64s."""
     min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
-    min_value_ = max(min_value_, MIN_FLOAT64)
-    max_value_ = min(max_value_, MAX_FLOAT64)
+    min_value_ = max_nullable([min_value_, MIN_FLOAT64])
+    max_value_ = min_nullable([max_value_, MAX_FLOAT64])
     if is_zero(min_value_) and is_zero(max_value_):
         min_value_ = max_value_ = 0.0
     return draw(floats(min_value_, max_value_, width=64))
@@ -601,18 +635,48 @@ def int_arrays(
 ##
 
 
+@composite
+def int8s(
+    draw: DrawFn,
+    /,
+    *,
+    min_value: MaybeSearchStrategy[int | None] = None,
+    max_value: MaybeSearchStrategy[int | None] = None,
+) -> int:
+    """Strategy for generating int8s."""
+    min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
+    min_value_ = max_nullable([min_value_, MIN_INT8])
+    max_value_ = min_nullable([max_value_, MAX_INT8])
+    return draw(integers(min_value=min_value_, max_value=max_value_))
+
+
+@composite
+def int16s(
+    draw: DrawFn,
+    /,
+    *,
+    min_value: MaybeSearchStrategy[int | None] = None,
+    max_value: MaybeSearchStrategy[int | None] = None,
+) -> int:
+    """Strategy for generating int16s."""
+    min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
+    min_value_ = max_nullable([min_value_, MIN_INT16])
+    max_value_ = min_nullable([max_value_, MAX_INT16])
+    return draw(integers(min_value=min_value_, max_value=max_value_))
+
+
 @composite
 def int32s(
     draw: DrawFn,
     /,
     *,
-    min_value: MaybeSearchStrategy[int] = MIN_INT32,
-    max_value: MaybeSearchStrategy[int] = MAX_INT32,
+    min_value: MaybeSearchStrategy[int | None] = None,
+    max_value: MaybeSearchStrategy[int | None] = None,
 ) -> int:
     """Strategy for generating int32s."""
     min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
-    min_value_ = max(min_value_, MIN_INT32)
-    max_value_ = min(max_value_, MAX_INT32)
+    min_value_ = max_nullable([min_value_, MIN_INT32])
+    max_value_ = min_nullable([max_value_, MAX_INT32])
     return draw(integers(min_value_, max_value_))
 
 
@@ -621,13 +685,13 @@ def int64s(
     draw: DrawFn,
     /,
     *,
-    min_value: MaybeSearchStrategy[int] = MIN_INT64,
-    max_value: MaybeSearchStrategy[int] = MAX_INT64,
+    min_value: MaybeSearchStrategy[int | None] = None,
+    max_value: MaybeSearchStrategy[int | None] = None,
 ) -> int:
     """Strategy for generating int64s."""
     min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
-    min_value_ = max(min_value_, MIN_INT64)
-    max_value_ = min(max_value_, MAX_INT64)
+    min_value_ = max_nullable([min_value_, MIN_INT64])
+    max_value_ = min_nullable([max_value_, MAX_INT64])
     return draw(integers(min_value_, max_value_))
 
 
@@ -780,7 +844,7 @@ def _path_parts(draw: DrawFn, /) -> str:
 
 
 @composite
-def plain_datetimes(
+def plain_date_times(
     draw: DrawFn,
     /,
     *,
@@ -1174,6 +1238,24 @@ def time_deltas(
 ##
 
 
+@composite
+def time_periods(
+    draw: DrawFn,
+    /,
+    *,
+    min_value: MaybeSearchStrategy[Time | None] = None,
+    max_value: MaybeSearchStrategy[Time | None] = None,
+) -> TimePeriod:
+    """Strategy for generating time periods."""
+    min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
+    strategy = times(min_value=min_value_, max_value=max_value_)
+    start, end = draw(pairs(strategy, sorted=True))
+    return TimePeriod(start, end)
+
+
+##
+
+
 @composite
 def times(
     draw: DrawFn,
@@ -1235,13 +1317,13 @@ def uint8s(
     draw: DrawFn,
     /,
     *,
-    min_value: MaybeSearchStrategy[int] = MIN_UINT8,
-    max_value: MaybeSearchStrategy[int] = MAX_UINT8,
+    min_value: MaybeSearchStrategy[int | None] = None,
+    max_value: MaybeSearchStrategy[int | None] = None,
 ) -> int:
     """Strategy for generating uint8s."""
     min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
-    min_value_ = max(min_value_, MIN_UINT8)
-    max_value_ = min(max_value_, MAX_UINT8)
+    min_value_ = max_nullable([min_value_, MIN_UINT8])
+    max_value_ = min_nullable([max_value_, MAX_UINT8])
     return draw(integers(min_value=min_value_, max_value=max_value_))
 
 
@@ -1250,13 +1332,13 @@ def uint16s(
     draw: DrawFn,
     /,
     *,
-    min_value: MaybeSearchStrategy[int] = MIN_UINT16,
-    max_value: MaybeSearchStrategy[int] = MAX_UINT16,
+    min_value: MaybeSearchStrategy[int | None] = None,
+    max_value: MaybeSearchStrategy[int | None] = None,
 ) -> int:
     """Strategy for generating uint16s."""
     min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
-    min_value_ = max(min_value_, MIN_UINT16)
-    max_value_ = min(max_value_, MAX_UINT16)
+    min_value_ = max_nullable([min_value_, MIN_UINT16])
+    max_value_ = min_nullable([max_value_, MAX_UINT16])
     return draw(integers(min_value=min_value_, max_value=max_value_))
 
 
@@ -1265,13 +1347,13 @@ def uint32s(
     draw: DrawFn,
     /,
     *,
-    min_value: MaybeSearchStrategy[int] = MIN_UINT32,
-    max_value: MaybeSearchStrategy[int] = MAX_UINT32,
+    min_value: MaybeSearchStrategy[int | None] = None,
+    max_value: MaybeSearchStrategy[int | None] = None,
 ) -> int:
     """Strategy for generating uint32s."""
     min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
-    min_value_ = max(min_value_, MIN_UINT32)
-    max_value_ = min(max_value_, MAX_UINT32)
+    min_value_ = max_nullable([min_value_, MIN_UINT32])
+    max_value_ = min_nullable([max_value_, MAX_UINT32])
     return draw(integers(min_value=min_value_, max_value=max_value_))
 
 
@@ -1280,13 +1362,13 @@ def uint64s(
     draw: DrawFn,
     /,
     *,
-    min_value: MaybeSearchStrategy[int] = MIN_UINT64,
-    max_value: MaybeSearchStrategy[int] = MAX_UINT64,
+    min_value: MaybeSearchStrategy[int | None] = None,
+    max_value: MaybeSearchStrategy[int | None] = None,
 ) -> int:
     """Strategy for generating uint64s."""
     min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
-    min_value_ = max(min_value_, MIN_UINT64)
-    max_value_ = min(max_value_, MAX_UINT64)
+    min_value_ = max_nullable([min_value_, MIN_UINT64])
+    max_value_ = min_nullable([max_value_, MAX_UINT64])
     return draw(integers(min_value=min_value_, max_value=max_value_))
 
 
@@ -1374,7 +1456,29 @@ def year_months(
 
 
 @composite
-def zoned_datetimes(
+def zoned_date_time_periods(
+    draw: DrawFn,
+    /,
+    *,
+    min_value: MaybeSearchStrategy[PlainDateTime | ZonedDateTime | None] = None,
+    max_value: MaybeSearchStrategy[PlainDateTime | ZonedDateTime | None] = None,
+    time_zone: MaybeSearchStrategy[TimeZoneLike] = UTC,
+) -> ZonedDateTimePeriod:
+    """Strategy for generating zoned date-time periods."""
+    min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
+    time_zone_: TimeZoneLike = draw2(draw, time_zone)
+    strategy = zoned_date_times(
+        min_value=min_value_, max_value=max_value_, time_zone=time_zone_
+    )
+    start, end = draw(pairs(strategy, sorted=True))
+    return ZonedDateTimePeriod(start, end)
+
+
+##
+
+
+@composite
+def zoned_date_times(
     draw: DrawFn,
     /,
     *,
@@ -1382,7 +1486,7 @@ def zoned_datetimes(
     max_value: MaybeSearchStrategy[PlainDateTime | ZonedDateTime | None] = None,
     time_zone: MaybeSearchStrategy[TimeZoneLike] = UTC,
 ) -> ZonedDateTime:
-    """Strategy for generating zoned datetimes."""
+    """Strategy for generating zoned date-times."""
     min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
     time_zone_ = ensure_time_zone(draw2(draw, time_zone))
     match min_value_:
@@ -1401,7 +1505,7 @@ def zoned_datetimes(
                 max_value_ = max_value_.to_tz(time_zone_.key).to_plain()
         case never:
             assert_never(never)
-    plain = draw(plain_datetimes(min_value=min_value_, max_value=max_value_))
+    plain = draw(plain_date_times(min_value=min_value_, max_value=max_value_))
     with (
         assume_does_not_raise(RepeatedTime),
         assume_does_not_raise(SkippedTime),
@@ -1415,7 +1519,7 @@ def zoned_datetimes(
     return zoned
 
 
-zoned_datetimes_2000 = zoned_datetimes(
+zoned_date_times_2000 = zoned_date_times(
     min_value=ZonedDateTime(2000, 1, 1, tz=UTC.key),
     max_value=ZonedDateTime(2000, 12, 31, tz=UTC.key),
 )
@@ -1427,6 +1531,7 @@ __all__ = [
     "assume_does_not_raise",
     "bool_arrays",
     "date_deltas",
+    "date_periods",
     "date_time_deltas",
     "dates",
     "draw2",
@@ -1438,6 +1543,8 @@ __all__ = [
     "hashables",
     "import_froms",
     "imports",
+    "int8s",
+    "int16s",
     "int32s",
     "int64s",
     "int_arrays",
@@ -1446,7 +1553,7 @@ __all__ = [
     "numbers",
     "pairs",
     "paths",
-    "plain_datetimes",
+    "plain_date_times",
     "py_datetimes",
     "random_states",
     "sentinels",
@@ -1463,6 +1570,7 @@ __all__ = [
     "text_digits",
     "text_printable",
     "time_deltas",
+    "time_periods",
     "times",
     "triples",
     "uint8s",
@@ -1472,6 +1580,7 @@ __all__ = [
     "urls",
     "versions",
     "year_months",
-    "zoned_datetimes",
-    "zoned_datetimes_2000",
+    "zoned_date_time_periods",
+    "zoned_date_times",
+    "zoned_date_times_2000",
 ]

utilities/orjson.py

@@ -5,7 +5,7 @@ import re
 from collections.abc import Callable, Iterable, Mapping, Sequence
 from contextlib import suppress
 from dataclasses import dataclass, field, replace
-from enum import Enum, unique
+from enum import Enum, StrEnum, unique
 from functools import cached_property, partial
 from itertools import chain
 from logging import Formatter, LogRecord
@@ -52,7 +52,12 @@ from utilities.math import MAX_INT64, MIN_INT64
 from utilities.types import Dataclass, LogLevel, MaybeIterable, PathLike, StrMapping
 from utilities.tzlocal import LOCAL_TIME_ZONE
 from utilities.version import Version, parse_version
-from utilities.whenever import from_timestamp
+from utilities.whenever import (
+    DatePeriod,
+    TimePeriod,
+    ZonedDateTimePeriod,
+    from_timestamp,
+)
 
 if TYPE_CHECKING:
     from collections.abc import Set as AbstractSet
@@ -65,10 +70,11 @@ if TYPE_CHECKING:
 
 
 @unique
-class _Prefixes(Enum):
+class _Prefixes(StrEnum):
     dataclass = "dc"
     date = "d"
     date_delta = "dd"
+    date_period = "dp"
     date_time_delta = "D"
     enum = "e"
     exception_class = "Ex"
@@ -77,7 +83,7 @@ class _Prefixes(Enum):
     frozenset_ = "fr"
     list_ = "l"
     month_day = "md"
-    none = "none"
+    none = "0"
     path = "p"
     plain_date_time = "pd"
     py_date = "!d"
@@ -87,12 +93,14 @@ class _Prefixes(Enum):
     set_ = "s"
     time = "ti"
     time_delta = "td"
+    time_period = "tp"
     tuple_ = "tu"
     unserializable = "un"
     uuid = "uu"
     version = "v"
     year_month = "ym"
     zoned_date_time = "zd"
+    zoned_date_time_period = "zp"
 
 
 type _DataclassHook = Callable[[type[Dataclass], StrMapping], StrMapping]
@@ -167,8 +175,10 @@ def _pre_process(
             return f"[{_Prefixes.date.value}]{date}"
         case DateDelta() as date:
             return f"[{_Prefixes.date_delta.value}]{date}"
-        case DateTimeDelta() as date:
-            return f"[{_Prefixes.date_time_delta.value}]{date}"
+        case DatePeriod() as period:
+            return f"[{_Prefixes.date_period.value}]{period.start},{period.end}"
+        case DateTimeDelta() as date_time_delta:
+            return f"[{_Prefixes.date_time_delta.value}]{date_time_delta}"
         case Exception() as error_:
             return {
                 f"[{_Prefixes.exception_instance.value}|{type(error_).__qualname__}]": pre(
@@ -187,14 +197,16 @@ def _pre_process(
             return f"[{_Prefixes.month_day.value}]{month_day!s}"
         case Path() as path:
             return f"[{_Prefixes.path.value}]{path!s}"
-        case PlainDateTime() as datetime:
-            return f"[{_Prefixes.plain_date_time.value}]{datetime}"
-        case str() as str_:
-            return str_
+        case PlainDateTime() as date_time:
+            return f"[{_Prefixes.plain_date_time.value}]{date_time}"
+        case str() as text:
+            return text
         case Time() as time:
             return f"[{_Prefixes.time.value}]{time}"
         case TimeDelta() as time_delta:
             return f"[{_Prefixes.time_delta.value}]{time_delta}"
+        case TimePeriod() as period:
+            return f"[{_Prefixes.time_period.value}]{period.start},{period.end}"
         case type() as error_cls if issubclass(error_cls, Exception):
             return f"[{_Prefixes.exception_class.value}|{error_cls.__qualname__}]"
         case UUID() as uuid:
@@ -203,8 +215,12 @@ def _pre_process(
             return f"[{_Prefixes.version.value}]{version}"
         case YearMonth() as year_month:
             return f"[{_Prefixes.year_month.value}]{year_month}"
-        case ZonedDateTime() as datetime:
-            return f"[{_Prefixes.zoned_date_time.value}]{datetime}"
+        case ZonedDateTime() as date_time:
+            return f"[{_Prefixes.zoned_date_time.value}]{date_time}"
+        case ZonedDateTimePeriod() as period:
+            return (
+                f"[{_Prefixes.zoned_date_time_period.value}]{period.start},{period.end}"
+            )
         case dt.datetime() as py_datetime:
             match py_datetime.tzinfo:
                 case None:
@@ -369,6 +385,7 @@ def deserialize(
 (
     _DATE_PATTERN,
     _DATE_DELTA_PATTERN,
+    _DATE_PERIOD_PATTERN,
     _DATE_TIME_DELTA_PATTERN,
     _FLOAT_PATTERN,
     _MONTH_DAY_PATTERN,
@@ -381,15 +398,18 @@ def deserialize(
     _PY_ZONED_DATE_TIME_PATTERN,
     _TIME_PATTERN,
     _TIME_DELTA_PATTERN,
+    _TIME_PERIOD_PATTERN,
     _UUID_PATTERN,
     _VERSION_PATTERN,
     _YEAR_MONTH_PATTERN,
     _ZONED_DATE_TIME_PATTERN,
+    _ZONED_DATE_TIME_PERIOD_PATTERN,
 ) = [
     re.compile(r"^\[" + p.value + r"\](" + ".*" + ")$")
     for p in [
         _Prefixes.date,
         _Prefixes.date_delta,
+        _Prefixes.date_period,
         _Prefixes.date_time_delta,
         _Prefixes.float_,
         _Prefixes.month_day,
@@ -402,10 +422,12 @@ def deserialize(
         _Prefixes.py_zoned_date_time,
         _Prefixes.time,
         _Prefixes.time_delta,
+        _Prefixes.time_period,
         _Prefixes.uuid,
         _Prefixes.version,
         _Prefixes.year_month,
         _Prefixes.zoned_date_time,
+        _Prefixes.zoned_date_time_period,
     ]
 ]
 
@@ -453,6 +475,9 @@ def _object_hook(
                 return Date.parse_common_iso(match.group(1))
             if match := _DATE_DELTA_PATTERN.search(text):
                 return DateDelta.parse_common_iso(match.group(1))
+            if match := _DATE_PERIOD_PATTERN.search(text):
+                start, end = map(Date.parse_common_iso, match.group(1).split(","))
+                return DatePeriod(start, end)
             if match := _DATE_TIME_DELTA_PATTERN.search(text):
                 return DateTimeDelta.parse_common_iso(match.group(1))
             if match := _FLOAT_PATTERN.search(text):
@@ -475,6 +500,9 @@ def _object_hook(
                 return Time.parse_common_iso(match.group(1))
             if match := _TIME_DELTA_PATTERN.search(text):
                 return TimeDelta.parse_common_iso(match.group(1))
+            if match := _TIME_PERIOD_PATTERN.search(text):
+                start, end = map(Time.parse_common_iso, match.group(1).split(","))
+                return TimePeriod(start, end)
             if match := _UUID_PATTERN.search(text):
                 return UUID(match.group(1))
             if match := _VERSION_PATTERN.search(text):
@@ -483,6 +511,11 @@ def _object_hook(
                 return YearMonth.parse_common_iso(match.group(1))
             if match := _ZONED_DATE_TIME_PATTERN.search(text):
                 return ZonedDateTime.parse_common_iso(match.group(1))
+            if match := _ZONED_DATE_TIME_PERIOD_PATTERN.search(text):
+                start, end = map(
+                    ZonedDateTime.parse_common_iso, match.group(1).split(",")
+                )
+                return ZonedDateTimePeriod(start, end)
             if (
                 exc_class := _object_hook_exception_class(
                     text, data=data, objects=objects, redirects=redirects

utilities/polars.py

@@ -15,11 +15,12 @@ from uuid import UUID
 from zoneinfo import ZoneInfo
 
 import polars as pl
+import whenever
 from polars import (
     Boolean,
     DataFrame,
-    Date,
     Datetime,
+    Duration,
     Expr,
     Float64,
     Int64,
@@ -43,16 +44,16 @@ from polars import (
 from polars._typing import PolarsDataType
 from polars.datatypes import DataType, DataTypeClass
 from polars.exceptions import (
-    ColumnNotFoundError,
+    ColumnNotFoundError,  # pyright: ignore[reportAttributeAccessIssue]
     NoRowsReturnedError,
-    OutOfBoundsError,
+    OutOfBoundsError,  # pyright: ignore[reportAttributeAccessIssue]
     PolarsInefficientMapWarning,
 )
 from polars.schema import Schema
 from polars.testing import assert_frame_equal, assert_series_equal
-from whenever import ZonedDateTime
+from whenever import DateDelta, DateTimeDelta, PlainDateTime, TimeDelta, ZonedDateTime
 
-from utilities.dataclasses import _YieldFieldsInstance, yield_fields
+from utilities.dataclasses import yield_fields
 from utilities.errors import ImpossibleCaseError
 from utilities.functions import (
     EnsureIntError,
@@ -93,14 +94,18 @@ from utilities.typing import (
     get_args,
     get_type_hints,
     is_frozenset_type,
-    is_instance_gen,
     is_list_type,
     is_literal_type,
     is_optional_type,
     is_set_type,
-    is_union_type,
 )
 from utilities.warnings import suppress_warnings
+from utilities.whenever import (
+    DatePeriod,
+    TimePeriod,
+    ZonedDateTimePeriod,
+    to_py_time_delta,
+)
 from utilities.zoneinfo import UTC, ensure_time_zone, get_time_zone_name
 
 if TYPE_CHECKING:
@@ -1052,14 +1057,35 @@ def dataclass_to_dataframe(
 
 def _dataclass_to_dataframe_cast(series: Series, /) -> Series:
     if series.dtype == Object:
+        if series.map_elements(
+            make_isinstance(whenever.Date), return_dtype=Boolean
+        ).all():
+            return series.map_elements(lambda x: x.py_date(), return_dtype=pl.Date)
+        if series.map_elements(make_isinstance(DateDelta), return_dtype=Boolean).all():
+            return series.map_elements(to_py_time_delta, return_dtype=Duration)
+        if series.map_elements(
+            make_isinstance(DateTimeDelta), return_dtype=Boolean
+        ).all():
+            return series.map_elements(to_py_time_delta, return_dtype=Duration)
         is_path = series.map_elements(make_isinstance(Path), return_dtype=Boolean).all()
         is_uuid = series.map_elements(make_isinstance(UUID), return_dtype=Boolean).all()
         if is_path or is_uuid:
             with suppress_warnings(category=PolarsInefficientMapWarning):
                 return series.map_elements(str, return_dtype=String)
-        else:  # pragma: no cover
-            msg = f"{is_path=}, f{is_uuid=}"
-            raise NotImplementedError(msg)
+        if series.map_elements(
+            make_isinstance(whenever.Time), return_dtype=Boolean
+        ).all():
+            return series.map_elements(lambda x: x.py_time(), return_dtype=pl.Time)
+        if series.map_elements(make_isinstance(TimeDelta), return_dtype=Boolean).all():
+            return series.map_elements(to_py_time_delta, return_dtype=Duration)
+        if series.map_elements(
+            make_isinstance(ZonedDateTime), return_dtype=Boolean
+        ).all():
+            return_dtype = zoned_datetime_dtype(time_zone=one({dt.tz for dt in series}))
+            return series.map_elements(
+                lambda x: x.py_datetime(), return_dtype=return_dtype
+            )
+        raise NotImplementedError(series)  # pragma: no cover
     return series
 
 
@@ -1101,20 +1127,14 @@ def dataclass_to_schema(
     for field in yield_fields(
         obj, globalns=globalns, localns=localns, warn_name_errors=warn_name_errors
     ):
-        if is_dataclass_instance(field.value):
+        if is_dataclass_instance(field.value) and not (
+            isinstance(field.type_, type)
+            and issubclass(field.type_, (DatePeriod, TimePeriod, ZonedDateTimePeriod))
+        ):
             dtypes = dataclass_to_schema(
                 field.value, globalns=globalns, localns=localns
             )
             dtype = struct_dtype(**dtypes)
-        elif field.type_ is dt.datetime:
-            dtype = _dataclass_to_schema_datetime(field)
-        elif is_union_type(field.type_) and set(
-            get_args(field.type_, optional_drop_none=True)
-        ) == {dt.date, dt.datetime}:
-            if is_instance_gen(field.value, dt.date):
-                dtype = Date
-            else:
-                dtype = _dataclass_to_schema_datetime(field)
         else:
             dtype = _dataclass_to_schema_one(
                 field.type_, globalns=globalns, localns=localns
@@ -1123,14 +1143,6 @@ def dataclass_to_schema(
     return out
 
 
-def _dataclass_to_schema_datetime(
-    field: _YieldFieldsInstance[dt.datetime], /
-) -> PolarsDataType:
-    if field.value.tzinfo is None:
-        return Datetime
-    return zoned_datetime_dtype(time_zone=ensure_time_zone(field.value.tzinfo))
-
-
 def _dataclass_to_schema_one(
     obj: Any,
     /,
@@ -1138,20 +1150,35 @@ def _dataclass_to_schema_one(
     globalns: StrMapping | None = None,
     localns: StrMapping | None = None,
 ) -> PolarsDataType:
-    if obj is bool:
-        return Boolean
-    if obj is int:
-        return Int64
-    if obj is float:
-        return Float64
-    if obj is str:
-        return String
-    if obj is dt.date:
-        return Date
-    if obj in {Path, UUID}:
-        return Object
-    if isinstance(obj, type) and issubclass(obj, enum.Enum):
-        return pl.Enum([e.name for e in obj])
+    if isinstance(obj, type):
+        if issubclass(obj, bool):
+            return Boolean
+        if issubclass(obj, int):
+            return Int64
+        if issubclass(obj, float):
+            return Float64
+        if issubclass(obj, str):
+            return String
+        if issubclass(
+            obj,
+            (
+                DateDelta,
+                DatePeriod,
+                DateTimeDelta,
+                Path,
+                PlainDateTime,
+                TimeDelta,
+                TimePeriod,
+                UUID,
+                ZonedDateTime,
+                ZonedDateTimePeriod,
+                whenever.Date,
+                whenever.Time,
+            ),
+        ):
+            return Object
+        if issubclass(obj, enum.Enum):
+            return pl.Enum([e.name for e in obj])
     if is_dataclass_class(obj):
         out: dict[str, Any] = {}
         for field in yield_fields(obj, globalns=globalns, localns=localns):
@@ -2444,7 +2471,13 @@ def struct_from_dataclass(
 def _struct_from_dataclass_one(
     ann: Any, /, *, time_zone: TimeZoneLike | None = None
 ) -> PolarsDataType:
-    mapping = {bool: Boolean, dt.date: Date, float: Float64, int: Int64, str: String}
+    mapping = {
+        bool: Boolean,
+        whenever.Date: pl.Date,
+        float: Float64,
+        int: Int64,
+        str: String,
+    }
     with suppress(KeyError):
         return mapping[ann]
     if ann is dt.datetime:

utilities/pytest_regressions.py

@@ -91,7 +91,9 @@ class PolarsRegressionFixture:
     def check(self, obj: Series | DataFrame, /, *, suffix: str | None = None) -> None:
         """Check the Series/DataFrame summary against the baseline."""
         from polars import DataFrame, Series, col
-        from polars.exceptions import InvalidOperationError
+        from polars.exceptions import (
+            InvalidOperationError,  # pyright: ignore[reportAttributeAccessIssue]
+        )
 
         data: StrMapping = {
             "describe": obj.describe(percentiles=[i / 10 for i in range(1, 10)]).rows(

utilities/traceback.py

@@ -284,7 +284,7 @@ def _make_except_hook_inner(
         except SendToSlackError as error:
             _ = stderr.write(f"{error}\n")
     if to_bool(pudb):  # pragma: no cover
-        from pudb import post_mortem
+        from pudb import post_mortem  # pyright: ignore[reportMissingImports]
 
         post_mortem(tb=traceback, e_type=exc_type, e_value=exc_val)
 

utilities/typing.py

@@ -23,6 +23,7 @@ from typing import get_type_hints as _get_type_hints
 from uuid import UUID
 from warnings import warn
 
+import whenever
 from whenever import (
     Date,
     DateDelta,
@@ -122,7 +123,6 @@ def get_type_hints(
     warn_name_errors: bool = False,
 ) -> dict[str, Any]:
     """Get the type hints of an object."""
-    result: dict[str, Any] = obj.__annotations__
     _ = {
         Date,
         DateDelta,
@@ -136,10 +136,17 @@ def get_type_hints(
         TimeDelta,
         UUID,
         ZonedDateTime,
-        dt,
+        whenever.Date,
+        whenever.DateDelta,
+        whenever.DateTimeDelta,
+        whenever.PlainDateTime,
+        whenever.Time,
+        whenever.TimeDelta,
+        whenever.ZonedDateTime,
     }
     globalns_use = globals() | ({} if globalns is None else dict(globalns))
     localns_use = {} if localns is None else dict(localns)
+    result: dict[str, Any] = obj.__annotations__
     try:
         hints = _get_type_hints(obj, globalns=globalns_use, localns=localns_use)
     except NameError as error:

utilities/whenever.py

@@ -367,6 +367,14 @@ def get_now_local() -> ZonedDateTime:
 NOW_LOCAL = get_now_local()
 
 
+def get_now_plain(time_zone: TimeZoneLike = UTC, /) -> PlainDateTime:
+    """Get the current zoned datetime."""
+    return get_now(time_zone).to_plain()
+
+
+NOW_PLAIN = get_now_plain()
+
+
 ##
 
 
@@ -1927,6 +1935,7 @@ __all__ = [
     "MINUTE",
     "MONTH",
     "NOW_LOCAL",
+    "NOW_PLAIN",
     "SECOND",
     "TIME_DELTA_MAX",
     "TIME_DELTA_MIN",
@@ -1966,6 +1975,7 @@ __all__ = [
     "from_timestamp_nanos",
     "get_now",
     "get_now_local",
+    "get_now_plain",
     "get_today",
     "get_today_local",
     "mean_datetime",