dycw-utilities 0.131.11__tar.gz → 0.131.12__tar.gz

{dycw_utilities-0.131.11 → dycw_utilities-0.131.12}/PKG-INFO

@@ -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 → dycw_utilities-0.131.12}/pyproject.toml

@@ -94,7 +94,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.131.11"
+version = "0.131.12"
 
 [project.optional-dependencies]
 logging = [
@@ -121,7 +121,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.131.11"
+current_version = "0.131.12"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.131.11 → dycw_utilities-0.131.12}/src/tests/conftest.py

@@ -2,7 +2,8 @@ from __future__ import annotations
 
 import re
 from asyncio import sleep
-from contextlib import suppress
+from contextlib import AbstractContextManager, contextmanager, suppress
+from logging import LogRecord, setLogRecordFactory
 from os import environ
 from re import MULTILINE, Pattern
 from typing import TYPE_CHECKING, Any
@@ -16,7 +17,7 @@ from utilities.re import ExtractGroupError, extract_group
 from utilities.text import strip_and_dedent
 
 if TYPE_CHECKING:
-    from collections.abc import Sequence
+    from collections.abc import Iterator, Sequence
     from pathlib import Path
 
     from _pytest.fixtures import SubRequest
@@ -43,6 +44,21 @@ else:
     setup_hypothesis_profiles()
 
 
+# fixture - logging
+
+
+@fixture
+def set_log_factory() -> AbstractContextManager[None]:
+    @contextmanager
+    def cm() -> Iterator[None]:
+        try:
+            yield
+        finally:
+            setLogRecordFactory(LogRecord)
+
+    return cm()
+
+
 # fixtures - sqlalchemy
 
 

{dycw_utilities-0.131.11 → dycw_utilities-0.131.12}/src/tests/test_dataclasses.py

@@ -928,7 +928,9 @@ class TestYieldFields:
         assert get_args(args[0]) == ("true", "false")
 
     def test_class_orjson_log_record(self) -> None:
-        result = list(yield_fields(OrjsonLogRecord, globalns=globals()))
+        result = list(
+            yield_fields(OrjsonLogRecord, globalns=globals(), warn_name_errors=True)
+        )
         exp_head = [
             _YieldFieldsClass(name="name", type_=str, kw_only=True),
             _YieldFieldsClass(name="message", type_=str, kw_only=True),

{dycw_utilities-0.131.11 → dycw_utilities-0.131.12}/src/tests/test_logging.py

@@ -1,16 +1,8 @@
 from __future__ import annotations
 
 from asyncio import sleep
-from contextlib import contextmanager
 from io import StringIO
-from logging import (
-    Formatter,
-    Logger,
-    LogRecord,
-    StreamHandler,
-    getLogger,
-    setLogRecordFactory,
-)
+from logging import Formatter, Logger, StreamHandler, getLogger
 from pathlib import Path
 from re import search
 from typing import TYPE_CHECKING, Any, cast
@@ -20,13 +12,12 @@ from hypothesis.strategies import booleans, integers, none, sampled_from
 from pytest import LogCaptureFixture, mark, param, raises
 
 from tests.conftest import SKIPIF_CI_AND_WINDOWS
-from utilities.datetime import NOW_UTC, SECOND, serialize_compact
 from utilities.hypothesis import (
     assume_does_not_raise,
     pairs,
     temp_paths,
     text_ascii,
-    zoned_datetimes,
+    zoned_datetimes_whenever,
 )
 from utilities.iterables import one
 from utilities.logging import (
@@ -47,19 +38,14 @@ from utilities.logging import (
 from utilities.text import unique_str
 from utilities.types import LogLevel
 from utilities.typing import get_args
+from utilities.whenever2 import format_compact, get_now
 
 if TYPE_CHECKING:
-    import datetime as dt
-    from collections.abc import Iterator, Mapping
+    from collections.abc import Mapping
+    from contextlib import AbstractContextManager
     from logging import _FilterType
 
-
-@contextmanager
-def _temp_log_factory() -> Iterator[None]:
-    try:
-        yield
-    finally:
-        setLogRecordFactory(LogRecord)
+    from whenever import ZonedDateTime
 
 
 class TestAddFilters:
@@ -81,7 +67,6 @@ class TestAddFilters:
 
 
 class TestBasicConfig:
-    @mark.parametrize("whenever", [param(True), param(False)])
     @mark.parametrize(
         "filters",
         [
@@ -94,21 +79,20 @@ class TestBasicConfig:
         self,
         *,
         caplog: LogCaptureFixture,
-        whenever: bool,
         filters: _FilterType | None,
         plain: bool,
+        set_log_factory: AbstractContextManager[None],
     ) -> None:
         name = unique_str()
-        with _temp_log_factory():
-            basic_config(obj=name, whenever=whenever, filters=filters, plain=plain)
-            getLogger(name).warning("message")
-            record = one(r for r in caplog.records if r.name == name)
-            assert record.message == "message"
+        with set_log_factory:
+            basic_config(obj=name, filters=filters, plain=plain)
+        getLogger(name).warning("message")
+        record = one(r for r in caplog.records if r.name == name)
+        assert record.message == "message"
 
-    @mark.parametrize("whenever", [param(True), param(False)])
-    def test_none(self, *, whenever: bool) -> None:
-        with _temp_log_factory():
-            basic_config(whenever=whenever)
+    def test_none(self, *, set_log_factory: AbstractContextManager[None]) -> None:
+        with set_log_factory:
+            basic_config()
 
 
 class TestComputeRolloverActions:
@@ -208,7 +192,7 @@ class TestComputeRolloverActions:
 
         await sleep(1)
         tmp_path.joinpath("log.txt").touch()
-        now = serialize_compact(NOW_UTC)
+        now = format_compact(get_now())
         tmp_path.joinpath(f"log.99__{now}__{now}.txt").touch()
         actions = _compute_rollover_actions(tmp_path, "log", ".txt")
         assert len(actions.deletions) == 2
@@ -249,21 +233,20 @@ class TestFilterForKey:
 
 
 class TestGetFormatter:
-    @mark.parametrize("whenever", [param(True), param(False)])
     @mark.parametrize("plain", [param(True), param(False)])
     @mark.parametrize("color_field_styles", [param({}), param(None)])
     def test_main(
         self,
         *,
-        whenever: bool,
         plain: bool,
         color_field_styles: Mapping[str, _FieldStyleKeys] | None,
+        set_log_factory: AbstractContextManager[None],
     ) -> None:
-        with _temp_log_factory():
+        with set_log_factory:
             formatter = get_formatter(
-                whenever=whenever, plain=plain, color_field_styles=color_field_styles
+                plain=plain, color_field_styles=color_field_styles
             )
-            assert isinstance(formatter, Formatter)
+        assert isinstance(formatter, Formatter)
 
 
 class TestGetLogger:
@@ -332,42 +315,35 @@ class TestRotatingLogFile:
         assert result.start is None
         assert result.end is None
 
-    @given(
-        index=integers(min_value=1),
-        end=zoned_datetimes(round_="standard", timedelta=SECOND),
-    )
+    @given(index=integers(min_value=1), end=zoned_datetimes_whenever())
     def test_from_path_with_index_and_end(
-        self, *, index: int, end: dt.datetime
+        self, *, index: int, end: ZonedDateTime
     ) -> None:
-        path = Path(f"log.{index}__{serialize_compact(end)}.txt")
+        path = Path(f"log.{index}__{format_compact(end)}.txt")
         result = _RotatingLogFile.from_path(path, "log", ".txt")
         assert result is not None
         assert result.stem == "log"
         assert result.suffix == ".txt"
         assert result.index == index
         assert result.start is None
-        assert result.end == end
+        assert result.end == end.round()
 
     @given(
         index=integers(min_value=1),
-        datetimes=pairs(
-            zoned_datetimes(round_="standard", timedelta=SECOND), sorted=True
-        ),
+        datetimes=pairs(zoned_datetimes_whenever(), sorted=True),
     )
     def test_from_path_with_index_start_and_end(
-        self, *, index: int, datetimes: tuple[dt.datetime, dt.datetime]
+        self, *, index: int, datetimes: tuple[ZonedDateTime, ZonedDateTime]
     ) -> None:
         start, end = datetimes
-        path = Path(
-            f"log.{index}__{serialize_compact(start)}__{serialize_compact(end)}.txt"
-        )
+        path = Path(f"log.{index}__{format_compact(start)}__{format_compact(end)}.txt")
         result = _RotatingLogFile.from_path(path, "log", ".txt")
         assert result is not None
         assert result.stem == "log"
         assert result.suffix == ".txt"
         assert result.index == index
-        assert result.start == start
-        assert result.end == end
+        assert result.start == start.round()
+        assert result.end == end.round()
 
     def test_from_path_none(self) -> None:
         path = Path("invalid.txt")
@@ -384,34 +360,30 @@ class TestRotatingLogFile:
         assert file.path == root.joinpath(f"log.{index}.txt")
 
     @given(
-        root=temp_paths(),
-        index=integers(min_value=1),
-        end=zoned_datetimes(round_="standard", timedelta=SECOND),
+        root=temp_paths(), index=integers(min_value=1), end=zoned_datetimes_whenever()
     )
     def test_path_with_index_and_end(
-        self, *, root: Path, index: int, end: dt.datetime
+        self, *, root: Path, index: int, end: ZonedDateTime
     ) -> None:
         file = _RotatingLogFile(
             directory=root, stem="log", suffix=".txt", index=index, end=end
         )
-        assert file.path == root.joinpath(f"log.{index}__{serialize_compact(end)}.txt")
+        assert file.path == root.joinpath(f"log.{index}__{format_compact(end)}.txt")
 
     @given(
         root=temp_paths(),
         index=integers(min_value=1),
-        datetimes=pairs(
-            zoned_datetimes(round_="standard", timedelta=SECOND), sorted=True
-        ),
+        datetimes=pairs(zoned_datetimes_whenever(), sorted=True),
     )
     def test_path_with_index_start_and_end(
-        self, *, root: Path, index: int, datetimes: tuple[dt.datetime, dt.datetime]
+        self, *, root: Path, index: int, datetimes: tuple[ZonedDateTime, ZonedDateTime]
     ) -> None:
         start, end = datetimes
         file = _RotatingLogFile(
             directory=root, stem="log", suffix=".txt", index=index, start=start, end=end
         )
         assert file.path == root.joinpath(
-            f"log.{index}__{serialize_compact(start)}__{serialize_compact(end)}.txt"
+            f"log.{index}__{format_compact(start)}__{format_compact(end)}.txt"
         )
 
 
@@ -440,8 +412,7 @@ class TestSizeAndTimeRotatingFileHandler:
         filename = tmp_path.joinpath("log")
         logger.addHandler(SizeAndTimeRotatingFileHandler(filename=filename))
         logger.warning("message")
-        with filename.open() as fh:
-            content = fh.read()
+        content = filename.read_text()
         assert content == "message\n"
 
     def test_create_parents(self, *, tmp_path: Path) -> None:

{dycw_utilities-0.131.11 → dycw_utilities-0.131.12}/src/tests/test_orjson.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import datetime as dt
 from collections.abc import Iterable
 from io import StringIO
 from logging import DEBUG, WARNING, FileHandler, StreamHandler, getLogger
@@ -12,7 +11,6 @@ from hypothesis import assume, given
 from hypothesis.strategies import (
     booleans,
     builds,
-    dates,
     dictionaries,
     integers,
     lists,
@@ -51,16 +49,16 @@ from tests.test_typing_funcs.with_future import (
     DataClassFutureTypeLiteral,
     DataClassFutureTypeLiteralNullable,
 )
-from utilities.datetime import MINUTE, SECOND, get_now
 from utilities.functions import is_sequence_of
 from utilities.hypothesis import (
     assume_does_not_raise,
+    dates_whenever,
     int64s,
     paths,
     temp_paths,
     text_ascii,
     text_printable,
-    zoned_datetimes,
+    zoned_datetimes_whenever,
 )
 from utilities.iterables import always_iterable, one
 from utilities.logging import get_logging_level_number
@@ -81,13 +79,15 @@ from utilities.orjson import (
 )
 from utilities.polars import check_polars_dataframe, zoned_datetime
 from utilities.sentinel import Sentinel, sentinel
-from utilities.types import DateOrDateTime, LogLevel, MaybeIterable, PathLike
+from utilities.types import LogLevel, MaybeIterable, PathLike
 from utilities.typing import get_args
-from utilities.tzlocal import get_now_local
+from utilities.whenever2 import MINUTE, SECOND, get_now
 
 if TYPE_CHECKING:
     from collections.abc import Sequence
 
+    from whenever import Date, ZonedDateTime
+
     from utilities.types import Dataclass, StrMapping
 
 
@@ -195,9 +195,12 @@ class TestGetLogRecords:
         level=sampled_from(get_args(LogLevel)) | none(),
         min_level=sampled_from(get_args(LogLevel)) | none(),
         max_level=sampled_from(get_args(LogLevel)) | none(),
-        date_or_datetime=dates() | zoned_datetimes() | none(),
-        min_date_or_datetime=dates() | zoned_datetimes() | none(),
-        max_date_or_datetime=dates() | zoned_datetimes() | none(),
+        date=dates_whenever() | none(),
+        min_date=dates_whenever() | none(),
+        max_date=dates_whenever() | none(),
+        datetime=zoned_datetimes_whenever() | none(),
+        min_datetime=zoned_datetimes_whenever() | none(),
+        max_datetime=zoned_datetimes_whenever() | none(),
         func_name=booleans() | text_ascii() | none(),
         extra=booleans() | text_ascii() | sets(text_ascii()) | none(),
         log_file=booleans() | paths() | text_ascii() | none(),
@@ -218,9 +221,12 @@ class TestGetLogRecords:
         level: LogLevel | None,
         min_level: LogLevel | None,
         max_level: LogLevel | None,
-        date_or_datetime: DateOrDateTime | None,
-        min_date_or_datetime: DateOrDateTime | None,
-        max_date_or_datetime: DateOrDateTime | None,
+        date: Date | None,
+        min_date: Date | None,
+        max_date: Date | None,
+        datetime: ZonedDateTime | None,
+        min_datetime: ZonedDateTime | None,
+        max_datetime: ZonedDateTime | None,
         func_name: bool | str | None,
         extra: bool | MaybeIterable[str] | None,
         log_file: bool | PathLike | None,
@@ -245,9 +251,12 @@ class TestGetLogRecords:
             level=level,
             min_level=min_level,
             max_level=max_level,
-            date_or_datetime=date_or_datetime,
-            min_date_or_datetime=min_date_or_datetime,
-            max_date_or_datetime=max_date_or_datetime,
+            date=date,
+            min_date=min_date,
+            max_date=max_date,
+            datetime=datetime,
+            min_datetime=min_datetime,
+            max_datetime=max_datetime,
             func_name=func_name,
             extra=extra,
             log_file=log_file,
@@ -272,24 +281,18 @@ class TestGetLogRecords:
             assert all(r.level >= get_logging_level_number(min_level) for r in records)
         if max_level is not None:
             assert all(r.level <= get_logging_level_number(max_level) for r in records)
-        if date_or_datetime is not None:
-            match date_or_datetime:
-                case dt.datetime() as datetime:
-                    assert all(r.datetime == datetime for r in records)
-                case dt.date() as date:
-                    assert all(r.date == date for r in records)
-        if min_date_or_datetime is not None:
-            match min_date_or_datetime:
-                case dt.datetime() as min_datetime:
-                    assert all(r.datetime >= min_datetime for r in records)
-                case dt.date() as min_date:
-                    assert all(r.date >= min_date for r in records)
-        if max_date_or_datetime is not None:
-            match max_date_or_datetime:
-                case dt.datetime() as max_datetime:
-                    assert all(r.datetime <= max_datetime for r in records)
-                case dt.date() as max_date:
-                    assert all(r.date <= max_date for r in records)
+        if date is not None:
+            assert all(r.date == date for r in records)
+        if min_date is not None:
+            assert all(r.date >= min_date for r in records)
+        if max_date is not None:
+            assert all(r.date <= max_date for r in records)
+        if datetime is not None:
+            assert all(r.datetime == datetime for r in records)
+        if min_datetime is not None:
+            assert all(r.datetime >= min_datetime for r in records)
+        if max_datetime is not None:
+            assert all(r.datetime <= max_datetime for r in records)
         if func_name is not None:
             match func_name:
                 case bool() as has_func_name:
@@ -425,7 +428,7 @@ class TestOrjsonFormatter:
         assert record.message == "message"
         assert record.level == WARNING
         assert record.path_name == Path(__file__)
-        assert abs(record.datetime - get_now_local()) <= SECOND
+        assert abs(record.datetime - get_now()) <= SECOND
         assert record.func_name == TestOrjsonFormatter.test_main.__name__
         assert record.stack_info is None
         assert record.extra == {"a": 1, "b": 2}

{dycw_utilities-0.131.11 → dycw_utilities-0.131.12}/src/tests/test_pyinstrument.py

@@ -16,4 +16,4 @@ class TestProfile:
             sleep(1e-3)
 
         (file,) = tmp_path.iterdir()
-        assert search(r"^profile__\d{8}T\d{6}\.html$", file.name)
+        assert search(r"^profile__[\dT]+\.html$", file.name)

{dycw_utilities-0.131.11 → dycw_utilities-0.131.12}/src/tests/test_traceback.py

@@ -99,7 +99,7 @@ class TestMakeExceptHook:
             exc_type, exc_val, traceback = exc_info()
             hook(exc_type, exc_val, traceback)
         path = one(tmp_path.iterdir())
-        assert search(r"^\d{8}T\d{6}\.txt$", path.name)
+        assert search(r"^[\dT]+\.txt$", path.name)
 
     def test_non_error(self) -> None:
         hook = make_except_hook()

dycw_utilities-0.131.12/src/tests/test_tzlocal.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from zoneinfo import ZoneInfo
+
+from utilities.tzlocal import LOCAL_TIME_ZONE, LOCAL_TIME_ZONE_NAME, get_local_time_zone
+
+
+class TestGetLocalTimeZone:
+    def test_function(self) -> None:
+        time_zone = get_local_time_zone()
+        assert isinstance(time_zone, ZoneInfo)
+
+    def test_constants(self) -> None:
+        assert isinstance(LOCAL_TIME_ZONE, ZoneInfo)
+        assert isinstance(LOCAL_TIME_ZONE_NAME, str)

{dycw_utilities-0.131.11 → dycw_utilities-0.131.12}/src/tests/test_whenever2.py

@@ -8,14 +8,21 @@ from zoneinfo import ZoneInfo
 from hypothesis import given
 from hypothesis.strategies import just, none, timezones
 from pytest import mark, param, raises
-from whenever import Date, DateDelta, DateTimeDelta, TimeDelta, ZonedDateTime
+from whenever import (
+    Date,
+    DateDelta,
+    DateTimeDelta,
+    PlainDateTime,
+    TimeDelta,
+    ZonedDateTime,
+)
 
 from tests.conftest import IS_CI
 from utilities.dataclasses import replace_non_sentinel
 from utilities.hypothesis import dates_whenever, sentinels, zoned_datetimes_whenever
 from utilities.sentinel import Sentinel, sentinel
 from utilities.tzdata import HongKong, Tokyo
-from utilities.tzlocal import LOCAL_TIME_ZONE
+from utilities.tzlocal import LOCAL_TIME_ZONE_NAME
 from utilities.whenever2 import (
     DATE_DELTA_MAX,
     DATE_DELTA_MIN,
@@ -39,6 +46,7 @@ from utilities.whenever2 import (
     ZONED_DATE_TIME_MAX,
     ZONED_DATE_TIME_MIN,
     WheneverLogRecord,
+    format_compact,
     from_timestamp,
     from_timestamp_millis,
     from_timestamp_nanos,
@@ -56,6 +64,17 @@ if TYPE_CHECKING:
     from utilities.types import MaybeCallableDate, MaybeCallableZonedDateTime
 
 
+class TestFormatCompact:
+    @given(datetime=zoned_datetimes_whenever())
+    def test_main(self, *, datetime: ZonedDateTime) -> None:
+        result = format_compact(datetime)
+        assert isinstance(result, str)
+        parsed = PlainDateTime.parse_common_iso(result)
+        assert parsed.nanosecond == 0
+        expected = datetime.round().to_tz(LOCAL_TIME_ZONE_NAME).to_plain()
+        assert parsed == expected
+
+
 class TestFromTimeStamp:
     @given(datetime=zoned_datetimes_whenever(time_zone=UTC if IS_CI else timezones()))
     def test_main(self, *, datetime: ZonedDateTime) -> None:
@@ -100,7 +119,7 @@ class TestGetNowLocal:
 
     def test_constant(self) -> None:
         assert isinstance(NOW_LOCAL, ZonedDateTime)
-        assert NOW_LOCAL.tz == LOCAL_TIME_ZONE.key
+        assert NOW_LOCAL.tz == LOCAL_TIME_ZONE_NAME
 
 
 class TestGetToday:

{dycw_utilities-0.131.11 → dycw_utilities-0.131.12}/src/utilities/__init__.py

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

{dycw_utilities-0.131.11 → dycw_utilities-0.131.12}/src/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

{dycw_utilities-0.131.11 → dycw_utilities-0.131.12}/src/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
 

{dycw_utilities-0.131.11 → dycw_utilities-0.131.12}/src/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,