dycw-utilities 0.129.15__tar.gz → 0.130.1__tar.gz

{dycw_utilities-0.129.15 → dycw_utilities-0.130.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.129.15
+Version: 0.130.1
 Author-email: Derek Wan <d.wan@icloud.com>
 License-File: LICENSE
 Requires-Python: >=3.12
@@ -109,8 +109,6 @@ Requires-Dist: rich<14.1,>=14.0.0; extra == 'zzz-test-logging'
 Requires-Dist: tomlkit<0.14,>=0.13.2; extra == 'zzz-test-logging'
 Requires-Dist: tzlocal<5.4,>=5.3.1; extra == 'zzz-test-logging'
 Requires-Dist: whenever<0.9,>=0.8.5; extra == 'zzz-test-logging'
-Provides-Extra: zzz-test-loguru
-Requires-Dist: loguru<0.8,>=0.7.3; extra == 'zzz-test-loguru'
 Provides-Extra: zzz-test-luigi
 Requires-Dist: luigi<3.7,>=3.6.0; extra == 'zzz-test-luigi'
 Requires-Dist: whenever<0.9,>=0.8.5; extra == 'zzz-test-luigi'

{dycw_utilities-0.129.15 → dycw_utilities-0.130.1}/pyproject.toml

@@ -29,7 +29,6 @@ dev = [
   "img2pdf >= 0.6.0, < 0.7",
   "inflect >= 7.5.0, < 7.6",
   "lightweight-charts >= 2.1, < 2.2",
-  "loguru >= 0.7.3, < 0.8",
   "luigi >= 3.6.0, < 3.7",
   "memory-profiler >= 0.61.0, < 0.62",
   "more-itertools >= 10.7.0, < 10.8",
@@ -83,7 +82,6 @@ dev = [
   "pytest-timeout >= 2.4.0, < 2.5",
   "pytest-xdist >= 3.7.0, < 3.8",
   # CI
-  "win32_setctime >= 1.2.0, < 1.3",  # https://github.com/Delgan/loguru/issues/147
   "aiolimiter>=1.2.1",
 ]
 
@@ -96,7 +94,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.129.15"
+version = "0.130.1"
 
 [project.optional-dependencies]
 logging = [
@@ -213,7 +211,6 @@ zzz-test-logging = [
   "tzlocal >= 5.3.1, < 5.4",
   "whenever >= 0.8.5, < 0.9",
 ]
-zzz-test-loguru = ["loguru >= 0.7.3, < 0.8"]
 zzz-test-luigi = [
   "luigi >= 3.6.0, < 3.7",
   "whenever >= 0.8.5, < 0.9",
@@ -344,7 +341,7 @@ zzz-test-zoneinfo = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.129.15"
+current_version = "0.130.1"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"
@@ -464,6 +461,7 @@ filterwarnings = [
   "ignore:unclosed <socket.*socket .*>:ResourceWarning",  # redis
   "ignore:unclosed Connection <redis.*asyncio.*connection.*Connection.*>:ResourceWarning",  # redis
   "ignore:unclosed event loop <_UnixSelectorEventLoop .*>:ResourceWarning",  # redis
+  "ignore:unclosed file <_io.*TextIOWrapper .*>:ResourceWarning",  # logging
   "ignore:unclosed transport <_SelectorSocketTransport .*>:ResourceWarning",  # redis
 ]
 minversion = "8.0"
@@ -478,6 +476,7 @@ unsafe-fixes = true
 
 [tool.ruff.format]
 preview = true
+skip-magic-trailing-comma = true
 
 [tool.ruff.lint]
 explicit-preview-rules = true
@@ -545,3 +544,4 @@ ban-relative-imports = "all"
 
 [tool.ruff.lint.isort]
 required-imports = ["from __future__ import annotations"]
+split-on-trailing-comma = false

dycw_utilities-0.130.1/src/tests/conftest.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from os import environ
+
+from pytest import mark
+
+from utilities.platform import IS_NOT_LINUX, IS_WINDOWS
+
+FLAKY = mark.flaky(reruns=5, reruns_delay=1)
+IS_CI = "CI" in environ
+SKIPIF_CI = mark.skipif(IS_CI, reason="Skipped for CI")
+IS_CI_AND_WINDOWS = IS_CI and IS_WINDOWS
+SKIPIF_CI_AND_WINDOWS = mark.skipif(IS_CI_AND_WINDOWS, reason="Skipped for CI/Windows")
+SKIPIF_CI_AND_NOT_LINUX = mark.skipif(
+    IS_CI and IS_NOT_LINUX, reason="Skipped for CI/non-Linux"
+)
+
+
+# hypothesis
+
+
+try:
+    from utilities.hypothesis import setup_hypothesis_profiles
+except ModuleNotFoundError:
+    pass
+else:
+    setup_hypothesis_profiles()

{dycw_utilities-0.129.15 → dycw_utilities-0.130.1}/src/tests/test_logging.py

@@ -1,19 +1,25 @@
 from __future__ import annotations
 
+from asyncio import sleep
+from contextlib import contextmanager
 from io import StringIO
-from logging import DEBUG, NOTSET, FileHandler, Logger, StreamHandler, getLogger
+from logging import (
+    Formatter,
+    Logger,
+    LogRecord,
+    StreamHandler,
+    getLogger,
+    setLogRecordFactory,
+)
 from pathlib import Path
 from re import search
-from time import sleep
-from typing import TYPE_CHECKING, Any, Literal, cast
+from typing import TYPE_CHECKING, Any, cast
 
 from hypothesis import given
 from hypothesis.strategies import booleans, integers, none, sampled_from
 from pytest import LogCaptureFixture, mark, param, raises
-from whenever import ZonedDateTime
 
-from tests.test_traceback_funcs.one import func_one
-from tests.test_traceback_funcs.untraced import func_untraced
+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,
@@ -27,30 +33,33 @@ from utilities.logging import (
     FilterForKeyError,
     GetLoggingLevelNumberError,
     SizeAndTimeRotatingFileHandler,
-    StandaloneFileHandler,
-    _AdvancedLogRecord,
     _compute_rollover_actions,
+    _FieldStyleKeys,
     _RotatingLogFile,
     add_filters,
     basic_config,
     filter_for_key,
-    get_default_logging_path,
+    get_formatter,
     get_logger,
     get_logging_level_number,
     setup_logging,
-    temp_handler,
-    temp_logger,
 )
-from utilities.pytest import skipif_windows
 from utilities.text import unique_str
 from utilities.types import LogLevel
 from utilities.typing import get_args
 
 if TYPE_CHECKING:
     import datetime as dt
-    from re import Pattern
+    from collections.abc import Iterator, Mapping
+    from logging import _FilterType
+
 
-    from utilities.types import LoggerOrName
+@contextmanager
+def _temp_log_factory() -> Iterator[None]:
+    try:
+        yield
+    finally:
+        setLogRecordFactory(LogRecord)
 
 
 class TestAddFilters:
@@ -72,22 +81,38 @@ class TestAddFilters:
 
 
 class TestBasicConfig:
-    @mark.parametrize("log", [param(True), param(False)])
     @mark.parametrize("whenever", [param(True), param(False)])
+    @mark.parametrize(
+        "filters",
+        [
+            param(lambda _: True),  # pyright: ignore[reportUnknownLambdaType]
+            param(None),
+        ],
+    )
     @mark.parametrize("plain", [param(True), param(False)])
     def test_main(
-        self, *, caplog: LogCaptureFixture, log: bool, whenever: bool, plain: bool
+        self,
+        *,
+        caplog: LogCaptureFixture,
+        whenever: bool,
+        filters: _FilterType | None,
+        plain: bool,
     ) -> None:
-        logger = unique_str() if log else None
-        basic_config(obj=logger, whenever=whenever, plain=plain)
-        logger_use = getLogger()
-        logger_use.warning("message")
-        assert "message" in caplog.messages
+        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"
+
+    @mark.parametrize("whenever", [param(True), param(False)])
+    def test_none(self, *, whenever: bool) -> None:
+        with _temp_log_factory():
+            basic_config(whenever=whenever)
 
 
 class TestComputeRolloverActions:
-    @skipif_windows
-    def test_main(self, *, tmp_path: Path) -> None:
+    async def test_main(self, *, tmp_path: Path) -> None:
         tmp_path.joinpath("log.txt").touch()
 
         actions = _compute_rollover_actions(tmp_path, "log", ".txt")
@@ -99,7 +124,7 @@ class TestComputeRolloverActions:
         assert any(p for p in files if search(r"^log\.1\__[\dT]+\.txt$", p.name))
 
         for _ in range(2):
-            sleep(1)
+            await sleep(1)
             tmp_path.joinpath("log.txt").touch()
             actions = _compute_rollover_actions(tmp_path, "log", ".txt")
             assert len(actions.deletions) == 1
@@ -111,8 +136,7 @@ class TestComputeRolloverActions:
                 p for p in files if search(r"^log\.1\__[\dT]+__[\dT]+\.txt$", p.name)
             )
 
-    @skipif_windows
-    def test_multiple_backups(self, *, tmp_path: Path) -> None:
+    async def test_multiple_backups(self, *, tmp_path: Path) -> None:
         tmp_path.joinpath("log.txt").touch()
 
         actions = _compute_rollover_actions(tmp_path, "log", ".txt", backup_count=3)
@@ -123,7 +147,7 @@ class TestComputeRolloverActions:
         assert len(files) == 1
         assert any(p for p in files if search(r"^log\.1\__[\dT]+\.txt$", p.name))
 
-        sleep(1)
+        await sleep(1)
         tmp_path.joinpath("log.txt").touch()
         actions = _compute_rollover_actions(tmp_path, "log", ".txt", backup_count=3)
         assert len(actions.deletions) == 0
@@ -136,7 +160,7 @@ class TestComputeRolloverActions:
         )
         assert any(p for p in files if search(r"^log\.2\__[\dT]+\.txt$", p.name))
 
-        sleep(1)
+        await sleep(1)
         tmp_path.joinpath("log.txt").touch()
         actions = _compute_rollover_actions(tmp_path, "log", ".txt", backup_count=3)
         assert len(actions.deletions) == 0
@@ -153,7 +177,7 @@ class TestComputeRolloverActions:
         assert all(p for p in files if search(r"^log\.3\__[\dT]+\.txt$", p.name))
 
         for _ in range(2):
-            sleep(1)
+            await sleep(1)
             tmp_path.joinpath("log.txt").touch()
             actions = _compute_rollover_actions(tmp_path, "log", ".txt", backup_count=3)
             assert len(actions.deletions) == 1
@@ -171,8 +195,7 @@ class TestComputeRolloverActions:
                 p for p in files if search(r"^log\.3\__[\dT]+__[\dT]+\.txt$", p.name)
             )
 
-    @skipif_windows
-    def test_deleting_old_files(self, *, tmp_path: Path) -> None:
+    async def test_deleting_old_files(self, *, tmp_path: Path) -> None:
         tmp_path.joinpath("log.txt").touch()
 
         actions = _compute_rollover_actions(tmp_path, "log", ".txt")
@@ -183,7 +206,7 @@ class TestComputeRolloverActions:
         assert len(files) == 1
         assert any(p for p in files if search(r"^log\.1\__[\dT]+\.txt$", p.name))
 
-        sleep(1)
+        await sleep(1)
         tmp_path.joinpath("log.txt").touch()
         now = serialize_compact(NOW_UTC)
         tmp_path.joinpath(f"log.99__{now}__{now}.txt").touch()
@@ -225,9 +248,22 @@ class TestFilterForKey:
             _ = filter_for_key(key)
 
 
-class TestGetDefaultLoggingPath:
-    def test_main(self) -> None:
-        assert isinstance(get_default_logging_path(), Path)
+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,
+    ) -> None:
+        with _temp_log_factory():
+            formatter = get_formatter(
+                whenever=whenever, plain=plain, color_field_styles=color_field_styles
+            )
+            assert isinstance(formatter, Formatter)
 
 
 class TestGetLogger:
@@ -380,105 +416,25 @@ class TestRotatingLogFile:
 
 
 class TestSetupLogging:
-    @skipif_windows
-    def test_decorated(
-        self, *, tmp_path: Path, traceback_func_one: Pattern[str]
-    ) -> None:
-        name = unique_str()
-        setup_logging(logger=name, files_dir=tmp_path)
-        logger = getLogger(name)
-        assert len(logger.handlers) == 7
-        self.assert_files(tmp_path, "init")
-        try:
-            _ = func_one(1, 2, 3, 4, c=5, d=6, e=7)
-        except AssertionError:
-            logger.exception("message")
-        self.assert_files(tmp_path, ("post", traceback_func_one))
-
-    @skipif_windows
-    def test_undecorated(
-        self, *, tmp_path: Path, traceback_func_untraced: Pattern[str]
-    ) -> None:
+    def test_main(self, *, tmp_path: Path) -> None:
         name = unique_str()
         setup_logging(logger=name, files_dir=tmp_path)
         logger = getLogger(name)
         assert len(logger.handlers) == 7
-        self.assert_files(tmp_path, "init")
-        try:
-            _ = func_untraced(1, 2, 3, 4, c=5, d=6, e=7)
-        except AssertionError:
-            logger.exception("message")
-        self.assert_files(tmp_path, ("post", traceback_func_untraced))
-
-    @skipif_windows
-    def test_regular_percent_formatting(
-        self, *, tmp_path: Path, caplog: LogCaptureFixture
-    ) -> None:
-        name = unique_str()
-        setup_logging(logger=name, files_dir=tmp_path)
-        logger = getLogger(name)
-        logger.info("int: %d, float: %.2f", 1, 12.3456)
-        record = one(caplog.records)
-        assert isinstance(record, _AdvancedLogRecord)
-        expected = "int: 1, float: 12.35"
-        assert record.message == expected
-
-    @skipif_windows
-    def test_no_console(self, *, tmp_path: Path) -> None:
-        name = unique_str()
-        setup_logging(logger=name, console_level=None, files_dir=tmp_path)
-        logger = getLogger(name)
-        assert len(logger.handlers) == 5
-
-    @skipif_windows
-    def test_zoned_datetime(self, *, tmp_path: Path, caplog: LogCaptureFixture) -> None:
-        name = unique_str()
-        setup_logging(logger=name, files_dir=tmp_path)
-        logger = getLogger(name)
-        logger.info("")
-        record = one(caplog.records)
-        assert isinstance(record, _AdvancedLogRecord)
-        assert isinstance(record._zoned_datetime, ZonedDateTime)
-        assert isinstance(record._zoned_datetime_str, str)
-
-    @skipif_windows
-    def test_extra(self, *, tmp_path: Path) -> None:
-        name = unique_str()
-
-        def extra(logger: LoggerOrName | None, /) -> None:
-            get_logger(logger=logger).addHandler(
-                FileHandler(tmp_path.joinpath("extra.log"))
-            )
-
-        setup_logging(logger=name, files_dir=tmp_path, extra=extra)
-        logger = getLogger(name)
-        logger.info("")
-        files = list(tmp_path.iterdir())
-        names = {f.name for f in files}
-        assert len(names) == 4
-
-    @classmethod
-    def assert_files(
-        cls, path: Path, check: Literal["init"] | tuple[Literal["post"], Pattern[str]]
-    ) -> None:
-        files = list(path.iterdir())
-        names = {f.name for f in files}
-        match check:
-            case "init":
-                assert names == {"debug.txt", "info.txt", "plain"}
-            case "post", pattern:
-                assert names == {"debug.txt", "info.txt", "errors", "plain"}
-                errors = path.joinpath("errors")
-                assert errors.is_dir()
-                files = list(errors.iterdir())
-                assert len(files) == 1
-                with one(files).open() as fh:
-                    contents = fh.read()
-                assert pattern.search(contents)
+        logger.warning("message")
+        files = {p.name for p in tmp_path.iterdir() if p.is_file()}
+        expected = {
+            "debug.txt",
+            "info.txt",
+            "error.txt",
+            f"{name}-debug.txt",
+            f"{name}-info.txt",
+            f"{name}-error.txt",
+        }
+        assert files == expected
 
 
 class TestSizeAndTimeRotatingFileHandler:
-    @skipif_windows
     def test_handlers(self, *, tmp_path: Path) -> None:
         logger = getLogger(unique_str())
         filename = tmp_path.joinpath("log")
@@ -488,15 +444,14 @@ class TestSizeAndTimeRotatingFileHandler:
             content = fh.read()
         assert content == "message\n"
 
-    @skipif_windows
     def test_create_parents(self, *, tmp_path: Path) -> None:
         logger = getLogger(unique_str())
         filename = tmp_path.joinpath("foo", "bar", "bar", "log")
         logger.addHandler(SizeAndTimeRotatingFileHandler(filename=filename))
         assert filename.exists()
 
-    @skipif_windows
-    def test_size(self, *, tmp_path: Path) -> None:
+    @SKIPIF_CI_AND_WINDOWS
+    async def test_size(self, *, tmp_path: Path) -> None:
         logger = getLogger(unique_str())
         logger.addHandler(
             SizeAndTimeRotatingFileHandler(
@@ -552,10 +507,10 @@ class TestSizeAndTimeRotatingFileHandler:
                         for p in files
                         if search(r"^log\.3__[\dT]+__[\dT]+\.txt$", p.name)
                     )
+                await sleep(0.1)
 
-    @mark.flaky
-    @skipif_windows
-    def test_time(self, *, tmp_path: Path) -> None:
+    @SKIPIF_CI_AND_WINDOWS
+    async def test_time(self, *, tmp_path: Path) -> None:
         logger = getLogger(unique_str())
         logger.addHandler(
             SizeAndTimeRotatingFileHandler(
@@ -575,7 +530,7 @@ class TestSizeAndTimeRotatingFileHandler:
         assert len(files) == 1
         assert any(p for p in files if search(r"^log\.txt$", p.name))
 
-        sleep(1.01)
+        await sleep(1.1)
         for i in range(2, 4):
             logger.warning("message %d", i)
             files = list(tmp_path.iterdir())
@@ -583,7 +538,7 @@ class TestSizeAndTimeRotatingFileHandler:
             assert any(p for p in files if search(r"^log\.txt$", p.name))
             assert any(p for p in files if search(r"^log\.1__[\dT]+\.txt$", p.name))
 
-        sleep(1.01)
+        await sleep(1.1)
         for i in range(4, 6):
             logger.warning("message %d", i)
             files = list(tmp_path.iterdir())
@@ -594,7 +549,7 @@ class TestSizeAndTimeRotatingFileHandler:
             )
             assert any(p for p in files if search(r"^log\.2__[\dT]+\.txt$", p.name))
 
-        sleep(1.01)
+        await sleep(1.1)
         for i in range(6, 8):
             logger.warning("message %d", i)
             files = list(tmp_path.iterdir())
@@ -609,7 +564,7 @@ class TestSizeAndTimeRotatingFileHandler:
             assert any(p for p in files if search(r"^log\.3__[\dT]+\.txt$", p.name))
 
         for _ in range(2):
-            sleep(1.01)
+            await sleep(1.1)
             for i in range(8, 10):
                 logger.warning("message %d", i)
                 files = list(tmp_path.iterdir())
@@ -625,67 +580,17 @@ class TestSizeAndTimeRotatingFileHandler:
                     p for p in files if search(r"^log\.3__[\dT]+__[\dT]+\.txt$", p.name)
                 )
 
-    @skipif_windows
+    @mark.parametrize("max_bytes", [param(0), param(1)])
+    @SKIPIF_CI_AND_WINDOWS
     def test_should_rollover_file_not_found(
-        self, *, tmp_path: Path, caplog: LogCaptureFixture
+        self, *, tmp_path: Path, max_bytes: int, caplog: LogCaptureFixture
     ) -> None:
-        logger = getLogger(unique_str())
+        logger = getLogger(name := unique_str())
         path = tmp_path.joinpath("log")
         logger.addHandler(
-            handler := SizeAndTimeRotatingFileHandler(filename=path, maxBytes=1)
+            handler := SizeAndTimeRotatingFileHandler(filename=path, maxBytes=max_bytes)
         )
         logger.warning("message")
-        record = one(caplog.records)
+        record = one(r for r in caplog.records if r.name == name)
         path.unlink()
         assert not handler._should_rollover(record)
-
-
-class TestStandaloneFileHandler:
-    @skipif_windows
-    def test_main(self, *, tmp_path: Path) -> None:
-        logger = getLogger(unique_str())
-        logger.addHandler(StandaloneFileHandler(level=DEBUG, path=tmp_path))
-        assert len(list(tmp_path.iterdir())) == 0
-        logger.warning("message")
-        files = list(tmp_path.iterdir())
-        assert len(files) == 1
-        with one(files).open() as fh:
-            contents = fh.read()
-        assert contents == "message"
-
-
-class TestTempHandler:
-    def test_main(self) -> None:
-        logger = getLogger(unique_str())
-        logger.addHandler(h1 := StreamHandler())
-        logger.addHandler(h2 := StreamHandler())
-        assert len(logger.handlers) == 2
-        handler = StreamHandler()
-        with temp_handler(handler, logger=logger):
-            assert len(logger.handlers) == 3
-        assert len(logger.handlers) == 2
-        assert logger.handlers[0] is h1
-        assert logger.handlers[1] is h2
-
-
-class TestTempLogger:
-    def test_disabled(self) -> None:
-        logger = getLogger(unique_str())
-        assert not logger.disabled
-        with temp_logger(logger, disabled=True):
-            assert logger.disabled
-        assert not logger.disabled
-
-    def test_level(self) -> None:
-        logger = getLogger(unique_str())
-        assert logger.level == NOTSET
-        with temp_logger(logger, level="DEBUG"):
-            assert logger.level == DEBUG
-        assert logger.level == NOTSET
-
-    def test_propagate(self) -> None:
-        logger = getLogger(unique_str())
-        assert logger.propagate
-        with temp_logger(logger, propagate=False):
-            assert not logger.propagate
-        assert logger.propagate