dycw-utilities 0.129.4__tar.gz → 0.129.6__tar.gz

{dycw_utilities-0.129.4 → dycw_utilities-0.129.6}/PKG-INFO

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

{dycw_utilities-0.129.4 → dycw_utilities-0.129.6}/pyproject.toml

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

{dycw_utilities-0.129.4 → dycw_utilities-0.129.6}/src/tests/test_logging.py

@@ -42,6 +42,7 @@ from utilities.logging import (
     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
 
@@ -53,9 +54,9 @@ if TYPE_CHECKING:
 
 
 class TestAddFilters:
-    @given(root=temp_paths(), expected=booleans())
-    def test_main(self, *, root: Path, expected: bool) -> None:
-        logger = getLogger(str(root))
+    @given(expected=booleans())
+    def test_main(self, *, expected: bool) -> None:
+        logger = getLogger(unique_str())
         logger.addHandler(handler := StreamHandler(buffer := StringIO()))
         add_filters(handler, lambda _: expected)
         assert len(handler.filters) == 1
@@ -71,10 +72,13 @@ class TestAddFilters:
 
 
 class TestBasicConfig:
-    def test_main(self, *, tmp_path: Path) -> None:
-        basic_config()
-        logger = getLogger(str(tmp_path))
-        logger.info("message")
+    @mark.parametrize("log", [param(True), param(False)])
+    def test_main(self, *, caplog: LogCaptureFixture, log: bool) -> None:
+        logger = unique_str() if log else None
+        basic_config(logger=logger)
+        logger_use = getLogger()
+        logger_use.warning("message")
+        assert "message" in caplog.messages
 
 
 class TestComputeRolloverActions:
@@ -191,16 +195,9 @@ class TestComputeRolloverActions:
 
 
 class TestFilterForKey:
-    @given(
-        root=temp_paths(),
-        key=text_ascii(),
-        value=booleans() | none(),
-        default=booleans(),
-    )
-    def test_main(
-        self, *, root: Path, key: str, value: bool | None, default: bool
-    ) -> None:
-        logger = getLogger(str(root))
+    @given(key=text_ascii(), value=booleans() | none(), default=booleans())
+    def test_main(self, *, key: str, value: bool | None, default: bool) -> None:
+        logger = getLogger(unique_str())
         logger.addHandler(handler := StreamHandler(buffer := StringIO()))
         with assume_does_not_raise(FilterForKeyError):
             filter_ = filter_for_key(key, default=default)
@@ -230,15 +227,16 @@ class TestGetDefaultLoggingPath:
 
 
 class TestGetLogger:
-    def test_logger(self, *, tmp_path: Path) -> None:
-        logger = getLogger(str(tmp_path))
+    def test_logger(self) -> None:
+        logger = getLogger(unique_str())
         result = get_logger(logger=logger)
         assert result is logger
 
-    def test_str(self, *, tmp_path: Path) -> None:
-        result = get_logger(logger=str(tmp_path))
-        assert isinstance(result, Logger)
-        assert result.name == str(tmp_path)
+    def test_str(self) -> None:
+        name = unique_str()
+        logger = getLogger(name)
+        assert isinstance(logger, Logger)
+        assert logger.name == name
 
     def test_none(self) -> None:
         result = get_logger()
@@ -382,7 +380,7 @@ class TestSetupLogging:
     def test_decorated(
         self, *, tmp_path: Path, traceback_func_one: Pattern[str]
     ) -> None:
-        name = str(tmp_path)
+        name = unique_str()
         setup_logging(logger=name, files_dir=tmp_path)
         logger = getLogger(name)
         assert len(logger.handlers) == 7
@@ -397,7 +395,7 @@ class TestSetupLogging:
     def test_undecorated(
         self, *, tmp_path: Path, traceback_func_untraced: Pattern[str]
     ) -> None:
-        name = str(tmp_path)
+        name = unique_str()
         setup_logging(logger=name, files_dir=tmp_path)
         logger = getLogger(name)
         assert len(logger.handlers) == 7
@@ -412,7 +410,7 @@ class TestSetupLogging:
     def test_regular_percent_formatting(
         self, *, tmp_path: Path, caplog: LogCaptureFixture
     ) -> None:
-        name = str(tmp_path)
+        name = unique_str()
         setup_logging(logger=name, files_dir=tmp_path)
         logger = getLogger(name)
         logger.info("int: %d, float: %.2f", 1, 12.3456)
@@ -423,14 +421,14 @@ class TestSetupLogging:
 
     @skipif_windows
     def test_no_console(self, *, tmp_path: Path) -> None:
-        name = str(tmp_path)
+        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 = str(tmp_path)
+        name = unique_str()
         setup_logging(logger=name, files_dir=tmp_path)
         logger = getLogger(name)
         logger.info("")
@@ -441,7 +439,7 @@ class TestSetupLogging:
 
     @skipif_windows
     def test_extra(self, *, tmp_path: Path) -> None:
-        name = str(tmp_path)
+        name = unique_str()
 
         def extra(logger: LoggerOrName | None, /) -> None:
             get_logger(logger=logger).addHandler(
@@ -478,7 +476,7 @@ class TestSetupLogging:
 class TestSizeAndTimeRotatingFileHandler:
     @skipif_windows
     def test_handlers(self, *, tmp_path: Path) -> None:
-        logger = getLogger(str(tmp_path))
+        logger = getLogger(unique_str())
         filename = tmp_path.joinpath("log")
         logger.addHandler(SizeAndTimeRotatingFileHandler(filename=filename))
         logger.warning("message")
@@ -488,77 +486,66 @@ class TestSizeAndTimeRotatingFileHandler:
 
     @skipif_windows
     def test_size(self, *, tmp_path: Path) -> None:
-        logger = getLogger(str(tmp_path))
+        logger = getLogger(unique_str())
         logger.addHandler(
             SizeAndTimeRotatingFileHandler(
                 filename=tmp_path.joinpath("log.txt"), maxBytes=100, backupCount=3
             )
         )
-
-        for i in range(1, 3):
-            logger.warning("message %d", i)
-            files = list(tmp_path.iterdir())
-            assert len(files) == 1
-            assert any(p for p in files if search(r"^log\.txt$", p.name))
-
-        logger.warning(10 * "message 3")
-        files = list(tmp_path.iterdir())
-        assert len(files) == 2
-        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))
-
-        for i in range(4, 6):
-            logger.warning("message %d", i)
-            files = list(tmp_path.iterdir())
-            assert len(files) == 3
-            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]+__[\dT]+\.txt$", p.name)
-            )
-            assert any(p for p in files if search(r"^log\.2__[\dT]+\.txt$", p.name))
-
-        logger.warning(10 * "message 6")
-        files = list(tmp_path.iterdir())
-        assert len(files) == 4
-        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]+__[\dT]+\.txt$", p.name))
-        assert any(p for p in files if search(r"^log\.2__[\dT]+__[\dT]+\.txt$", p.name))
-        assert any(p for p in files if search(r"^log\.3__[\dT]+\.txt$", p.name))
-
-        for _ in range(2):
-            for i in range(7, 9):
-                logger.warning("message %d", i)
+        for cycle in range(1, 10):
+            for i in range(1, 4):
+                logger.warning("%s message %d", 100 * "long" if i % 3 == 0 else "", i)
                 files = list(tmp_path.iterdir())
-                assert len(files) == 4
+                assert len(files) == min(cycle, 4)
                 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]+__[\dT]+\.txt$", p.name)
-                )
-                assert any(
-                    p for p in files if search(r"^log\.2__[\dT]+__[\dT]+\.txt$", p.name)
-                )
-                assert any(
-                    p for p in files if search(r"^log\.3__[\dT]+__[\dT]+\.txt$", p.name)
-                )
-
-            logger.warning("message 9")
-            files = list(tmp_path.iterdir())
-            assert len(files) == 4
-            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]+__[\dT]+\.txt$", p.name)
-            )
-            assert any(
-                p for p in files if search(r"^log\.2__[\dT]+__[\dT]+\.txt$", p.name)
-            )
-            assert any(
-                p for p in files if search(r"^log\.3__[\dT]+__[\dT]+\.txt$", p.name)
-            )
+                if cycle == 2:
+                    assert any(
+                        p for p in files if search(r"^log\.1__[\dT]+\.txt$", p.name)
+                    )
+                elif cycle == 3:
+                    assert any(
+                        p
+                        for p in files
+                        if search(r"^log\.1__[\dT]+__[\dT]+\.txt$", p.name)
+                    )
+                    assert any(
+                        p for p in files if search(r"^log\.2__[\dT]+\.txt$", p.name)
+                    )
+                elif cycle == 4:
+                    assert any(
+                        p
+                        for p in files
+                        if search(r"^log\.1__[\dT]+__[\dT]+\.txt$", p.name)
+                    )
+                    assert any(
+                        p
+                        for p in files
+                        if search(r"^log\.2__[\dT]+__[\dT]+\.txt$", p.name)
+                    )
+                    assert any(
+                        p for p in files if search(r"^log\.3__[\dT]+\.txt$", p.name)
+                    )
+                elif cycle >= 5:
+                    assert any(
+                        p
+                        for p in files
+                        if search(r"^log\.1__[\dT]+__[\dT]+\.txt$", p.name)
+                    )
+                    assert any(
+                        p
+                        for p in files
+                        if search(r"^log\.2__[\dT]+__[\dT]+\.txt$", p.name)
+                    )
+                    assert any(
+                        p
+                        for p in files
+                        if search(r"^log\.3__[\dT]+__[\dT]+\.txt$", p.name)
+                    )
 
     @mark.flaky
     @skipif_windows
     def test_time(self, *, tmp_path: Path) -> None:
-        logger = getLogger(str(tmp_path))
+        logger = getLogger(unique_str())
         logger.addHandler(
             SizeAndTimeRotatingFileHandler(
                 filename=tmp_path.joinpath("log.txt"),
@@ -631,7 +618,7 @@ class TestSizeAndTimeRotatingFileHandler:
     def test_should_rollover_file_not_found(
         self, *, tmp_path: Path, caplog: LogCaptureFixture
     ) -> None:
-        logger = getLogger(str(tmp_path))
+        logger = getLogger(unique_str())
         path = tmp_path.joinpath("log")
         logger.addHandler(
             handler := SizeAndTimeRotatingFileHandler(filename=path, maxBytes=1)
@@ -645,7 +632,7 @@ class TestSizeAndTimeRotatingFileHandler:
 class TestStandaloneFileHandler:
     @skipif_windows
     def test_main(self, *, tmp_path: Path) -> None:
-        logger = getLogger(str(tmp_path))
+        logger = getLogger(unique_str())
         logger.addHandler(StandaloneFileHandler(level=DEBUG, path=tmp_path))
         assert len(list(tmp_path.iterdir())) == 0
         logger.warning("message")
@@ -657,8 +644,8 @@ class TestStandaloneFileHandler:
 
 
 class TestTempHandler:
-    def test_main(self, *, tmp_path: Path) -> None:
-        logger = getLogger(str(tmp_path))
+    def test_main(self) -> None:
+        logger = getLogger(unique_str())
         logger.addHandler(h1 := StreamHandler())
         logger.addHandler(h2 := StreamHandler())
         assert len(logger.handlers) == 2
@@ -671,22 +658,22 @@ class TestTempHandler:
 
 
 class TestTempLogger:
-    def test_disabled(self, *, tmp_path: Path) -> None:
-        logger = getLogger(str(tmp_path))
+    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, *, tmp_path: Path) -> None:
-        logger = getLogger(str(tmp_path))
+    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, *, tmp_path: Path) -> None:
-        logger = getLogger(str(tmp_path))
+    def test_propagate(self) -> None:
+        logger = getLogger(unique_str())
         assert logger.propagate
         with temp_logger(logger, propagate=False):
             assert not logger.propagate

{dycw_utilities-0.129.4 → dycw_utilities-0.129.6}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.129.4"
+__version__ = "0.129.6"

{dycw_utilities-0.129.4 → dycw_utilities-0.129.6}/src/utilities/logging.py

@@ -160,13 +160,11 @@ class SizeAndTimeRotatingFileHandler(BaseRotatingHandler):
     def _should_rollover(self, record: LogRecord, /) -> bool:
         if self._max_bytes is not None:  # skipif-ci-and-windows
             try:
-                current = self._filename.stat().st_size
+                size = self._filename.stat().st_size
             except FileNotFoundError:
                 pass
             else:
-                delta = len(f"{self.format(record)}\n")
-                new = current + delta
-                if new >= self._max_bytes:
+                if size >= self._max_bytes:
                     return True
         return bool(self._time_handler.shouldRollover(record))  # skipif-ci-and-windows
 
@@ -417,16 +415,26 @@ def add_filters(handler: Handler, /, *filters: _FilterType) -> None:
 
 def basic_config(
     *,
-    format: str = "{asctime} | {name} | {levelname:8} | {message}",  # noqa: A002
+    logger: LoggerOrName | None = None,
+    format_: str = "{asctime} | {name} | {levelname:8} | {message}",
     level: LogLevel = "INFO",
 ) -> None:
     """Do the basic config."""
-    basicConfig(
-        format=format,
-        datefmt=maybe_sub_pct_y("%Y-%m-%d %H:%M:%S"),
-        style="{",
-        level=level,
-    )
+    datefmt = maybe_sub_pct_y("%Y-%m-%d %H:%M:%S")
+    if logger is None:
+        basicConfig(format=format_, datefmt=datefmt, style="{", level=level)
+    else:
+        logger_use = get_logger(logger=logger)
+        logger_use.setLevel(level)
+        logger_use.addHandler(handler := StreamHandler())
+        handler.setLevel(level)
+        try:
+            from coloredlogs import ColoredFormatter
+        except ModuleNotFoundError:  # pragma: no cover
+            formatter = Formatter(fmt=format_, datefmt=datefmt, style="{")
+        else:
+            formatter = ColoredFormatter(fmt=format_, datefmt=datefmt, style="{")
+        handler.setFormatter(formatter)
 
 
 ##