dycw-utilities 0.131.11__py3-none-any.whl → 0.131.12__py3-none-any.whl

{dycw_utilities-0.131.11.dist-info → dycw_utilities-0.131.12.dist-info}/METADATA

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

{dycw_utilities-0.131.11.dist-info → dycw_utilities-0.131.12.dist-info}/RECORD

@@ -1,4 +1,4 @@
-utilities/__init__.py,sha256=wP5J8Mq8g6P6zyTVUVaa3X4tWb427OMAAyoOjt4J0qQ,61
+utilities/__init__.py,sha256=Mewpkpu3DcrrhZzBvzBQpI4GkBsPPKRq0bdDX_sR7t4,61
 utilities/aiolimiter.py,sha256=mD0wEiqMgwpty4XTbawFpnkkmJS6R4JRsVXFUaoitSU,628
 utilities/altair.py,sha256=HeZBVUocjkrTNwwKrClppsIqgNFF-ykv05HfZSoHYno,9104
 utilities/asyncio.py,sha256=yfKvAIDCRrWdyQMVZMo4DJQx4nVrXoAcqwhNuF95Ryo,38186
@@ -12,12 +12,12 @@ utilities/contextvars.py,sha256=RsSGGrbQqqZ67rOydnM7WWIsM2lIE31UHJLejnHJPWY,505
 utilities/cryptography.py,sha256=_CiK_K6c_-uQuUhsUNjNjTL-nqxAh4_1zTfS11Xe120,972
 utilities/cvxpy.py,sha256=Rv1-fD-XYerosCavRF8Pohop2DBkU3AlFaGTfD8AEAA,13776
 utilities/dataclasses.py,sha256=iiC1wpGXWhaocIikzwBt8bbLWyImoUlOlcDZJGejaIg,33011
-utilities/datetime.py,sha256=cDb0-fE7rRt3Gwl5vJ1HW0ZWf-wW7PHsQruD6or9hUo,38770
+utilities/datetime.py,sha256=uPQdUgJJ9KuF-pogjYRbI9lOK-i5UBzPHexWe4pOVEo,38713
 utilities/enum.py,sha256=HoRwVCWzsnH0vpO9ZEcAAIZLMv0Sn2vJxxA4sYMQgDs,5793
 utilities/errors.py,sha256=nC7ZYtxxDBMfrTHtT_MByBfup_wfGQFRo3eDt-0ZPe8,1045
 utilities/eventkit.py,sha256=6M5Xu1SzN-juk9PqBHwy5dS-ta7T0qA6SMpDsakOJ0E,13039
-utilities/fastapi.py,sha256=8ABDSOH99j7H8cpKLZhUT2JzU18wiBqcTQuBUlTe-QE,2937
-utilities/fpdf2.py,sha256=lqizPXpzdwfJk3ChcbbWVa7WNXO2uvy7KDzWQtVTnXA,1831
+utilities/fastapi.py,sha256=zDNPgfYNTZWQfS87y8ekgoJvTvmq07gv5m5kOyMYoX8,2796
+utilities/fpdf2.py,sha256=PQysO4BcSMRpg-h-t2Pm7yatyk2yFl1inkvtKs1NG4M,1853
 utilities/functions.py,sha256=jgt592voaHNtX56qX0SRvFveVCRmSIxCZmqvpLZCnY8,27305
 utilities/functools.py,sha256=WrpHt7NLNWSUn9A1Q_ZIWlNaYZOEI4IFKyBG9HO3BC4,1643
 utilities/getpass.py,sha256=DfN5UgMAtFCqS3dSfFHUfqIMZX2shXvwphOz_6J6f6A,103
@@ -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=JrkrAZMo6JID2Eoc9QCc05Y_pK4l2zsApIhmii1z2Ig,2764
-utilities/logging.py,sha256=GP2BqpUlb9T7v90sdavsweJnOxfSdK7cJKFdgKURJZo,17892
+utilities/logging.py,sha256=zm5k0Cduxtx2H2o7odxUTJtPNkJS85mqHYN1cS5Kc1w,17863
 utilities/luigi.py,sha256=fpH9MbxJDuo6-k9iCXRayFRtiVbUtibCJKugf7ygpv0,5988
 utilities/math.py,sha256=_6vrDyjtaqE_OFE-F2DNWrDG_J_kMl3nFAJsok9v_bY,26862
 utilities/memory_profiler.py,sha256=tf2C51P2lCujPGvRt2Rfc7VEw5LDXmVPCG3z_AvBmbU,962
@@ -41,7 +41,7 @@ utilities/more_itertools.py,sha256=tBbjjKx8_Uv_TCjxhPwrGfAx_jRHtvLIZqXVWAsjzqA,8
 utilities/numpy.py,sha256=Xn23sA2ZbVNqwUYEgNJD3XBYH6IbCri_WkHSNhg3NkY,26122
 utilities/operator.py,sha256=0M2yZJ0PODH47ogFEnkGMBe_cfxwZR02T_92LZVZvHo,3715
 utilities/optuna.py,sha256=loyJGWTzljgdJaoLhP09PT8Jz6o_pwBOwehY33lHkhw,1923
-utilities/orjson.py,sha256=vmPsuOOxrQBAg6aEVVKHfOX9A04QlSa162El5HrIT9E,36889
+utilities/orjson.py,sha256=oD9sQYd3bQKZi2dwpQsaRVwCSlSQ2sREl83UZP4LD7w,36962
 utilities/os.py,sha256=D_FyyT-6TtqiN9KSS7c9g1fnUtgxmyMtzAjmYLkk46A,3587
 utilities/parse.py,sha256=vsZ2jf_ceSI_Kta9titixufysJaVXh0Whjz1T4awJZw,18938
 utilities/pathlib.py,sha256=PK41rf1c9Wqv7h8f5R7H3_Lhq_gQZTUJD5tu3gMHVaU,3247
@@ -55,7 +55,7 @@ utilities/pqdm.py,sha256=foRytQybmOQ05pjt5LF7ANyzrIa--4ScDE3T2wd31a4,3118
 utilities/psutil.py,sha256=RtbLKOoIJhqrJmEoHDBVeSD-KPzshtS0FtRXBP9_w2s,3751
 utilities/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 utilities/pydantic.py,sha256=aP6OKowg2Md4rgQuQ5qTSF4bTbBuq7WtRb7zS3JSRGY,1841
-utilities/pyinstrument.py,sha256=KU7_wPX63TY_8kSps0WZ0ijpN7vXQUkp175vdg-CIdE,899
+utilities/pyinstrument.py,sha256=3MPNDbZW_1Aj1aA1_f-yqPStgmjIFxPwIafYq2dsaTs,853
 utilities/pyrsistent.py,sha256=wVOVIe_68AAaa-lUE9y-TEzDawVp1uEIc_zfoDgr5ww,2287
 utilities/pytest.py,sha256=zP4CWKXpRVk4aRDRxolUAvqQwX7wgDO8lzmkQfuZaZo,7832
 utilities/pytest_regressions.py,sha256=YI55B7EtLjhz7zPJZ6NK9bWrxrKCKabWZJe1cwcbA5o,5082
@@ -79,19 +79,19 @@ utilities/tenacity.py,sha256=1PUvODiBVgeqIh7G5TRt5WWMSqjLYkEqP53itT97WQc,4914
 utilities/text.py,sha256=ymBFlP_cA8OgNnZRVNs7FAh7OG8HxE6YkiLEMZv5g_A,11297
 utilities/threading.py,sha256=GvBOp4CyhHfN90wGXZuA2VKe9fGzMaEa7oCl4f3nnPU,1009
 utilities/timer.py,sha256=VeSl3ot8-f4D1d3HjjSsgKvjxHJGXd_sW4KcTExOR64,2475
-utilities/traceback.py,sha256=U8Du13z0qFo7sntup2x8xLw49KNb-QtEv7-UgziZ_Cw,8769
+utilities/traceback.py,sha256=cMXrCD59CROnezAU8VW67CxZ8Igc5QmaxlV8qrBvNMs,8504
 utilities/types.py,sha256=CHQke10ETEpypxppYVhWp1G68S6mvifalrRLolYBcCg,19506
-utilities/typing.py,sha256=kQWywPcRbFBKmvQBELmgbiqSHsnlo_D0ru53vl6KDeY,13846
+utilities/typing.py,sha256=VuGuztLSkTicxgVwI5wrVOTcY70OlzwsTU7LcFVjGlY,14169
 utilities/tzdata.py,sha256=yCf70NICwAeazN3_JcXhWvRqCy06XJNQ42j7r6gw3HY,1217
-utilities/tzlocal.py,sha256=P5BjqTiYskeCwjE7i9zycCFXO4MWdZgYCh4jut-LpzA,1042
+utilities/tzlocal.py,sha256=xbBBzVIUKMk8AkhuIp1qxGRNBioIa5I09dpeoBnIOOU,662
 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=2NQ-0SnLNW2kFpefP9dVE8H0RbaeusXYLPmv282Jpto,16755
-utilities/whenever2.py,sha256=76tFaAVX5CfXOjjMJ1Sg3LW85RoYARNZIALseCLG81k,7047
+utilities/whenever2.py,sha256=WiDVsgHA-4E-KiIJ25-R4qAWvtyBQk1EkhjMszFzQMM,7455
 utilities/zipfile.py,sha256=24lQc9ATcJxHXBPc_tBDiJk48pWyRrlxO2fIsFxU0A8,699
 utilities/zoneinfo.py,sha256=tvcgu3QzDxe2suTexi2QzRGpin7VK1TjHa0JYYxT69I,1862
-dycw_utilities-0.131.11.dist-info/METADATA,sha256=m2QhrLfCIpPGxtKXK8nVbiyX5ldnlLwNHjQnHy9UWkk,1585
-dycw_utilities-0.131.11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dycw_utilities-0.131.11.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
-dycw_utilities-0.131.11.dist-info/RECORD,,
+dycw_utilities-0.131.12.dist-info/METADATA,sha256=8G8r4jcsCl-iXqwXZ2vq8Kx7M4S2A6xCNxQA3Blrv64,1585
+dycw_utilities-0.131.12.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dycw_utilities-0.131.12.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
+dycw_utilities-0.131.12.dist-info/RECORD,,

utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.131.11"
+__version__ = "0.131.12"

utilities/datetime.py

@@ -21,21 +21,14 @@ from utilities.iterables import OneEmptyError, one
 from utilities.math import SafeRoundError, round_, safe_round
 from utilities.platform import SYSTEM
 from utilities.sentinel import Sentinel, sentinel
-from utilities.types import MaybeStr
+from utilities.types import MaybeCallablePyDate, MaybeCallablePyDateTime, MaybeStr
 from utilities.typing import is_instance_gen
 from utilities.zoneinfo import UTC, ensure_time_zone, get_time_zone_name
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
 
-    from utilities.types import (
-        DateOrDateTime,
-        Duration,
-        MathRoundMode,
-        MaybeCallablePyDate,
-        MaybeCallablePyDateTime,
-        TimeZoneLike,
-    )
+    from utilities.types import DateOrDateTime, Duration, MathRoundMode, TimeZoneLike
 
 
 _DAYS_PER_YEAR = 365.25

utilities/fastapi.py

@@ -9,8 +9,7 @@ from uvicorn import Config, Server
 
 from utilities.asyncio import Looper
 from utilities.datetime import SECOND, datetime_duration_to_float
-from utilities.tzlocal import get_now_local  # skipif-ci
-from utilities.whenever import serialize_zoned_datetime  # skipif-ci
+from utilities.whenever2 import get_now_local
 
 if TYPE_CHECKING:
     from types import TracebackType
@@ -31,8 +30,7 @@ class _PingerReceiverApp(FastAPI):
 
         @self.get("/ping")  # skipif-ci
         def ping() -> str:
-            now = serialize_zoned_datetime(get_now_local())  # skipif-ci
-            return f"pong @ {now}"  # skipif-ci
+            return f"pong @ {get_now_local()}"  # skipif-ci
 
         _ = ping  # skipif-ci
 

utilities/fpdf2.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, override
 from fpdf import FPDF
 from fpdf.enums import XPos, YPos
 
-from utilities.tzlocal import get_now_local
+from utilities.whenever2 import format_compact, get_now
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
@@ -47,7 +47,7 @@ def yield_pdf(*, header: str | None = None) -> Iterator[_BasePDF]:
         def footer(self) -> None:
             self.set_y(-15)
             self.set_font(family="Helvetica", style="I", size=8)
-            page_no, now = self.page_no(), get_now_local()
+            page_no, now = self.page_no(), format_compact(get_now())
             text = f"page {page_no}/{{}}; {now}"
             _ = self.cell(
                 w=0,

utilities/logging.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import datetime as dt
 import re
 from dataclasses import dataclass, field
 from functools import cached_property
@@ -19,7 +18,6 @@ from logging import (
 from logging.handlers import BaseRotatingHandler, TimedRotatingFileHandler
 from pathlib import Path
 from re import Pattern
-from time import time
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -32,17 +30,31 @@ from typing import (
     override,
 )
 
+from whenever import PlainDateTime, ZonedDateTime
+
 from utilities.atomicwrites import move_many
 from utilities.dataclasses import replace_non_sentinel
-from utilities.datetime import parse_datetime_compact, serialize_compact
 from utilities.errors import ImpossibleCaseError
 from utilities.iterables import OneEmptyError, always_iterable, one
 from utilities.pathlib import ensure_suffix, get_path
+from utilities.re import (
+    ExtractGroupError,
+    ExtractGroupsError,
+    extract_group,
+    extract_groups,
+)
 from utilities.sentinel import Sentinel, sentinel
-from utilities.tzlocal import get_now_local
+from utilities.tzlocal import LOCAL_TIME_ZONE_NAME
+from utilities.whenever2 import (
+    WheneverLogRecord,
+    format_compact,
+    get_now,
+    get_now_local,
+)
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Iterable, Mapping
+    from datetime import time
     from logging import _FilterType
 
     from utilities.types import (
@@ -54,7 +66,9 @@ if TYPE_CHECKING:
     )
 
 
-_DEFAULT_FORMAT = "{asctime} | {name}:{funcName}:{lineno} | {levelname:8} | {message}"
+_DEFAULT_FORMAT = (
+    "{zoned_datetime} | {name}:{funcName}:{lineno} | {levelname:8} | {message}"
+)
 _DEFAULT_DATEFMT = "%Y-%m-%d %H:%M:%S"
 _DEFAULT_BACKUP_COUNT: int = 100
 _DEFAULT_MAX_BYTES: int = 10 * 1024**2
@@ -76,7 +90,6 @@ def add_filters(handler: Handler, /, *filters: _FilterType) -> None:
 def basic_config(
     *,
     obj: LoggerOrName | Handler | None = None,
-    whenever: bool = False,
     format_: str = _DEFAULT_FORMAT,
     datefmt: str = _DEFAULT_DATEFMT,
     level: LogLevel = "INFO",
@@ -93,7 +106,6 @@ def basic_config(
             logger.addHandler(handler := StreamHandler())
             basic_config(
                 obj=handler,
-                whenever=whenever,
                 format_=format_,
                 datefmt=datefmt,
                 level=level,
@@ -104,7 +116,6 @@ def basic_config(
         case str() as name:
             basic_config(
                 obj=get_logger(logger=name),
-                whenever=whenever,
                 format_=format_,
                 datefmt=datefmt,
                 level=level,
@@ -117,7 +128,6 @@ def basic_config(
             if filters is not None:
                 add_filters(handler, *always_iterable(filters))
             formatter = get_formatter(
-                whenever=whenever,
                 format_=format_,
                 datefmt=datefmt,
                 plain=plain,
@@ -179,18 +189,13 @@ class _FieldStyleDict(TypedDict):
 
 def get_formatter(
     *,
-    whenever: bool = False,
     format_: str = _DEFAULT_FORMAT,
     datefmt: str = _DEFAULT_DATEFMT,
     plain: bool = False,
     color_field_styles: Mapping[str, _FieldStyleKeys] | None = None,
 ) -> Formatter:
     """Get the formatter; colored if available."""
-    if whenever:
-        from utilities.whenever2 import WheneverLogRecord
-
-        setLogRecordFactory(WheneverLogRecord)
-        format_ = format_.replace("{asctime}", "{zoned_datetime}")
+    setLogRecordFactory(WheneverLogRecord)
     if plain:
         return _get_plain_formatter(format_=format_, datefmt=datefmt)
     try:
@@ -199,8 +204,7 @@ def get_formatter(
         return _get_plain_formatter(format_=format_, datefmt=datefmt)
     default = cast("dict[_FieldStyleKeys, _FieldStyleDict]", DEFAULT_FIELD_STYLES)
     field_styles = {cast("str", k): v for k, v in default.items()}
-    if whenever:
-        field_styles["zoned_datetime"] = default["asctime"]
+    field_styles["zoned_datetime"] = default["asctime"]
     if color_field_styles is not None:
         field_styles.update({k: default[v] for k, v in color_field_styles.items()})
     return ColoredFormatter(
@@ -256,7 +260,6 @@ class GetLoggingLevelNumberError(Exception):
 def setup_logging(
     *,
     logger: LoggerOrName | None = None,
-    whenever: bool = False,
     format_: str = _DEFAULT_FORMAT,
     datefmt: str = _DEFAULT_DATEFMT,
     console_level: LogLevel = "INFO",
@@ -272,7 +275,6 @@ def setup_logging(
     """Set up logger."""
     basic_config(
         obj=logger,
-        whenever=whenever,
         format_=f"{console_prefix} {format_}",
         datefmt=datefmt,
         level=console_level,
@@ -295,7 +297,6 @@ def setup_logging(
             logger_use.addHandler(handler)
             basic_config(
                 obj=handler,
-                whenever=whenever,
                 format_=format_,
                 datefmt=datefmt,
                 level=level,
@@ -330,7 +331,7 @@ class SizeAndTimeRotatingFileHandler(BaseRotatingHandler):
         interval: int = 1,
         backupCount: int = _DEFAULT_BACKUP_COUNT,
         utc: bool = False,
-        atTime: dt.time | None = None,
+        atTime: time | None = None,
     ) -> None:
         path = Path(filename)
         path.parent.mkdir(parents=True, exist_ok=True)
@@ -382,7 +383,7 @@ class SizeAndTimeRotatingFileHandler(BaseRotatingHandler):
         if not self.delay:  # pragma: no cover
             self.stream = self._open()
         self._time_handler.rolloverAt = (  # skipif-ci-and-windows
-            self._time_handler.computeRollover(int(time()))
+            self._time_handler.computeRollover(get_now().timestamp())
         )
 
     def _should_rollover(self, record: LogRecord, /) -> bool:
@@ -400,10 +401,8 @@ class SizeAndTimeRotatingFileHandler(BaseRotatingHandler):
 def _compute_rollover_patterns(stem: str, suffix: str, /) -> _RolloverPatterns:
     return _RolloverPatterns(
         pattern1=re.compile(rf"^{stem}\.(\d+){suffix}$"),
-        pattern2=re.compile(rf"^{stem}\.(\d+)__(\d{{8}}T\d{{6}}){suffix}$"),
-        pattern3=re.compile(
-            rf"^{stem}\.(\d+)__(\d{{8}}T\d{{6}})__(\d{{8}}T\d{{6}}){suffix}$"
-        ),
+        pattern2=re.compile(rf"^{stem}\.(\d+)__([\dT]+?){suffix}$"),
+        pattern3=re.compile(rf"^{stem}\.(\d+)__([\dT]+?)__([\dT]+?){suffix}$"),
     )
 
 
@@ -452,7 +451,7 @@ def _compute_rollover_actions(
                 rotations.add(
                     _Rotation(file=file, index=curr + 1, start=start, end=end)
                 )
-            case int() as index, dt.datetime(), dt.datetime():
+            case int() as index, ZonedDateTime(), ZonedDateTime():
                 rotations.add(_Rotation(file=file, index=index + 1))
             case _:  # pragma: no cover
                 raise NotImplementedError
@@ -476,8 +475,8 @@ class _RotatingLogFile:
     stem: str
     suffix: str
     index: int | None = None
-    start: dt.datetime | None = None
-    end: dt.datetime | None = None
+    start: ZonedDateTime | None = None
+    end: ZonedDateTime | None = None
 
     @classmethod
     def from_path(
@@ -494,16 +493,23 @@ class _RotatingLogFile:
         if patterns is None:
             patterns = _compute_rollover_patterns(stem, suffix)
         try:
-            (index,) = patterns.pattern1.findall(path.name)
-        except ValueError:
+            index, start, end = extract_groups(patterns.pattern3, path.name)
+        except ExtractGroupsError:
             pass
         else:
             return cls(
-                directory=path.parent, stem=stem, suffix=suffix, index=int(index)
+                directory=path.parent,
+                stem=stem,
+                suffix=suffix,
+                index=int(index),
+                start=PlainDateTime.parse_common_iso(start).assume_tz(
+                    LOCAL_TIME_ZONE_NAME
+                ),
+                end=PlainDateTime.parse_common_iso(end).assume_tz(LOCAL_TIME_ZONE_NAME),
             )
         try:
-            ((index, end),) = patterns.pattern2.findall(path.name)
-        except ValueError:
+            index, end = extract_groups(patterns.pattern2, path.name)
+        except ExtractGroupsError:
             pass
         else:
             return cls(
@@ -511,21 +517,17 @@ class _RotatingLogFile:
                 stem=stem,
                 suffix=suffix,
                 index=int(index),
-                end=parse_datetime_compact(end),
+                end=PlainDateTime.parse_common_iso(end).assume_tz(LOCAL_TIME_ZONE_NAME),
             )
         try:
-            ((index, start, end),) = patterns.pattern3.findall(path.name)
-        except ValueError:
-            return cls(directory=path.parent, stem=stem, suffix=suffix)
+            index = extract_group(patterns.pattern1, path.name)
+        except ExtractGroupError:
+            pass
         else:
             return cls(
-                directory=path.parent,
-                stem=stem,
-                suffix=suffix,
-                index=int(index),
-                start=parse_datetime_compact(start),
-                end=parse_datetime_compact(end),
+                directory=path.parent, stem=stem, suffix=suffix, index=int(index)
             )
+        return cls(directory=path.parent, stem=stem, suffix=suffix)
 
     @cached_property
     def path(self) -> Path:
@@ -535,10 +537,10 @@ class _RotatingLogFile:
                 tail = None
             case int() as index, None, None:
                 tail = str(index)
-            case int() as index, None, dt.datetime() as end:
-                tail = f"{index}__{serialize_compact(end)}"
-            case int() as index, dt.datetime() as start, dt.datetime() as end:
-                tail = f"{index}__{serialize_compact(start)}__{serialize_compact(end)}"
+            case int() as index, None, ZonedDateTime() as end:
+                tail = f"{index}__{format_compact(end)}"
+            case int() as index, ZonedDateTime() as start, ZonedDateTime() as end:
+                tail = f"{index}__{format_compact(start)}__{format_compact(end)}"
             case _:  # pragma: no cover
                 raise ImpossibleCaseError(
                     case=[f"{self.index=}", f"{self.start=}", f"{self.end=}"]
@@ -550,8 +552,8 @@ class _RotatingLogFile:
         self,
         *,
         index: int | None | Sentinel = sentinel,
-        start: dt.datetime | None | Sentinel = sentinel,
-        end: dt.datetime | None | Sentinel = sentinel,
+        start: ZonedDateTime | None | Sentinel = sentinel,
+        end: ZonedDateTime | None | Sentinel = sentinel,
     ) -> Self:
         return replace_non_sentinel(self, index=index, start=start, end=end)
 
@@ -568,8 +570,8 @@ class _Deletion:
 class _Rotation:
     file: _RotatingLogFile
     index: int = 0
-    start: dt.datetime | None | Sentinel = sentinel
-    end: dt.datetime | Sentinel = sentinel
+    start: ZonedDateTime | None | Sentinel = sentinel
+    end: ZonedDateTime | Sentinel = sentinel
 
     @cached_property
     def destination(self) -> Path:

utilities/orjson.py

@@ -14,6 +14,7 @@ from pathlib import Path
 from re import Pattern, search
 from typing import TYPE_CHECKING, Any, Literal, Self, assert_never, overload, override
 from uuid import UUID
+from zoneinfo import ZoneInfo
 
 from orjson import (
     OPT_PASSTHROUGH_DATACLASS,
@@ -22,6 +23,7 @@ from orjson import (
     dumps,
     loads,
 )
+from whenever import ZonedDateTime
 
 from utilities.concurrent import concurrent_map
 from utilities.dataclasses import dataclass_to_dict
@@ -35,15 +37,8 @@ from utilities.iterables import (
 )
 from utilities.logging import get_logging_level_number
 from utilities.math import MAX_INT64, MIN_INT64
-from utilities.types import (
-    Dataclass,
-    DateOrDateTime,
-    LogLevel,
-    MaybeIterable,
-    PathLike,
-    StrMapping,
-)
-from utilities.tzlocal import get_local_time_zone
+from utilities.types import Dataclass, LogLevel, MaybeIterable, PathLike, StrMapping
+from utilities.tzlocal import LOCAL_TIME_ZONE
 from utilities.uuid import UUID_PATTERN
 from utilities.version import Version, parse_version
 from utilities.whenever import (
@@ -57,12 +52,14 @@ from utilities.whenever import (
     serialize_time,
     serialize_timedelta,
 )
-from utilities.zoneinfo import ensure_time_zone
+from utilities.whenever2 import from_timestamp
 
 if TYPE_CHECKING:
     from collections.abc import Set as AbstractSet
     from logging import _FormatStyle
 
+    from whenever import Date
+
     from utilities.types import Parallelism
 
 
@@ -92,6 +89,7 @@ class _Prefixes(Enum):
     unserializable = "un"
     uuid = "uu"
     version = "v"
+    zoned_datetime = "zd"
 
 
 type _DataclassHook = Callable[[type[Dataclass], StrMapping], StrMapping]
@@ -194,6 +192,8 @@ def _pre_process(
             return f"[{_Prefixes.exception_class.value}|{error_cls.__qualname__}]"
         case Version() as version:
             return f"[{_Prefixes.version.value}]{version!s}"
+        case ZonedDateTime() as datetime:
+            return f"[{_Prefixes.zoned_datetime.value}]{datetime}"
         # contains
         case Dataclass() as dataclass:
             asdict = dataclass_to_dict(
@@ -350,6 +350,11 @@ _ZONED_DATETIME_PATTERN = re.compile(
     + _Prefixes.datetime.value
     + r"\](\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,6})?[\+\-]\d{2}:\d{2}(?::\d{2})?\[(?!(?:dt\.)).+?\])$"
 )
+_ZONED_DATETIME_PATTERN2 = re.compile(
+    r"^\["
+    + _Prefixes.zoned_datetime.value
+    + r"\](\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?[\+\-]\d{2}:\d{2}(?::\d{2})?\[(?!(?:dt\.)).+?\])$"
+)
 
 
 def _make_unit_pattern(prefix: _Prefixes, /) -> Pattern[str]:
@@ -437,6 +442,8 @@ def _object_hook(
                 return parse_version(match.group(1))
             if match := _ZONED_DATETIME_PATTERN.search(text):
                 return parse_zoned_datetime(match.group(1))
+            if match := _ZONED_DATETIME_PATTERN2.search(text):
+                return ZonedDateTime.parse_common_iso(match.group(1))
             if (
                 exc_class := _object_hook_exception_class(
                     text, data=data, objects=objects, redirects=redirects
@@ -753,9 +760,7 @@ class OrjsonFormatter(Formatter):
             path_name=Path(record.pathname),
             line_num=record.lineno,
             message=record.getMessage(),
-            datetime=dt.datetime.fromtimestamp(
-                record.created, tz=get_local_time_zone()
-            ),
+            datetime=from_timestamp(record.created, time_zone="local"),
             func_name=record.funcName,
             extra=extra if len(extra) >= 1 else None,
         )
@@ -859,11 +864,16 @@ class GetLogRecordsOutput:
             for r in self.records
         ]
         if len(records) >= 1:
-            time_zone = one_unique(ensure_time_zone(r.datetime) for r in records)
+            time_zone = one_unique(ZoneInfo(r.datetime.tz) for r in records)
         else:
-            time_zone = get_local_time_zone()
+            time_zone = LOCAL_TIME_ZONE
         return DataFrame(
-            data=[dataclass_to_dict(r, recursive=False) for r in records],
+            data=[
+                dataclass_to_dict(
+                    replace(r, datetime=r.datetime.py_datetime()), recursive=False
+                )
+                for r in records
+            ],
             schema={
                 "index": UInt64,
                 "name": String,
@@ -891,9 +901,12 @@ class GetLogRecordsOutput:
         level: LogLevel | None = None,
         min_level: LogLevel | None = None,
         max_level: LogLevel | None = None,
-        date_or_datetime: DateOrDateTime | None = None,
-        min_date_or_datetime: DateOrDateTime | None = None,
-        max_date_or_datetime: DateOrDateTime | None = None,
+        date: Date | None = None,
+        min_date: Date | None = None,
+        max_date: Date | None = None,
+        datetime: ZonedDateTime | None = None,
+        min_datetime: ZonedDateTime | None = None,
+        max_datetime: ZonedDateTime | None = None,
         func_name: bool | str | None = None,
         extra: bool | MaybeIterable[str] | None = None,
         log_file: bool | PathLike | None = None,
@@ -932,30 +945,18 @@ class GetLogRecordsOutput:
             records = [
                 r for r in records if r.level <= get_logging_level_number(max_level)
             ]
-        if date_or_datetime is not None:
-            match date_or_datetime:
-                case dt.datetime() as datetime:
-                    records = [r for r in records if r.datetime == datetime]
-                case dt.date() as date:
-                    records = [r for r in records if r.date == date]
-                case _ as never:
-                    assert_never(never)
-        if min_date_or_datetime is not None:
-            match min_date_or_datetime:
-                case dt.datetime() as min_datetime:
-                    records = [r for r in records if r.datetime >= min_datetime]
-                case dt.date() as min_date:
-                    records = [r for r in records if r.date >= min_date]
-                case _ as never:
-                    assert_never(never)
-        if max_date_or_datetime is not None:
-            match max_date_or_datetime:
-                case dt.datetime() as max_datetime:
-                    records = [r for r in records if r.datetime <= max_datetime]
-                case dt.date() as max_date:
-                    records = [r for r in records if r.date <= max_date]
-                case _ as never:
-                    assert_never(never)
+        if date is not None:
+            records = [r for r in records if r.date == date]
+        if min_date is not None:
+            records = [r for r in records if r.date >= min_date]
+        if max_date is not None:
+            records = [r for r in records if r.date <= max_date]
+        if datetime is not None:
+            records = [r for r in records if r.datetime == datetime]
+        if min_datetime is not None:
+            records = [r for r in records if r.datetime >= min_datetime]
+        if max_datetime is not None:
+            records = [r for r in records if r.datetime <= max_datetime]
         if func_name is not None:
             match func_name:
                 case bool() as has_func_name:
@@ -1058,7 +1059,7 @@ class OrjsonLogRecord:
     level: int
     path_name: Path
     line_num: int
-    datetime: dt.datetime
+    datetime: ZonedDateTime
     func_name: str | None = None
     stack_info: str | None = None
     extra: StrMapping | None = None
@@ -1066,7 +1067,7 @@ class OrjsonLogRecord:
     log_file_line_num: int | None = None
 
     @cached_property
-    def date(self) -> dt.date:
+    def date(self) -> Date:
         return self.datetime.date()
 
 

utilities/pyinstrument.py

@@ -7,9 +7,8 @@ from typing import TYPE_CHECKING
 from pyinstrument.profiler import Profiler
 
 from utilities.atomicwrites import writer
-from utilities.datetime import serialize_compact
 from utilities.pathlib import get_path
-from utilities.tzlocal import get_now_local
+from utilities.whenever2 import format_compact, get_now
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
@@ -23,7 +22,7 @@ def profile(*, path: MaybeCallablePathLike | None = Path.cwd) -> Iterator[None]:
     with Profiler() as profiler:
         yield
     filename = get_path(path=path).joinpath(
-        f"profile__{serialize_compact(get_now_local())}.html"
+        f"profile__{format_compact(get_now())}.html"
     )
     with writer(filename) as temp, temp.open(mode="w") as fh:
         _ = fh.write(profiler.output_html())

utilities/traceback.py

@@ -14,7 +14,6 @@ from traceback import TracebackException
 from typing import TYPE_CHECKING, override
 
 from utilities.atomicwrites import writer
-from utilities.datetime import get_datetime, get_now, serialize_compact
 from utilities.errors import repr_error
 from utilities.iterables import OneEmptyError, one
 from utilities.pathlib import get_path
@@ -27,16 +26,19 @@ from utilities.reprlib import (
     RICH_MAX_WIDTH,
     yield_mapping_repr,
 )
-from utilities.tzlocal import get_local_time_zone, get_now_local
 from utilities.version import get_version
-from utilities.whenever import serialize_duration, serialize_zoned_datetime
+from utilities.whenever2 import format_compact, get_now, to_zoned_date_time
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Iterator, Sequence
     from traceback import FrameSummary
     from types import TracebackType
 
-    from utilities.types import MaybeCallablePathLike, MaybeCallablePyDateTime, PathLike
+    from utilities.types import (
+        MaybeCallablePathLike,
+        MaybeCallableZonedDateTime,
+        PathLike,
+    )
     from utilities.version import MaybeCallableVersionLike
 
 
@@ -51,7 +53,7 @@ def format_exception_stack(
     /,
     *,
     header: bool = False,
-    start: MaybeCallablePyDateTime | None = _START,
+    start: MaybeCallableZonedDateTime | None = _START,
     version: MaybeCallableVersionLike | None = None,
     capture_locals: bool = False,
     max_width: int = RICH_MAX_WIDTH,
@@ -82,21 +84,18 @@ def format_exception_stack(
 
 def _yield_header_lines(
     *,
-    start: MaybeCallablePyDateTime | None = _START,
+    start: MaybeCallableZonedDateTime | None = _START,
     version: MaybeCallableVersionLike | None = None,
 ) -> Iterator[str]:
     """Yield the header lines."""
-    now = get_now_local()
-    start_use = get_datetime(datetime=start)
-    start_use = (
-        None if start_use is None else start_use.astimezone(get_local_time_zone())
-    )
-    yield f"Date/time | {serialize_zoned_datetime(now)}"
-    start_str = "" if start_use is None else serialize_zoned_datetime(start_use)
+    now = get_now()
+    start_use = to_zoned_date_time(date_time=start)
+    yield f"Date/time | {format_compact(now)}"
+    start_str = "" if start_use is None else format_compact(start_use)
     yield f"Started   | {start_str}"
-    duration = None if start_use is None else (now - start_use)
-    duration_str = "" if duration is None else serialize_duration(duration)
-    yield f"Duration  | {duration_str}"
+    delta = None if start_use is None else (now - start_use)
+    delta_str = "" if delta is None else delta.format_common_iso()
+    yield f"Duration  | {delta_str}"
     yield f"User      | {getuser()}"
     yield f"Host      | {gethostname()}"
     version_use = "" if version is None else get_version(version=version)
@@ -193,7 +192,7 @@ def _trim_path(path: PathLike, pattern: str, /) -> Path | None:
 
 def make_except_hook(
     *,
-    start: MaybeCallablePyDateTime | None = _START,
+    start: MaybeCallableZonedDateTime | None = _START,
     version: MaybeCallableVersionLike | None = None,
     path: MaybeCallablePathLike | None = None,
     max_width: int = RICH_MAX_WIDTH,
@@ -228,7 +227,7 @@ def _make_except_hook_inner(
     traceback: TracebackType | None,
     /,
     *,
-    start: MaybeCallablePyDateTime | None = _START,
+    start: MaybeCallableZonedDateTime | None = _START,
     version: MaybeCallableVersionLike | None = None,
     path: MaybeCallablePathLike | None = None,
     max_width: int = RICH_MAX_WIDTH,
@@ -247,9 +246,7 @@ def _make_except_hook_inner(
     _ = sys.stderr.write(f"{slim}\n")  # don't 'from sys import stderr'
     if path is not None:
         path = (
-            get_path(path=path)
-            .joinpath(serialize_compact(get_now_local()))
-            .with_suffix(".txt")
+            get_path(path=path).joinpath(format_compact(get_now())).with_suffix(".txt")
         )
         full = format_exception_stack(
             exc_val,

utilities/typing.py

@@ -25,6 +25,16 @@ from typing import get_type_hints as _get_type_hints
 from uuid import UUID
 from warnings import warn
 
+from whenever import (
+    Date,
+    DateDelta,
+    DateTimeDelta,
+    PlainDateTime,
+    Time,
+    TimeDelta,
+    ZonedDateTime,
+)
+
 from utilities.iterables import unique_everseen
 from utilities.sentinel import Sentinel
 from utilities.types import StrMapping
@@ -133,7 +143,21 @@ def get_type_hints(
 ) -> dict[str, Any]:
     """Get the type hints of an object."""
     result: dict[str, Any] = obj.__annotations__
-    _ = {Literal, Path, Sentinel, StrMapping, UUID, dt}
+    _ = {
+        Date,
+        DateDelta,
+        DateTimeDelta,
+        Literal,
+        Path,
+        PlainDateTime,
+        Sentinel,
+        StrMapping,
+        Time,
+        TimeDelta,
+        UUID,
+        ZonedDateTime,
+        dt,
+    }
     globalns_use = globals() | ({} if globalns is None else dict(globalns))
     localns_use = {} if localns is None else dict(localns)
     try:

utilities/tzlocal.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import datetime as dt
 from logging import getLogger
 from typing import TYPE_CHECKING
 
@@ -21,30 +20,7 @@ def get_local_time_zone() -> ZoneInfo:
 
 
 LOCAL_TIME_ZONE = get_local_time_zone()
+LOCAL_TIME_ZONE_NAME = LOCAL_TIME_ZONE.key
 
 
-def get_now_local() -> dt.datetime:
-    """Get the current local time."""
-    return dt.datetime.now(tz=LOCAL_TIME_ZONE)
-
-
-NOW_LOCAL = get_now_local()
-
-
-def get_today_local() -> dt.date:
-    """Get the current, timezone-aware local date."""
-    return get_now_local().date()
-
-
-TODAY_LOCAL = get_today_local()
-
-
-__all__ = [
-    "LOCAL_TIME_ZONE",
-    "LOCAL_TIME_ZONE",
-    "NOW_LOCAL",
-    "TODAY_LOCAL",
-    "get_local_time_zone",
-    "get_now_local",
-    "get_today_local",
-]
+__all__ = ["LOCAL_TIME_ZONE", "LOCAL_TIME_ZONE_NAME", "get_local_time_zone"]

utilities/whenever2.py

@@ -16,7 +16,9 @@ from whenever import (
     ZonedDateTime,
 )
 
+from utilities.datetime import maybe_sub_pct_y
 from utilities.sentinel import Sentinel, sentinel
+from utilities.tzlocal import LOCAL_TIME_ZONE_NAME
 from utilities.zoneinfo import UTC, get_time_zone_name
 
 if TYPE_CHECKING:
@@ -72,6 +74,15 @@ WEEK = DateDelta(weeks=1)
 ##
 
 
+def format_compact(datetime: ZonedDateTime, /) -> str:
+    """Convert a zoned datetime to the local time zone, then format."""
+    py_datetime = datetime.round().to_tz(LOCAL_TIME_ZONE_NAME).to_plain().py_datetime()
+    return py_datetime.strftime(maybe_sub_pct_y("%Y%m%dT%H%M%S"))
+
+
+##
+
+
 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))
@@ -255,6 +266,7 @@ __all__ = [
     "ZONED_DATE_TIME_MAX",
     "ZONED_DATE_TIME_MIN",
     "WheneverLogRecord",
+    "format_compact",
     "from_timestamp",
     "from_timestamp_millis",
     "from_timestamp_nanos",