dycw-utilities 0.131.0__py3-none-any.whl → 0.131.2__py3-none-any.whl

{dycw_utilities-0.131.0.dist-info → dycw_utilities-0.131.2.dist-info}/METADATA

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

{dycw_utilities-0.131.0.dist-info → dycw_utilities-0.131.2.dist-info}/RECORD

@@ -1,4 +1,4 @@
-utilities/__init__.py,sha256=uJKmD-jecfvyO-bClrlrEbRyiOqLmfntMZDawWbbSAk,60
+utilities/__init__.py,sha256=ajN78bRkB5Im8iLJo5SoqSMwaBs05vhc-hxvF77jai4,60
 utilities/aiolimiter.py,sha256=mD0wEiqMgwpty4XTbawFpnkkmJS6R4JRsVXFUaoitSU,628
 utilities/altair.py,sha256=Gpja-flOo-Db0PIPJLJsgzAlXWoKUjPU1qY-DQ829ek,9156
 utilities/asyncio.py,sha256=lvdgBhuMtxq0dpiwF9g2WMMrit3kqXibN1V5NZ4xdbo,38046
@@ -24,7 +24,7 @@ utilities/getpass.py,sha256=DfN5UgMAtFCqS3dSfFHUfqIMZX2shXvwphOz_6J6f6A,103
 utilities/git.py,sha256=oi7-_l5e9haSANSCvQw25ufYGoNahuUPHAZ6114s3JQ,1191
 utilities/hashlib.py,sha256=SVTgtguur0P4elppvzOBbLEjVM3Pea0eWB61yg2ilxo,309
 utilities/http.py,sha256=WcahTcKYRtZ04WXQoWt5EGCgFPcyHD3EJdlMfxvDt-0,946
-utilities/hypothesis.py,sha256=UnUMJmeqwJuK7uyUqw_i3opUYzVKud4RMG0RMOSRBQY,44463
+utilities/hypothesis.py,sha256=jiFJsS6rg4273BYDjrHT1iYH7D7ybROnH5bca9rBWqI,47372
 utilities/importlib.py,sha256=mV1xT_O_zt_GnZZ36tl3xOmMaN_3jErDWY54fX39F6Y,429
 utilities/inflect.py,sha256=DbqB5Q9FbRGJ1NbvEiZBirRMxCxgrz91zy5jCO9ZIs0,347
 utilities/ipython.py,sha256=V2oMYHvEKvlNBzxDXdLvKi48oUq2SclRg5xasjaXStw,763
@@ -32,7 +32,7 @@ utilities/iterables.py,sha256=mDqw2_0MUVp-P8FklgcaVTi2TXduH0MxbhTDzzhSBho,44915
 utilities/jupyter.py,sha256=ft5JA7fBxXKzP-L9W8f2-wbF0QeYc_2uLQNFDVk4Z-M,2917
 utilities/libcst.py,sha256=Jto5ppzRzsxn4AD32IS8n0lbgLYXwsVJB6EY8giNZyY,4974
 utilities/lightweight_charts.py,sha256=0xNfcsrgFI0R9xL25LtSm-W5yhfBI93qQNT6HyaXAhg,2769
-utilities/logging.py,sha256=0dUW0F0RISy9arU58M6WHn7ACSs3-S4GHDs8ZCkjyNk,18420
+utilities/logging.py,sha256=DoLjy18w87fu6xDIBwiCtx3sAsNobm1QqQ4e2RRmp50,18421
 utilities/luigi.py,sha256=fpH9MbxJDuo6-k9iCXRayFRtiVbUtibCJKugf7ygpv0,5988
 utilities/math.py,sha256=-mQgbah-dPJwOEWf3SonrFoVZ2AVxMgpeQ3dfVa-oJA,26764
 utilities/memory_profiler.py,sha256=tf2C51P2lCujPGvRt2Rfc7VEw5LDXmVPCG3z_AvBmbU,962
@@ -70,7 +70,7 @@ utilities/shelve.py,sha256=HZsMwK4tcIfg3sh0gApx4-yjQnrY4o3V3ZRimvRhoW0,738
 utilities/slack_sdk.py,sha256=ltmzv68aa73CJGqTDvt8L9vDm22YU9iOCo3NCiNd3vA,4347
 utilities/socket.py,sha256=K77vfREvzoVTrpYKo6MZakol0EYu2q1sWJnnZqL0So0,118
 utilities/sqlalchemy.py,sha256=IuQ7CIVNl29TG6i81K6fam8NmTmPjtA6OiIN4nIM9W8,37935
-utilities/sqlalchemy_polars.py,sha256=OPrB_Aqh8KE3hfNqvvXSzqVH5CYgIYrDH13WoLdCzbw,15510
+utilities/sqlalchemy_polars.py,sha256=hApbjQUY-XgKfAXcun8gDP2lGh5LxrudnCpbG_hrYa0,14968
 utilities/statsmodels.py,sha256=koyiBHvpMcSiBfh99wFUfSggLNx7cuAw3rwyfAhoKpQ,3410
 utilities/streamlit.py,sha256=U9PJBaKP1IdSykKhPZhIzSPTZsmLsnwbEPZWzNhJPKk,2955
 utilities/string.py,sha256=XmU-s04qIV_tODnKl2pQiwmHaxzgOqRKU-RyzdrfvSE,620
@@ -81,16 +81,17 @@ utilities/threading.py,sha256=GvBOp4CyhHfN90wGXZuA2VKe9fGzMaEa7oCl4f3nnPU,1009
 utilities/timer.py,sha256=Rkc49KSpHuC8s7vUxGO9DU55U9I6yDKnchsQqrUCVBs,4075
 utilities/traceback.py,sha256=k3QhUca-643rl11S9uhibfNPlxjavOboCK56036KRcE,8859
 utilities/types.py,sha256=gP04CcCOyFrG7BgblVCsrrChiuO2x842NDVW-GF7odo,18370
-utilities/typing.py,sha256=H6ysJkI830aRwLsMKz0SZIw4cpcsm7d6KhQOwr-SDh0,13817
+utilities/typing.py,sha256=kQWywPcRbFBKmvQBELmgbiqSHsnlo_D0ru53vl6KDeY,13846
 utilities/tzdata.py,sha256=yCf70NICwAeazN3_JcXhWvRqCy06XJNQ42j7r6gw3HY,1217
 utilities/tzlocal.py,sha256=3upDNFBvGh1l9njmLR2z2S6K6VxQSb7QizYGUbAH3JU,960
 utilities/uuid.py,sha256=jJTFxz-CWgltqNuzmythB7iEQ-Q1mCwPevUfKthZT3c,611
 utilities/version.py,sha256=ufhJMmI6KPs1-3wBI71aj5wCukd3sP_m11usLe88DNA,5117
 utilities/warnings.py,sha256=un1LvHv70PU-LLv8RxPVmugTzDJkkGXRMZTE2-fTQHw,1771
-utilities/whenever.py,sha256=QbXgFAPuUL7PCp2hajmIP-FFIfIR1J6Y0TxJbeoj60I,18434
+utilities/whenever.py,sha256=jS31ZAY5OMxFxLja_Yo5Fidi87Pd-GoVZ7Vi_teqVDA,16743
+utilities/whenever2.py,sha256=uub90yQg2lUC8at7lnGR30qt5iuNlqPPTePwiKckhOE,3994
 utilities/zipfile.py,sha256=24lQc9ATcJxHXBPc_tBDiJk48pWyRrlxO2fIsFxU0A8,699
 utilities/zoneinfo.py,sha256=-5j7IQ9nb7gR43rdgA7ms05im-XuqhAk9EJnQBXxCoQ,1874
-dycw_utilities-0.131.0.dist-info/METADATA,sha256=nFoGHW3OOG6CRJXkrM-qnnpeoyMTas8muYPqY7L5sSM,12989
-dycw_utilities-0.131.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dycw_utilities-0.131.0.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
-dycw_utilities-0.131.0.dist-info/RECORD,,
+dycw_utilities-0.131.2.dist-info/METADATA,sha256=iP5y9JBuywFkkZML9iGcqagto8XgWUjD8sY4zCMWJv8,12989
+dycw_utilities-0.131.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dycw_utilities-0.131.2.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
+dycw_utilities-0.131.2.dist-info/RECORD,,

utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.131.0"
+__version__ = "0.131.2"

utilities/hypothesis.py

@@ -47,6 +47,7 @@ from hypothesis.strategies import (
     uuids,
 )
 from hypothesis.utils.conventions import not_set
+from whenever import Date, DateDelta
 
 from utilities.datetime import (
     DATETIME_MAX_NAIVE,
@@ -88,7 +89,7 @@ from utilities.platform import IS_WINDOWS
 from utilities.sentinel import Sentinel, sentinel
 from utilities.tempfile import TEMP_DIR, TemporaryDirectory
 from utilities.version import Version
-from utilities.zoneinfo import UTC
+from utilities.zoneinfo import UTC, ensure_time_zone
 
 if TYPE_CHECKING:
     from collections.abc import Collection, Hashable, Iterable, Iterator, Sequence
@@ -96,11 +97,10 @@ if TYPE_CHECKING:
 
     from hypothesis.database import ExampleDatabase
     from numpy.random import RandomState
-    from sqlalchemy.ext.asyncio import AsyncEngine
+    from whenever import PlainDateTime, ZonedDateTime
 
     from utilities.numpy import NDArrayB, NDArrayF, NDArrayI, NDArrayO
-    from utilities.sqlalchemy import Dialect, TableOrORMInstOrClass
-    from utilities.types import Duration, Number, RoundMode
+    from utilities.types import Duration, Number, RoundMode, TimeZoneLike
 
 
 _T = TypeVar("_T")
@@ -160,6 +160,45 @@ def bool_arrays(
 ##
 
 
+@composite
+def date_deltas_whenever(
+    draw: DrawFn,
+    /,
+    *,
+    min_value: MaybeSearchStrategy[DateDelta | None] = None,
+    max_value: MaybeSearchStrategy[DateDelta | None] = None,
+) -> DateDelta:
+    """Strategy for generating date deltas."""
+    from utilities.whenever2 import DATE_DELTA_MAX, DATE_DELTA_MIN
+
+    min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
+    match min_value_:
+        case None:
+            min_value_ = DATE_DELTA_MIN
+        case DateDelta():
+            ...
+        case _ as never:
+            assert_never(never)
+    match max_value_:
+        case None:
+            max_value_ = DATE_DELTA_MAX
+        case DateDelta():
+            ...
+        case _ as never:
+            assert_never(never)
+    min_years, min_months, min_days = min_value_.in_years_months_days()
+    assert min_years == 0
+    assert min_months == 0
+    max_years, max_months, max_days = max_value_.in_years_months_days()
+    assert max_years == 0
+    assert max_months == 0
+    days = draw(integers(min_value=min_days, max_value=max_days))
+    return DateDelta(days=days)
+
+
+##
+
+
 @composite
 def date_durations(
     draw: DrawFn,
@@ -240,6 +279,41 @@ def dates_two_digit_year(
 ##
 
 
+@composite
+def dates_whenever(
+    draw: DrawFn,
+    /,
+    *,
+    min_value: MaybeSearchStrategy[Date | None] = None,
+    max_value: MaybeSearchStrategy[Date | None] = None,
+) -> Date:
+    """Strategy for generating dates."""
+    from utilities.whenever2 import DATE_MAX, DATE_MIN
+
+    min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
+    match min_value_:
+        case None:
+            min_value_ = DATE_MIN
+        case Date():
+            ...
+        case _ as never:
+            assert_never(never)
+    match max_value_:
+        case None:
+            max_value_ = DATE_MAX
+        case Date():
+            ...
+        case _ as never:
+            assert_never(never)
+    py_date = draw(
+        dates(min_value=min_value_.py_date(), max_value=max_value_.py_date())
+    )
+    return Date.from_py_date(py_date)
+
+
+##
+
+
 @composite
 def datetime_durations(
     draw: DrawFn,
@@ -922,7 +996,7 @@ def _pairs_map(elements: list[_T], /) -> tuple[_T, _T]:
 
 def paths() -> SearchStrategy[Path]:
     """Strategy for generating `Path`s."""
-    reserved = {"NUL"}
+    reserved = {"AUX", "NUL"}
     strategy = text_ascii(min_size=1, max_size=10).filter(lambda x: x not in reserved)
     return lists(strategy, max_size=10).map(lambda parts: Path(*parts))
 
@@ -967,6 +1041,45 @@ class PlainDateTimesError(Exception):
 ##
 
 
+@composite
+def plain_datetimes_whenever(
+    draw: DrawFn,
+    /,
+    *,
+    min_value: MaybeSearchStrategy[PlainDateTime | None] = None,
+    max_value: MaybeSearchStrategy[PlainDateTime | None] = None,
+) -> PlainDateTime:
+    """Strategy for generating plain datetimes."""
+    from whenever import PlainDateTime
+
+    from utilities.whenever2 import PLAIN_DATE_TIME_MAX, PLAIN_DATE_TIME_MIN
+
+    min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
+    match min_value_:
+        case None:
+            min_value_ = PLAIN_DATE_TIME_MIN
+        case PlainDateTime():
+            ...
+        case _ as never:
+            assert_never(never)
+    match max_value_:
+        case None:
+            max_value_ = PLAIN_DATE_TIME_MAX
+        case PlainDateTime():
+            ...
+        case _ as never:
+            assert_never(never)
+    py_datetime = draw(
+        datetimes(
+            min_value=min_value_.py_datetime(), max_value=max_value_.py_datetime()
+        )
+    )
+    return PlainDateTime.from_py_datetime(py_datetime)
+
+
+##
+
+
 @composite
 def random_states(
     draw: DrawFn, /, *, seed: MaybeSearchStrategy[int | None] = None
@@ -1117,51 +1230,6 @@ def slices(
 ##
 
 
-_STRATEGY_DIALECTS: list[Dialect] = ["sqlite", "postgresql"]
-_SQLALCHEMY_ENGINE_DIALECTS = sampled_from(_STRATEGY_DIALECTS)
-
-
-async def sqlalchemy_engines(
-    data: DataObject,
-    /,
-    *tables_or_orms: TableOrORMInstOrClass,
-    dialect: MaybeSearchStrategy[Dialect] = _SQLALCHEMY_ENGINE_DIALECTS,
-) -> AsyncEngine:
-    """Strategy for generating sqlalchemy engines."""
-    from utilities.sqlalchemy import create_async_engine
-
-    dialect_: Dialect = draw2(data, dialect)
-    if "CI" in environ:  # pragma: no cover
-        _ = assume(dialect_ == "sqlite")
-    match dialect_:
-        case "sqlite":
-            temp_path = data.draw(temp_paths())
-            path = Path(temp_path, "db.sqlite")
-            engine = create_async_engine("sqlite+aiosqlite", database=str(path))
-
-            class EngineWithPath(type(engine)): ...
-
-            engine_with_path = EngineWithPath(engine.sync_engine)
-            cast(
-                "Any", engine_with_path
-            ).temp_path = temp_path  # keep `temp_path` alive
-            return engine_with_path
-        case "postgresql":  # skipif-ci-and-not-linux
-            from utilities.sqlalchemy import ensure_tables_dropped
-
-            engine = create_async_engine(
-                "postgresql+asyncpg", host="localhost", port=5432, database="testing"
-            )
-            with assume_does_not_raise(ConnectionRefusedError):
-                await ensure_tables_dropped(engine, *tables_or_orms)
-            return engine
-        case _:  # pragma: no cover
-            raise NotImplementedError(dialect)
-
-
-##
-
-
 @composite
 def str_arrays(
     draw: DrawFn,
@@ -1474,6 +1542,46 @@ class ZonedDateTimesError(Exception):
         return "Rounding requires a timedelta; got None"
 
 
+##
+
+
+@composite
+def zoned_datetimes_whenever(
+    draw: DrawFn,
+    /,
+    *,
+    min_value: MaybeSearchStrategy[PlainDateTime | ZonedDateTime | None] = None,
+    max_value: MaybeSearchStrategy[PlainDateTime | ZonedDateTime | None] = None,
+    time_zone: MaybeSearchStrategy[TimeZoneLike] = UTC,
+) -> ZonedDateTime:
+    """Strategy for generating zoned datetimes."""
+    from whenever import PlainDateTime, ZonedDateTime
+
+    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_:
+        case None | PlainDateTime():
+            ...
+        case ZonedDateTime():
+            with assume_does_not_raise(ValueError):
+                min_value_ = min_value_.to_tz(time_zone_.key).to_plain()
+        case _ as never:
+            assert_never(never)
+    match max_value_:
+        case None | PlainDateTime():
+            ...
+        case ZonedDateTime():
+            with assume_does_not_raise(ValueError):
+                max_value_ = max_value_.to_tz(time_zone_.key).to_plain()
+        case _ as never:
+            assert_never(never)
+    plain_datetime = draw(
+        plain_datetimes_whenever(min_value=min_value_, max_value=max_value_)
+    )
+    with assume_does_not_raise(ValueError):
+        return plain_datetime.assume_tz(time_zone_.key, disambiguate="raise")
+
+
 __all__ = [
     "Draw2Error",
     "MaybeSearchStrategy",
@@ -1482,8 +1590,10 @@ __all__ = [
     "ZonedDateTimesError",
     "assume_does_not_raise",
     "bool_arrays",
+    "date_deltas_whenever",
     "date_durations",
     "dates_two_digit_year",
+    "dates_whenever",
     "datetime_durations",
     "draw2",
     "float32s",
@@ -1507,12 +1617,12 @@ __all__ = [
     "paths",
     "plain_datetimes",
     "plain_datetimes",
+    "plain_datetimes_whenever",
     "random_states",
     "sentinels",
     "sets_fixed_length",
     "setup_hypothesis_profiles",
     "slices",
-    "sqlalchemy_engines",
     "str_arrays",
     "temp_dirs",
     "temp_paths",
@@ -1528,4 +1638,5 @@ __all__ = [
     "uint64s",
     "versions",
     "zoned_datetimes",
+    "zoned_datetimes_whenever",
 ]

utilities/logging.py

@@ -190,7 +190,7 @@ def get_formatter(
 ) -> Formatter:
     """Get the formatter; colored if available."""
     if whenever:
-        from utilities.whenever import WheneverLogRecord
+        from utilities.whenever2 import WheneverLogRecord
 
         setLogRecordFactory(WheneverLogRecord)
         format_ = format_.replace("{asctime}", "{zoned_datetime}")

utilities/sqlalchemy_polars.py

@@ -25,7 +25,6 @@ from polars import (
 )
 from sqlalchemy import Column, Select, select
 from sqlalchemy.exc import DuplicateColumnError
-from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine
 
 from utilities.asyncio import timeout_dur
 from utilities.functions import identity
@@ -61,6 +60,7 @@ if TYPE_CHECKING:
     )
 
     from polars._typing import PolarsDataType, SchemaDict
+    from sqlalchemy.ext.asyncio import AsyncEngine
     from sqlalchemy.sql import ColumnCollection
     from sqlalchemy.sql.base import ReadOnlyColumnCollection
     from tenacity.retry import RetryBaseT
@@ -307,22 +307,6 @@ async def select_to_dataframe(
     **kwargs: Any,
 ) -> DataFrame | Iterable[DataFrame] | AsyncIterable[DataFrame]:
     """Read a table from a database into a DataFrame."""
-    if not issubclass(AsyncEngine, type(engine)):
-        # for handling testing
-        engine = create_async_engine(engine.url)
-        return await select_to_dataframe(
-            sel,
-            engine,
-            snake=snake,
-            time_zone=time_zone,
-            batch_size=batch_size,
-            in_clauses=in_clauses,
-            in_clauses_chunk_size=in_clauses_chunk_size,
-            chunk_size_frac=chunk_size_frac,
-            timeout=timeout,
-            error=error,
-            **kwargs,
-        )
     if snake:
         sel = _select_to_dataframe_apply_snake(sel)
     schema = _select_to_dataframe_map_select_to_df_schema(sel, time_zone=time_zone)

utilities/typing.py

@@ -234,7 +234,7 @@ def is_instance_gen(obj: Any, type_: Any, /) -> bool:
     """Check if an instance relationship holds, except bool<int."""
     # parent
     if isinstance(type_, tuple):
-        return any(is_instance_gen(obj, t) for t in type_)
+        return any(is_instance_gen(obj, t) for t in type_)  # skipif-ci-and-not-windows
     if is_literal_type(type_):
         return obj in get_args(type_)
     if is_union_type(type_):

utilities/whenever.py

@@ -4,9 +4,7 @@ import datetime as dt
 import re
 from contextlib import suppress
 from dataclasses import dataclass
-from functools import cache
-from logging import LogRecord
-from typing import TYPE_CHECKING, Any, override
+from typing import TYPE_CHECKING, override
 
 from whenever import (
     Date,
@@ -35,8 +33,6 @@ from utilities.re import (
 from utilities.zoneinfo import UTC, ensure_time_zone, get_time_zone_name
 
 if TYPE_CHECKING:
-    from zoneinfo import ZoneInfo
-
     from utilities.types import (
         DateLike,
         DateTimeLike,
@@ -565,64 +561,6 @@ class SerializeZonedDateTimeError(Exception):
 ##
 
 
-class WheneverLogRecord(LogRecord):
-    """Log record powered by `whenever`."""
-
-    zoned_datetime: str
-
-    @override
-    def __init__(
-        self,
-        name: str,
-        level: int,
-        pathname: str,
-        lineno: int,
-        msg: object,
-        args: Any,
-        exc_info: Any,
-        func: str | None = None,
-        sinfo: str | None = None,
-    ) -> None:
-        super().__init__(
-            name, level, pathname, lineno, msg, args, exc_info, func, sinfo
-        )
-        length = self._get_length()
-        plain = format(self._get_now().to_plain().format_common_iso(), f"{length}s")
-        time_zone = self._get_time_zone_key()
-        self.zoned_datetime = f"{plain}[{time_zone}]"
-
-    @classmethod
-    @cache
-    def _get_time_zone(cls) -> ZoneInfo:
-        """Get the local timezone."""
-        try:
-            from utilities.tzlocal import get_local_time_zone
-        except ModuleNotFoundError:  # pragma: no cover
-            return UTC
-        return get_local_time_zone()
-
-    @classmethod
-    @cache
-    def _get_time_zone_key(cls) -> str:
-        """Get the local timezone as a string."""
-        return cls._get_time_zone().key
-
-    @classmethod
-    @cache
-    def _get_length(cls) -> int:
-        """Get maximum length of a formatted string."""
-        now = cls._get_now().replace(nanosecond=1000).to_plain()
-        return len(now.format_common_iso())
-
-    @classmethod
-    def _get_now(cls) -> ZonedDateTime:
-        """Get the current zoned datetime."""
-        return ZonedDateTime.now(cls._get_time_zone().key)
-
-
-##
-
-
 def _to_datetime_delta(timedelta: dt.timedelta, /) -> DateTimeDelta:
     """Serialize a timedelta."""
     total_microseconds = datetime_duration_to_microseconds(timedelta)
@@ -672,7 +610,6 @@ __all__ = [
     "SerializePlainDateTimeError",
     "SerializeTimeDeltaError",
     "SerializeZonedDateTimeError",
-    "WheneverLogRecord",
     "check_valid_zoned_datetime",
     "ensure_date",
     "ensure_datetime",

utilities/whenever2.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+import datetime as dt
+from functools import cache
+from logging import LogRecord
+from typing import TYPE_CHECKING, Any, override
+
+from whenever import Date, DateTimeDelta, PlainDateTime, ZonedDateTime
+
+from utilities.zoneinfo import UTC, get_time_zone_name
+
+if TYPE_CHECKING:
+    from zoneinfo import ZoneInfo
+
+    from utilities.types import TimeZoneLike
+
+
+DATE_MIN = Date.from_py_date(dt.date.min)
+DATE_MAX = Date.from_py_date(dt.date.max)
+PLAIN_DATE_TIME_MIN = PlainDateTime.from_py_datetime(dt.datetime.min)  # noqa: DTZ901
+PLAIN_DATE_TIME_MAX = PlainDateTime.from_py_datetime(dt.datetime.max)  # noqa: DTZ901
+ZONED_DATE_TIME_MIN = PLAIN_DATE_TIME_MIN.assume_tz(UTC.key)
+ZONED_DATE_TIME_MAX = PLAIN_DATE_TIME_MAX.assume_tz(UTC.key)
+DATE_TIME_DELTA_MIN = DateTimeDelta(days=-3652059, seconds=-316192377600)
+DATE_TIME_DELTA_MAX = DateTimeDelta(days=3652059, seconds=316192377600)
+DATE_DELTA_MIN = DATE_TIME_DELTA_MIN.date_part()
+DATE_DELTA_MAX = DATE_TIME_DELTA_MAX.date_part()
+TIME_DELTA_MIN = DATE_TIME_DELTA_MIN.time_part()
+TIME_DELTA_MAX = DATE_TIME_DELTA_MAX.time_part()
+
+
+##
+
+
+def from_timestamp(i: float, /, *, time_zone: TimeZoneLike = UTC) -> ZonedDateTime:
+    """Get a zoned datetime from a timestamp."""
+    return ZonedDateTime.from_timestamp(i, tz=get_time_zone_name(time_zone))
+
+
+def from_timestamp_millis(i: int, /, *, time_zone: TimeZoneLike = UTC) -> ZonedDateTime:
+    """Get a zoned datetime from a timestamp (in milliseconds)."""
+    return ZonedDateTime.from_timestamp_millis(i, tz=get_time_zone_name(time_zone))
+
+
+def from_timestamp_nanos(i: int, /, *, time_zone: TimeZoneLike = UTC) -> ZonedDateTime:
+    """Get a zoned datetime from a timestamp (in nanoseconds)."""
+    return ZonedDateTime.from_timestamp_nanos(i, tz=get_time_zone_name(time_zone))
+
+
+##
+
+
+def get_now(*, time_zone: TimeZoneLike = UTC) -> ZonedDateTime:
+    """Get the current zoned datetime."""
+    return ZonedDateTime.now(get_time_zone_name(time_zone))
+
+
+NOW_UTC = get_now(time_zone=UTC)
+
+
+def get_now_local() -> ZonedDateTime:
+    """Get the current local time."""
+    return get_now(time_zone="local")
+
+
+##
+
+
+class WheneverLogRecord(LogRecord):
+    """Log record powered by `whenever`."""
+
+    zoned_datetime: str
+
+    @override
+    def __init__(
+        self,
+        name: str,
+        level: int,
+        pathname: str,
+        lineno: int,
+        msg: object,
+        args: Any,
+        exc_info: Any,
+        func: str | None = None,
+        sinfo: str | None = None,
+    ) -> None:
+        super().__init__(
+            name, level, pathname, lineno, msg, args, exc_info, func, sinfo
+        )
+        length = self._get_length()
+        plain = format(get_now_local().to_plain().format_common_iso(), f"{length}s")
+        time_zone = self._get_time_zone_key()
+        self.zoned_datetime = f"{plain}[{time_zone}]"
+
+    @classmethod
+    @cache
+    def _get_time_zone(cls) -> ZoneInfo:
+        """Get the local timezone."""
+        try:
+            from utilities.tzlocal import get_local_time_zone
+        except ModuleNotFoundError:  # pragma: no cover
+            return UTC
+        return get_local_time_zone()
+
+    @classmethod
+    @cache
+    def _get_time_zone_key(cls) -> str:
+        """Get the local timezone as a string."""
+        return cls._get_time_zone().key
+
+    @classmethod
+    @cache
+    def _get_length(cls) -> int:
+        """Get maximum length of a formatted string."""
+        now = get_now_local().replace(nanosecond=1000).to_plain()
+        return len(now.format_common_iso())
+
+
+__all__ = [
+    "DATE_DELTA_MAX",
+    "DATE_DELTA_MIN",
+    "DATE_MAX",
+    "DATE_MIN",
+    "DATE_TIME_DELTA_MAX",
+    "DATE_TIME_DELTA_MIN",
+    "PLAIN_DATE_TIME_MAX",
+    "PLAIN_DATE_TIME_MIN",
+    "TIME_DELTA_MAX",
+    "TIME_DELTA_MIN",
+    "ZONED_DATE_TIME_MAX",
+    "ZONED_DATE_TIME_MIN",
+    "WheneverLogRecord",
+    "from_timestamp",
+    "from_timestamp_millis",
+    "from_timestamp_nanos",
+    "get_now",
+    "get_now",
+    "get_now_local",
+]