dycw-utilities 0.131.3__tar.gz → 0.131.5__tar.gz

dycw_utilities-0.131.5/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: dycw-utilities
+Version: 0.131.5
+Author-email: Derek Wan <d.wan@icloud.com>
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: atomicwrites<1.5,>=1.4.1
+Requires-Dist: typing-extensions<4.15,>=4.14.0
+Requires-Dist: tzlocal<5.4,>=5.3.1
+Requires-Dist: whenever<0.9,>=0.8.5
+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.136,>=6.135.2; extra == 'test'
+Requires-Dist: pytest-asyncio<1.1,>=1.0.0; extra == 'test'
+Requires-Dist: pytest-cov<6.2,>=6.1.1; extra == 'test'
+Requires-Dist: pytest-instafail<0.6,>=0.5.0; extra == 'test'
+Requires-Dist: pytest-lazy-fixtures<1.2,>=1.1.4; extra == 'test'
+Requires-Dist: pytest-randomly<3.17,>=3.16.0; extra == 'test'
+Requires-Dist: pytest-regressions<2.9,>=2.8.0; extra == 'test'
+Requires-Dist: pytest-rerunfailures<16,>=15.1; extra == 'test'
+Requires-Dist: pytest-rng<1.1,>=1.0.0; extra == 'test'
+Requires-Dist: pytest-timeout<2.5,>=2.4.0; extra == 'test'
+Requires-Dist: pytest-xdist<3.8,>=3.7.0; extra == 'test'
+Requires-Dist: pytest<8.4,>=8.3.5; extra == 'test'
+Description-Content-Type: text/markdown
+
+[![PyPI version](https://badge.fury.io/py/dycw-utilities.svg)](https://badge.fury.io/py/dycw-utilities)
+
+# `dycw-utilities`
+
+[All the Python functions I don't want to write twice.](https://github.com/nvim-lua/plenary.nvim)
+
+## Installation
+
+- `pip install dycw-utilities`
+
+or with [extras](https://github.com/dycw/python-utilities/blob/master/pyproject.toml).

{dycw_utilities-0.131.3 → dycw_utilities-0.131.5}/pyproject.toml

@@ -94,7 +94,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.131.3"
+version = "0.131.5"
 
 [project.optional-dependencies]
 logging = [
@@ -115,193 +115,13 @@ test = [
   "pytest-timeout >= 2.4.0, < 2.5",
   "pytest-xdist >= 3.7.0, < 3.8",
 ]
-zzz-test-aiolimiter = [
-  "aiolimiter >= 1.2.1, < 1.3",
-]
-zzz-test-altair = [
-  "altair >= 5.5.0, < 5.6",
-  "img2pdf >= 0.6.0, < 0.7",
-  "polars-lts-cpu >= 1.30.0, < 1.31",
-  "vl-convert-python >= 1.8.0, < 1.9",
-]
-zzz-test-asyncio = []
-zzz-test-atomicwrites = []
-zzz-test-atools = [
-  "atools >= 0.14.2, < 0.15",
-]
-zzz-test-cachetools = ["cachetools >= 5.5.2, < 5.6"]
-zzz-test-click = [
-  "click >= 8.2.1, < 8.3",
-  "sqlalchemy >= 2.0.41, < 2.1",
-]
-zzz-test-contextlib = []
-zzz-test-contextvars = []
-zzz-test-cryptography = ["cryptography >= 45.0.4, < 45.1"]
-zzz-test-cvxpy = ["cvxpy >= 1.6.5, < 1.7"]
-zzz-test-dataclasses = [
-  "orjson >= 3.10.15, < 3.11",
-  "polars-lts-cpu >= 1.30.0, < 1.31",
-]
-zzz-test-datetime = [
-]
-zzz-test-enum = []
-zzz-test-errors = []
-zzz-test-eventkit = ["eventkit >= 1.0.3, < 1.1"]
-zzz-test-fastapi = [
-  "fastapi >= 0.115.11, < 0.116",
-  "httpx >= 0.28.1, < 0.29",
-  "uvicorn >= 0.34.1, < 0.35",
-]
-zzz-test-fpdf2 = [
-  "fpdf2 >= 2.8.3, < 2.9",
-]
-zzz-test-functions = []
-zzz-test-functools = []
-zzz-test-getpass = []
-zzz-test-git = []
-zzz-test-hashlib = [
-  "polars-lts-cpu >= 1.30.0, < 1.31",
-  "orjson >= 3.10.15, < 3.11",
-]
-zzz-test-http = [
-  "orjson >= 3.10.18, < 3.11",
-]
-zzz-test-hypothesis = [
-  "aiosqlite >= 0.21.0, < 0.22",
-  "asyncpg >= 0.30.0, < 0.31",  # for sqlalchemy async
-  "greenlet >= 3.2.0, < 3.3",  # for sqlalchemy async
-  "hypothesis >= 6.135.2, < 6.136",
-  "luigi >= 3.6.0, < 3.7",
-  "numpy >= 2.3.0, < 2.4",
-  "pathvalidate >= 3.2.3, < 3.3",
-  "redis >= 6.2.0, < 6.3",
-  "sqlalchemy >= 2.0.41, < 2.1",
-  "tenacity >= 8.5.0, < 9.0",  # limited by luigi
-]
-zzz-test-ipython = ["ipython >= 9.0.1, < 9.1"]
-zzz-test-iterables = [
-  "polars-lts-cpu >= 1.30.0, < 1.31",
-]
-zzz-test-jupyter = [
-  "jupyterlab >= 4.2.0, < 4.3",
-  "pandas >= 2.3.0, < 2.4",
-  "polars-lts-cpu >= 1.30.0, < 1.31",
-]
-zzz-test-logging = [
-  "coloredlogs >= 15.0.1, < 15.1",
-  "rich >= 14.0.0, < 14.1",
-  "tomlkit >= 0.13.2, < 0.14",
-]
-zzz-test-luigi = [
-  "luigi >= 3.6.0, < 3.7",
-]
-zzz-test-math = ["numpy >= 2.3.0, < 2.4"]
-zzz-test-memory-profiler = ["memory-profiler >= 0.61.0, < 0.62"]
-zzz-test-modules = []
-zzz-test-more-itertools = ["more-itertools >= 10.7.0, < 10.8"]
-zzz-test-numpy = ["numpy >= 2.3.0, < 2.4"]
-zzz-test-operator = [
-  "polars-lts-cpu >= 1.30.0, < 1.31",
-]
-zzz-test-optuna = ["optuna >= 4.3.0, < 4.4"]
-zzz-test-orjson = [
-  "orjson >= 3.10.15, < 3.11",
-  "polars-lts-cpu >= 1.30.0, < 1.31",
-  "rich >= 14.0.0, < 14.1",
-]
-zzz-test-os = []
-zzz-test-pathlib = []
-zzz-test-pickle = []
-zzz-test-platform = []
-zzz-test-polars = [
-  "polars-lts-cpu >= 1.30.0, < 1.31",
-]
-zzz-test-pqdm = ["pqdm >= 0.2.0, < 0.3"]
-zzz-test-pydantic = [
-  "pydantic >= 2.11.4, < 2.12",
-]
-zzz-test-pyinstrument = [
-  "pyinstrument >= 5.0.2, < 5.1",
-]
-zzz-test-pyrsistent = ["pyrsistent >= 0.20.0, < 0.21"]
-zzz-test-pytest = [
-  "orjson >= 3.10.18, < 3.11",
-]
-zzz-test-pytest-regressions = ["pytest-regressions >= 2.8.0, < 2.9"]
-zzz-test-python-dotenv = [
-  "python-dotenv >= 1.1.0, < 1.2",
-]
-zzz-test-random = []
-zzz-test-re = []
-zzz-test-redis = [
-  "orjson >= 3.10.15, < 3.11",
-  "polars-lts-cpu >= 1.30.0, < 1.31",
-  "redis >= 6.2.0, < 6.3",
-  "rich >= 14.0.0, < 14.1",
-  "tenacity >= 8.5.0, < 9.0",  # limited by luigi
-]
-zzz-test-rich = ["rich >= 14.0.0, < 14.1"]
-zzz-test-scipy = ["scipy >= 1.15.3, < 1.16"]
-zzz-test-sentinel = []
-zzz-test-shelve = []
-zzz-test-slack-sdk = [
-  "aiohttp >= 3.12.12, < 3.13",  # for slack
-  "slack-sdk >= 3.35.0, < 3.36",
-]
-zzz-test-socket = []
-zzz-test-sqlalchemy = [
-  "aiosqlite >= 0.21.0, < 0.22",
-  "asyncpg >= 0.30.0, < 0.31",  # for sqlalchemy async
-  "greenlet >= 3.2.0, < 3.3",  # for sqlalchemy async
-  "nest-asyncio >= 1.6.0, < 1.7",  # for sqlalchemy async
-  "sqlalchemy >= 2.0.41, < 2.1",
-  "tenacity >= 8.5.0, < 9.0",  # limited by luigi
-]
-zzz-test-sqlalchemy-polars = [
-  "aiosqlite >= 0.21.0, < 0.22",
-  "asyncpg >= 0.30.0, < 0.31",  # for sqlalchemy async
-  "greenlet >= 3.2.0, < 3.3",  # for sqlalchemy async
-  "nest-asyncio >= 1.6.0, < 1.7",  # for sqlalchemy async
-  "polars-lts-cpu >= 1.30.0, < 1.31",
-  "sqlalchemy >= 2.0.41, < 2.1",
-  "tenacity >= 8.5.0, < 9.0",  # limited by luigi
-]
-zzz-test-streamlit = ["streamlit >= 1.45.0, < 1.46"]
-zzz-test-sys = [
-  "rich >= 14.0.0, < 14.1",
-  "tomlkit >= 0.13.2, < 0.14",
-]
-zzz-test-tempfile = []
-zzz-test-tenacity = [
-  "tenacity >= 8.5.0, < 9.0",  # limited by luigi
-]
-zzz-test-text = []
-zzz-test-threading = []
-zzz-test-timer = []
-zzz-test-traceback = [
-  "rich >= 14.0.0, < 14.1",
-  "tomlkit >= 0.13.2, < 0.14",
-]
-zzz-test-types = []
-zzz-test-typing = [
-  "polars-lts-cpu >= 1.30.0, < 1.31",
-]
-zzz-test-tzlocal = []
-zzz-test-uuid = []
-zzz-test-version = ["tomlkit >= 0.13.2, < 0.14"]
-zzz-test-warnings = []
-zzz-test-whenever = []
-zzz-test-zipfile = []
-zzz-test-zoneinfo = [
-  "tzdata >= 2025.2, < 2025.3",
-]
 
 [project.scripts]
 
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.131.3"
+current_version = "0.131.5"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.131.3 → dycw_utilities-0.131.5}/src/tests/test_hypothesis.py

@@ -183,14 +183,16 @@ class TestBoolArrays:
         assert array.shape == shape
 
 
-class TestDateDeltas:
-    @given(data=data())
-    def test_main(self, *, data: DataObject) -> None:
+class TestDateDeltasWhenever:
+    @given(data=data(), parsable=booleans())
+    def test_main(self, *, data: DataObject, parsable: bool) -> None:
         min_value = data.draw(date_deltas_whenever() | none())
         max_value = data.draw(date_deltas_whenever() | none())
         with assume_does_not_raise(InvalidArgument):
             delta = data.draw(
-                date_deltas_whenever(min_value=min_value, max_value=max_value)
+                date_deltas_whenever(
+                    min_value=min_value, max_value=max_value, parsable=parsable
+                )
             )
         assert isinstance(delta, DateDelta)
         years, months, days = delta.in_years_months_days()
@@ -206,6 +208,8 @@ class TestDateDeltas:
             assert max_years == 0
             assert max_months == 0
             assert days <= max_days
+        if parsable:
+            assert DateDelta.parse_common_iso(delta.format_common_iso()) == delta
 
 
 class TestDateDurations:
@@ -295,6 +299,7 @@ class TestDatesWhenever:
         with assume_does_not_raise(InvalidArgument):
             date = data.draw(dates_whenever(min_value=min_value, max_value=max_value))
         assert isinstance(date, Date)
+        assert Date.parse_common_iso(date.format_common_iso()) == date
         if min_value is not None:
             assert date >= min_value
         if max_value is not None:
@@ -894,6 +899,7 @@ class TestPlainDateTimesWhenever:
                 plain_datetimes_whenever(min_value=min_value, max_value=max_value)
             )
         assert isinstance(datetime, PlainDateTime)
+        assert PlainDateTime.parse_common_iso(datetime.format_common_iso()) == datetime
         if min_value is not None:
             assert datetime >= min_value
         if max_value is not None:
@@ -1273,6 +1279,7 @@ class TestZonedDateTimesWhenever:
                 )
             )
         assert isinstance(datetime, ZonedDateTime)
+        assert ZonedDateTime.parse_common_iso(datetime.format_common_iso()) == datetime
         assert datetime.tz == time_zone.key
         if min_value is not None:
             assert datetime >= min_value

{dycw_utilities-0.131.3 → dycw_utilities-0.131.5}/src/tests/test_operator.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import datetime as dt
 from dataclasses import dataclass
 from enum import Enum, auto
 from functools import partial
@@ -23,16 +22,15 @@ from hypothesis.strategies import (
     recursive,
     sampled_from,
     times,
-    timezones,
     tuples,
     uuids,
 )
 from polars import DataFrame, Int64
 from pytest import raises
+from whenever import DateTimeDelta
 
 import utilities.math
 import utilities.operator
-from tests.conftest import IS_CI_AND_WINDOWS
 from tests.test_typing_funcs.with_future import (
     DataClassFutureCustomEquality,
     DataClassFutureDefaultInInitChild,
@@ -60,6 +58,7 @@ from utilities.hypothesis import (
 from utilities.math import MAX_INT64, MIN_INT64
 from utilities.operator import IsEqualError
 from utilities.polars import are_frames_equal
+from utilities.whenever2 import get_now
 
 if TYPE_CHECKING:
     from collections.abc import Sequence
@@ -106,11 +105,12 @@ def base_objects(
         | timedeltas_2w()
         | uuids()
         | versions()
+        | zoned_datetimes(
+            min_value=get_now().py_datetime(),
+            max_value=(get_now() + DateTimeDelta(years=1)).py_datetime(),
+            valid=True,
+        )
     )
-    if IS_CI_AND_WINDOWS:
-        base |= zoned_datetimes()
-    else:
-        base |= zoned_datetimes(time_zone=timezones() | just(dt.UTC), valid=True)
     if dataclass_custom_equality:
         base |= builds(DataClassFutureCustomEquality)
     if dataclass_default_in_init_child:
@@ -348,8 +348,8 @@ class TestIsEqual:
         assert utilities.operator.is_equal(first, second, abs_tol=1e-8)
 
     @given(
-        x=dates() | datetimes() | zoned_datetimes(time_zone=timezones()),
-        y=dates() | datetimes() | zoned_datetimes(time_zone=timezones()),
+        x=dates() | datetimes() | zoned_datetimes(),
+        y=dates() | datetimes() | zoned_datetimes(),
     )
     def test_dates_or_datetimes(self, *, x: DateOrDateTime, y: DateOrDateTime) -> None:
         result = utilities.operator.is_equal(x, y)

{dycw_utilities-0.131.3 → dycw_utilities-0.131.5}/src/tests/test_parse.py

@@ -36,6 +36,7 @@ from utilities.errors import ImpossibleCaseError
 from utilities.functions import ensure_path
 from utilities.hypothesis import (
     datetime_durations,
+    int64s,
     numbers,
     paths,
     plain_datetimes,
@@ -78,10 +79,10 @@ class TestSerializeAndParseObject:
         result = parse_object(dt.datetime, serialized)
         assert result == datetime
 
-    @given(mapping=dictionaries(dates(), zoned_datetimes()))
-    def test_dict(self, *, mapping: dict[dt.date, dt.datetime]) -> None:
+    @given(mapping=dictionaries(dates(), int64s()))
+    def test_dict(self, *, mapping: dict[dt.date, int]) -> None:
         serialized = serialize_object(mapping)
-        result = parse_object(dict[dt.date, dt.datetime], serialized)
+        result = parse_object(dict[dt.date, int], serialized)
         assert result == mapping
 
     @given(duration=datetime_durations(two_way=True))

{dycw_utilities-0.131.3 → dycw_utilities-0.131.5}/src/tests/test_whenever2.py

@@ -14,10 +14,14 @@ from utilities.tzdata import HongKong, Tokyo
 from utilities.whenever2 import (
     DATE_DELTA_MAX,
     DATE_DELTA_MIN,
+    DATE_DELTA_PARSABLE_MAX,
+    DATE_DELTA_PARSABLE_MIN,
     DATE_MAX,
     DATE_MIN,
     DATE_TIME_DELTA_MAX,
     DATE_TIME_DELTA_MIN,
+    DATE_TIME_DELTA_PARSABLE_MAX,
+    DATE_TIME_DELTA_PARSABLE_MIN,
     NOW_UTC,
     PLAIN_DATE_TIME_MAX,
     PLAIN_DATE_TIME_MIN,
@@ -95,6 +99,22 @@ class TestMinMax:
         with raises(ValueError, match="Addition result out of bounds"):
             _ = DATE_DELTA_MAX + DateDelta(days=1)
 
+    def test_date_delta_parsable_min(self) -> None:
+        def func(delta: DateDelta, /) -> None:
+            _ = DateDelta.parse_common_iso(delta.format_common_iso())
+
+        _ = func(DATE_DELTA_PARSABLE_MIN)
+        with raises(ValueError, match="Invalid format: '.*'"):
+            _ = func(DATE_DELTA_PARSABLE_MIN - DateDelta(days=1))
+
+    def test_date_delta_parsable_max(self) -> None:
+        def func(delta: DateDelta, /) -> None:
+            _ = DateDelta.parse_common_iso(delta.format_common_iso())
+
+        _ = func(DATE_DELTA_PARSABLE_MAX)
+        with raises(ValueError, match="Invalid format: '.*'"):
+            _ = func(DATE_DELTA_PARSABLE_MAX + DateDelta(days=1))
+
     @mark.parametrize(
         "delta",
         [
@@ -129,6 +149,22 @@ class TestMinMax:
             with raises(ValueError, match="Addition result out of bounds"):
                 _ = DATE_TIME_DELTA_MAX + delta
 
+    def test_date_time_delta_parsable_min(self) -> None:
+        def func(delta: DateTimeDelta, /) -> None:
+            _ = DateDelta.parse_common_iso(delta.format_common_iso())
+
+        _ = func(DATE_TIME_DELTA_PARSABLE_MIN)
+        with raises(ValueError, match="Invalid format: '.*'"):
+            _ = func(DATE_TIME_DELTA_PARSABLE_MIN - DateTimeDelta(nanoseconds=1))
+
+    def test_date_time_delta_parsable_max(self) -> None:
+        def func(delta: DateTimeDelta, /) -> None:
+            _ = DateDelta.parse_common_iso(delta.format_common_iso())
+
+        _ = func(DATE_TIME_DELTA_PARSABLE_MAX)
+        with raises(ValueError, match="Invalid format: '.*'"):
+            _ = func(DATE_TIME_DELTA_PARSABLE_MAX + DateTimeDelta(nanoseconds=1))
+
     def test_plain_date_time_min(self) -> None:
         with raises(ValueError, match=r"Result of subtract\(\) out of range"):
             _ = PLAIN_DATE_TIME_MIN.subtract(nanoseconds=1, ignore_dst=True)
@@ -186,3 +222,9 @@ class TestWheneverLogRecord:
 
     def test_get_length(self) -> None:
         assert isinstance(WheneverLogRecord._get_length(), int)
+
+    def test_get_time_zone(self) -> None:
+        assert isinstance(WheneverLogRecord._get_time_zone(), ZoneInfo)
+
+    def test_get_time_zone_key(self) -> None:
+        assert isinstance(WheneverLogRecord._get_time_zone_key(), str)

{dycw_utilities-0.131.3 → dycw_utilities-0.131.5}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.131.3"
+__version__ = "0.131.5"

{dycw_utilities-0.131.3 → dycw_utilities-0.131.5}/src/utilities/hypothesis.py

@@ -47,7 +47,7 @@ from hypothesis.strategies import (
     uuids,
 )
 from hypothesis.utils.conventions import not_set
-from whenever import Date, DateDelta, PlainDateTime
+from whenever import Date, DateDelta
 
 from utilities.datetime import (
     DATETIME_MAX_NAIVE,
@@ -97,7 +97,7 @@ if TYPE_CHECKING:
 
     from hypothesis.database import ExampleDatabase
     from numpy.random import RandomState
-    from whenever import ZonedDateTime
+    from whenever import PlainDateTime, ZonedDateTime
 
     from utilities.numpy import NDArrayB, NDArrayF, NDArrayI, NDArrayO
     from utilities.types import Duration, Number, RoundMode, TimeZoneLike
@@ -167,9 +167,15 @@ def date_deltas_whenever(
     *,
     min_value: MaybeSearchStrategy[DateDelta | None] = None,
     max_value: MaybeSearchStrategy[DateDelta | None] = None,
+    parsable: MaybeSearchStrategy[bool] = False,
 ) -> DateDelta:
     """Strategy for generating date deltas."""
-    from utilities.whenever2 import DATE_DELTA_MAX, DATE_DELTA_MIN
+    from utilities.whenever2 import (
+        DATE_DELTA_MAX,
+        DATE_DELTA_MIN,
+        DATE_DELTA_PARSABLE_MAX,
+        DATE_DELTA_PARSABLE_MIN,
+    )
 
     min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
     match min_value_:
@@ -192,6 +198,19 @@ def date_deltas_whenever(
     max_years, max_months, max_days = max_value_.in_years_months_days()
     assert max_years == 0
     assert max_months == 0
+    if draw2(draw, parsable):
+        parsable_min_years, parsable_min_months, parsable_min_days = (
+            DATE_DELTA_PARSABLE_MIN.in_years_months_days()
+        )
+        assert parsable_min_years == 0
+        assert parsable_min_months == 0
+        min_days = max(min_days, parsable_min_days)
+        parsable_max_years, parsable_max_months, parsable_max_days = (
+            DATE_DELTA_PARSABLE_MAX.in_years_months_days()
+        )
+        assert parsable_max_years == 0
+        assert parsable_max_months == 0
+        max_days = min(max_days, parsable_max_days)
     days = draw(integers(min_value=min_days, max_value=max_days))
     return DateDelta(days=days)
 
@@ -1050,6 +1069,8 @@ def plain_datetimes_whenever(
     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]]

{dycw_utilities-0.131.3 → dycw_utilities-0.131.5}/src/utilities/whenever2.py

@@ -7,10 +7,11 @@ from typing import TYPE_CHECKING, Any, override
 
 from whenever import Date, DateTimeDelta, PlainDateTime, ZonedDateTime
 
-from utilities.tzlocal import LOCAL_TIME_ZONE
 from utilities.zoneinfo import UTC, get_time_zone_name
 
 if TYPE_CHECKING:
+    from zoneinfo import ZoneInfo
+
     from utilities.types import TimeZoneLike
 
 
@@ -27,6 +28,11 @@ 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()
 
+DATE_TIME_DELTA_PARSABLE_MIN = DateTimeDelta(days=-999999)
+DATE_TIME_DELTA_PARSABLE_MAX = DateTimeDelta(days=999999)
+DATE_DELTA_PARSABLE_MIN = DATE_TIME_DELTA_PARSABLE_MIN.date_part()
+DATE_DELTA_PARSABLE_MAX = DATE_TIME_DELTA_PARSABLE_MAX.date_part()
+
 
 ##
 
@@ -88,7 +94,24 @@ class WheneverLogRecord(LogRecord):
         )
         length = self._get_length()
         plain = format(get_now_local().to_plain().format_common_iso(), f"{length}s")
-        self.zoned_datetime = f"{plain}[{LOCAL_TIME_ZONE.key}]"
+        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
@@ -101,10 +124,14 @@ class WheneverLogRecord(LogRecord):
 __all__ = [
     "DATE_DELTA_MAX",
     "DATE_DELTA_MIN",
+    "DATE_DELTA_PARSABLE_MAX",
+    "DATE_DELTA_PARSABLE_MIN",
     "DATE_MAX",
     "DATE_MIN",
     "DATE_TIME_DELTA_MAX",
     "DATE_TIME_DELTA_MIN",
+    "DATE_TIME_DELTA_PARSABLE_MAX",
+    "DATE_TIME_DELTA_PARSABLE_MIN",
     "PLAIN_DATE_TIME_MAX",
     "PLAIN_DATE_TIME_MIN",
     "TIME_DELTA_MAX",