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

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

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

{dycw_utilities-0.131.11 → dycw_utilities-0.131.13}/pyproject.toml

@@ -94,7 +94,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.131.11"
+version = "0.131.13"
 
 [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.13"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.131.11 → dycw_utilities-0.131.13}/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.13}/src/tests/test_atools.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
-from asyncio import sleep
-
+from utilities.asyncio import sleep_dur
 from utilities.atools import call_memoized
+from utilities.whenever2 import SECOND
 
 
 class TestCallMemoized:
@@ -20,6 +20,7 @@ class TestCallMemoized:
 
     async def test_refresh(self) -> None:
         counter = 0
+        delta = 0.05 * SECOND
 
         async def increment() -> int:
             nonlocal counter
@@ -27,9 +28,9 @@ class TestCallMemoized:
             return counter
 
         for _ in range(2):
-            assert (await call_memoized(increment, 0.05)) == 1
+            assert (await call_memoized(increment, delta)) == 1
             assert counter == 1
-        await sleep(0.1)
+        await sleep_dur(duration=2 * delta)
         for _ in range(2):
-            assert (await call_memoized(increment, 0.05)) == 2
+            assert (await call_memoized(increment, delta)) == 2
             assert counter == 2

{dycw_utilities-0.131.11 → dycw_utilities-0.131.13}/src/tests/test_cachetools.py

@@ -1,20 +1,32 @@
 from __future__ import annotations
 
-from time import sleep
+from typing import TYPE_CHECKING
 
 from hypothesis import example, given
-from hypothesis.strategies import floats, integers, none
+from hypothesis.strategies import integers, none
 
+from utilities.asyncio import sleep_dur
 from utilities.cachetools import TTLSet, cache
+from utilities.hypothesis import time_deltas_whenever
+from utilities.whenever2 import SECOND
+
+if TYPE_CHECKING:
+    from whenever import TimeDelta
 
 
 class TestCache:
     @example(max_size=None, max_duration=None)
-    @example(max_size=None, max_duration=1.0)
+    @example(max_size=None, max_duration=SECOND)
     @example(max_size=1, max_duration=None)
-    @example(max_size=1, max_duration=1.0)
-    @given(max_size=integers(1, 10) | none(), max_duration=floats(0.1, 10.0) | none())
-    def test_main(self, *, max_size: int, max_duration: float) -> None:
+    @example(max_size=1, max_duration=SECOND)
+    @given(
+        max_size=integers(1, 10) | none(),
+        max_duration=time_deltas_whenever(
+            min_value=0.1 * SECOND, max_value=10.0 * SECOND
+        )
+        | none(),
+    )
+    def test_main(self, *, max_size: int, max_duration: TimeDelta) -> None:
         counter = 0
 
         @cache(max_size=max_size, max_duration=max_duration)
@@ -48,10 +60,11 @@ class TestTTLSet:
         set_ = TTLSet(range(3))
         assert len(set_) == 3
 
-    def test_max_duration(self) -> None:
-        set_ = TTLSet(range(3), max_duration=0.1)
+    async def test_max_duration(self) -> None:
+        delta = 0.1 * SECOND
+        set_ = TTLSet(range(3), max_duration=delta)
         assert set_ == {0, 1, 2}
-        sleep(0.2)
+        await sleep_dur(duration=2 * delta)
         assert set_ == set()
 
     def test_max_size(self) -> None:

{dycw_utilities-0.131.11 → dycw_utilities-0.131.13}/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.13}/src/tests/test_hypothesis.py

@@ -68,8 +68,6 @@ from utilities.hypothesis import (
     int_arrays,
     lists_fixed_length,
     min_and_max_datetimes,
-    min_and_maybe_max_datetimes,
-    min_and_maybe_max_sizes,
     months,
     namespace_mixins,
     numbers,
@@ -729,59 +727,6 @@ class TestMinAndMaxDateTimes:
             assert max_datetime == max_value
 
 
-class TestMinAndMaybeMaxDateTimes:
-    @given(
-        data=data(),
-        min_value=zoned_datetimes() | none() | just(zoned_datetimes() | none()),
-        max_value=zoned_datetimes()
-        | none()
-        | sentinels()
-        | just(zoned_datetimes() | none() | sentinels()),
-    )
-    def test_main(
-        self,
-        *,
-        data: DataObject,
-        min_value: MaybeSearchStrategy[dt.datetime | None],
-        max_value: MaybeSearchStrategy[dt.datetime | None | Sentinel],
-    ) -> None:
-        min_datetime, max_datetime = data.draw(
-            min_and_maybe_max_datetimes(min_value=min_value, max_value=max_value)
-        )
-        assert (max_datetime is None) or (min_datetime <= max_datetime)
-        if isinstance(min_value, dt.datetime):
-            assert min_datetime == min_value
-        if isinstance(max_value, dt.datetime) or (max_value is None):
-            assert max_datetime == max_value
-
-
-class TestMinAndMaybeMaxSizes:
-    @given(
-        data=data(),
-        min_value=integers(min_value=0) | none() | just(integers(min_value=0) | none()),
-        max_value=integers(min_value=0)
-        | none()
-        | sentinels()
-        | just(integers(min_value=0) | none() | sentinels()),
-    )
-    def test_main(
-        self,
-        *,
-        data: DataObject,
-        min_value: MaybeSearchStrategy[int | None],
-        max_value: MaybeSearchStrategy[int | None | Sentinel],
-    ) -> None:
-        min_size, max_size = data.draw(
-            min_and_maybe_max_sizes(min_value=min_value, max_value=max_value)
-        )
-        assert min_size >= 0
-        assert (max_size is None) or (min_size <= max_size)
-        if isinstance(min_value, int):
-            assert min_size == min_value
-        if isinstance(max_value, int) or (max_value is None):
-            assert max_size == max_value
-
-
 class TestMonths:
     @given(data=data())
     def test_main(self, *, data: DataObject) -> None:

{dycw_utilities-0.131.11 → dycw_utilities-0.131.13}/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.13}/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,16 @@ 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.tzlocal import LOCAL_TIME_ZONE
+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
 
 
@@ -169,7 +170,7 @@ class TestGetLogRecords:
                 "level": UInt64,
                 "path_name": String,
                 "line_num": UInt64,
-                "datetime": zoned_datetime(time_zone="local"),
+                "datetime": zoned_datetime(time_zone=LOCAL_TIME_ZONE),
                 "func_name": String,
                 "stack_info": String,
                 "extra": Object,
@@ -195,9 +196,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 +222,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 +252,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 +282,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 +429,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}