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

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_TIME_ZONE),
             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()