From d7fa6ea302afbfadf48e228cb9078eb19cec399f Mon Sep 17 00:00:00 2001 From: Derek Wan Date: Sun, 15 Sep 2024 20:56:46 +0900 Subject: [PATCH 01/11] more --- src/utilities/loguru.py | 120 ++++++++++++++-------------------------- 1 file changed, 41 insertions(+), 79 deletions(-) diff --git a/src/utilities/loguru.py b/src/utilities/loguru.py index 43b7f9519..9273f443b 100644 --- a/src/utilities/loguru.py +++ b/src/utilities/loguru.py @@ -5,28 +5,20 @@ import sys import time from asyncio import AbstractEventLoop -from collections.abc import Callable, Hashable, Sequence +from collections.abc import Callable, Hashable, Iterator, Sequence +from contextlib import contextmanager from dataclasses import dataclass from enum import StrEnum, unique -from functools import partial, wraps +from functools import wraps from inspect import iscoroutinefunction from logging import Handler, LogRecord from sys import __excepthook__, _getframe, stderr -from typing import ( - TYPE_CHECKING, - Any, - ParamSpec, - TextIO, - TypedDict, - TypeVar, - cast, - overload, -) +from typing import TYPE_CHECKING, Any, ParamSpec, TextIO, TypedDict, TypeVar, cast from loguru import logger from typing_extensions import override -from utilities.datetime import duration_to_timedelta +from utilities.datetime import SECOND, duration_to_timedelta from utilities.functions import get_func_name from utilities.iterables import ( OneEmptyError, @@ -34,6 +26,8 @@ one, resolve_include_and_exclude, ) +from utilities.sentinel import Sentinel, sentinel +from utilities.timer import Timer if TYPE_CHECKING: import datetime as dt @@ -199,85 +193,53 @@ def __str__(self) -> str: return f"Invalid logging level: {self.level!r}" -_MATHEMATICAL_ITALIC_SMALL_F = "𝑓" # noqa: RUF001 - - -@overload -def log( - func: Callable[_P, _T], - /, - *, - depth: int = 1, - entry: LogLevel | None = ..., - entry_bind: StrMapping | None = ..., - entry_message: str = ..., - error_expected: type[Exception] | tuple[type[Exception], ...] | None = ..., - error_bind: StrMapping | None = ..., - error_message: str = ..., - exit_: LogLevel | None = ..., - exit_predicate: Callable[[_T], bool] | None = ..., - exit_bind: StrMapping | None = ..., - exit_message: str = ..., -) -> Callable[_P, _T]: ... -@overload +@contextmanager def log( - func: None = None, - /, *, - depth: int = 1, - entry: LogLevel | None = ..., - entry_bind: StrMapping | None = ..., - entry_message: str = ..., - error_bind: StrMapping | None = ..., - error_expected: type[Exception] | tuple[type[Exception], ...] | None = ..., - error_message: str = ..., - exit_: LogLevel | None = ..., - exit_predicate: Callable[[Any], bool] | None = ..., - exit_bind: StrMapping | None = ..., - exit_message: str = ..., -) -> Callable[[Callable[_P, _T]], Callable[_P, _T]]: ... -def log( - func: Callable[_P, _T] | None = None, - /, - *, - depth: int = 1, - entry: LogLevel | None = LogLevel.TRACE, + entry_level: LogLevel | None = LogLevel.TRACE, entry_bind: StrMapping | None = None, entry_message: str = "⋯", error_expected: type[Exception] | tuple[type[Exception], ...] | None = None, error_bind: StrMapping | None = None, error_message: str = _RECORD_EXCEPTION_VALUE, - exit_: LogLevel | None = None, + exit_level: LogLevel | None | Sentinel = sentinel, + exit_duration: Duration = SECOND, exit_bind: StrMapping | None = None, exit_predicate: Callable[[_T], bool] | None = None, exit_message: str = "✔", -) -> Callable[_P, _T] | Callable[[Callable[_P, _T]], Callable[_P, _T]]: +) -> Iterator[None]: """Log the function call.""" - if func is None: - return partial( - log, - depth=depth, - entry=entry, - entry_bind=entry_bind, - entry_message=entry_message, - error_expected=error_expected, - error_bind=error_bind, - error_message=error_message, - exit_=exit_, - exit_bind=exit_bind, - exit_predicate=exit_predicate, - exit_message=exit_message, - ) + timer = Timer() + if entry_level is not None: + logger_entry = logger if entry_bind is None else logger.bind(**entry_bind) + logger_entry.opt(depth=2).log(entry_level, entry_message) + try: + yield + except Exception as error: + if (error_expected is None) or not isinstance(error, error_expected): + logger_error = logger if error_bind is None else logger.bind(**error_bind) + logger_error.opt(exception=True, record=True, depth=depth).error( + error_message + ) + raise + finally: + if (not isinstance(exit_level, Sentinel)) or (timer >= exit_duration): + exit_level_use = LogLevel.TRACE if exit_level is None else exit_level + if (exit_level_use is not None) + if timer >= SECOND: + logger.opt(depth=depth3).info("CM finish", timer=timer) func_name = get_func_name(func) if iscoroutinefunction(func): @wraps(func) async def wrapped_async(*args: _P.args, **kwargs: _P.kwargs) -> _T: - if entry is not None: + if entry_level is not None: logger_use = logger if entry_bind is None else logger.bind(**entry_bind) logger_use.opt(depth=depth).log( - entry, entry_message, **{_MATHEMATICAL_ITALIC_SMALL_F: func_name} + entry_level, + entry_message, + **{_MATHEMATICAL_ITALIC_SMALL_F: func_name}, ) try: result = await func(*args, **kwargs) @@ -291,20 +253,20 @@ async def wrapped_async(*args: _P.args, **kwargs: _P.kwargs) -> _T: ) raise if ((exit_predicate is None) or (exit_predicate(result))) and ( - exit_ is not None + exit_level is not None ): logger_use = logger if exit_bind is None else logger.bind(**exit_bind) - logger_use.opt(depth=depth).log(exit_, exit_message) + logger_use.opt(depth=depth).log(exit_level, exit_message) return result return cast(Callable[_P, _T], wrapped_async) @wraps(func) def wrapped_sync(*args: Any, **kwargs: Any) -> Any: - if entry is not None: + if entry_level is not None: logger_use = logger if entry_bind is None else logger.bind(**entry_bind) logger_use.opt(depth=depth).log( - entry, entry_message, **{_MATHEMATICAL_ITALIC_SMALL_F: func_name} + entry_level, entry_message, **{_MATHEMATICAL_ITALIC_SMALL_F: func_name} ) try: result = func(*args, **kwargs) @@ -316,10 +278,10 @@ def wrapped_sync(*args: Any, **kwargs: Any) -> Any: ) raise if ((exit_predicate is None) or (exit_predicate(result))) and ( - exit_ is not None + exit_level is not None ): logger_use = logger if exit_bind is None else logger.bind(**exit_bind) - logger_use.opt(depth=depth).log(exit_, exit_message) + logger_use.opt(depth=depth).log(exit_level, exit_message) return result return cast(Callable[_P, _T], wrapped_sync) From 53a7f7cca9547a3821fbc2d63866e257df3d999d Mon Sep 17 00:00:00 2001 From: Derek Wan Date: Sun, 15 Sep 2024 21:37:45 +0900 Subject: [PATCH 02/11] wip --- src/utilities/loguru.py | 107 ++++++++++------------------------------ 1 file changed, 26 insertions(+), 81 deletions(-) diff --git a/src/utilities/loguru.py b/src/utilities/loguru.py index 9273f443b..242a34ef8 100644 --- a/src/utilities/loguru.py +++ b/src/utilities/loguru.py @@ -9,24 +9,20 @@ from contextlib import contextmanager from dataclasses import dataclass from enum import StrEnum, unique -from functools import wraps -from inspect import iscoroutinefunction from logging import Handler, LogRecord from sys import __excepthook__, _getframe, stderr -from typing import TYPE_CHECKING, Any, ParamSpec, TextIO, TypedDict, TypeVar, cast +from typing import TYPE_CHECKING, Any, TextIO, TypedDict, cast from loguru import logger from typing_extensions import override from utilities.datetime import SECOND, duration_to_timedelta -from utilities.functions import get_func_name from utilities.iterables import ( OneEmptyError, OneNonUniqueError, one, resolve_include_and_exclude, ) -from utilities.sentinel import Sentinel, sentinel from utilities.timer import Timer if TYPE_CHECKING: @@ -52,10 +48,6 @@ from utilities.types import Duration, PathLike, StrMapping -_P = ParamSpec("_P") -_T = TypeVar("_T") - - _RECORD_EXCEPTION_VALUE = "{record[exception].value!r}" LEVEL_CONFIGS: Sequence[LevelConfig] = [ {"name": "TRACE", "color": ""}, @@ -196,95 +188,48 @@ def __str__(self) -> str: @contextmanager def log( *, + depth: int = 2, entry_level: LogLevel | None = LogLevel.TRACE, entry_bind: StrMapping | None = None, - entry_message: str = "⋯", + entry_message: str = "➢", error_expected: type[Exception] | tuple[type[Exception], ...] | None = None, error_bind: StrMapping | None = None, error_message: str = _RECORD_EXCEPTION_VALUE, - exit_level: LogLevel | None | Sentinel = sentinel, + exit_level: LogLevel | None = None, exit_duration: Duration = SECOND, exit_bind: StrMapping | None = None, - exit_predicate: Callable[[_T], bool] | None = None, exit_message: str = "✔", + **kwargs: Any, ) -> Iterator[None]: """Log the function call.""" - timer = Timer() - if entry_level is not None: - logger_entry = logger if entry_bind is None else logger.bind(**entry_bind) - logger_entry.opt(depth=2).log(entry_level, entry_message) - try: - yield - except Exception as error: - if (error_expected is None) or not isinstance(error, error_expected): - logger_error = logger if error_bind is None else logger.bind(**error_bind) - logger_error.opt(exception=True, record=True, depth=depth).error( - error_message - ) - raise - finally: - if (not isinstance(exit_level, Sentinel)) or (timer >= exit_duration): - exit_level_use = LogLevel.TRACE if exit_level is None else exit_level - if (exit_level_use is not None) - if timer >= SECOND: - logger.opt(depth=depth3).info("CM finish", timer=timer) - - func_name = get_func_name(func) - if iscoroutinefunction(func): - - @wraps(func) - async def wrapped_async(*args: _P.args, **kwargs: _P.kwargs) -> _T: - if entry_level is not None: - logger_use = logger if entry_bind is None else logger.bind(**entry_bind) - logger_use.opt(depth=depth).log( - entry_level, - entry_message, - **{_MATHEMATICAL_ITALIC_SMALL_F: func_name}, - ) - try: - result = await func(*args, **kwargs) - except Exception as error: - if (error_expected is None) or not isinstance(error, error_expected): - logger_use = ( - logger if error_bind is None else logger.bind(**error_bind) - ) - logger_use.opt(exception=True, record=True, depth=depth).error( - error_message - ) - raise - if ((exit_predicate is None) or (exit_predicate(result))) and ( - exit_level is not None - ): - logger_use = logger if exit_bind is None else logger.bind(**exit_bind) - logger_use.opt(depth=depth).log(exit_level, exit_message) - return result - - return cast(Callable[_P, _T], wrapped_async) - - @wraps(func) - def wrapped_sync(*args: Any, **kwargs: Any) -> Any: + with logger.contextualize(**kwargs), Timer() as timer: if entry_level is not None: - logger_use = logger if entry_bind is None else logger.bind(**entry_bind) - logger_use.opt(depth=depth).log( - entry_level, entry_message, **{_MATHEMATICAL_ITALIC_SMALL_F: func_name} - ) + logger_entry = logger if entry_bind is None else logger.bind(**entry_bind) + logger_entry.opt(depth=depth).log(entry_level, entry_message) try: - result = func(*args, **kwargs) + yield except Exception as error: if (error_expected is None) or not isinstance(error, error_expected): - logger_use = logger if error_bind is None else logger.bind(**error_bind) - logger_use.opt(exception=True, record=True, depth=depth).error( + logger_error = ( + logger if error_bind is None else logger.bind(**error_bind) + ) + logger_error.opt(exception=True, record=True, depth=depth).error( error_message ) raise - if ((exit_predicate is None) or (exit_predicate(result))) and ( - exit_level is not None - ): - logger_use = logger if exit_bind is None else logger.bind(**exit_bind) - logger_use.opt(depth=depth).log(exit_level, exit_message) - return result - - return cast(Callable[_P, _T], wrapped_sync) + finally: + if isinstance(exit_level, LogLevel) or (timer >= exit_duration): + match exit_level: + case LogLevel(): + exit_level_use = exit_level + case None: + exit_level_use = ( + LogLevel.TRACE if entry_level is None else entry_level + ) + logger_exit = logger if exit_bind is None else logger.bind(**exit_bind) + logger_exit.opt(depth=depth).log( + exit_level_use, exit_message, timer=timer + ) def logged_sleep_sync( From 3fe80d069288d22a647362be27990d205afe9ec4 Mon Sep 17 00:00:00 2001 From: Derek Wan Date: Sun, 15 Sep 2024 21:54:58 +0900 Subject: [PATCH 03/11] hi --- src/tests/functions.py | 68 ----------- src/tests/test_loguru.py | 186 ++++++++++------------------- src/tests/test_loguru_functions.py | 46 +++++++ 3 files changed, 107 insertions(+), 193 deletions(-) create mode 100644 src/tests/test_loguru_functions.py diff --git a/src/tests/functions.py b/src/tests/functions.py index 7c1e94dd9..b0ba5338a 100644 --- a/src/tests/functions.py +++ b/src/tests/functions.py @@ -15,66 +15,6 @@ from collections.abc import Callable -# test entry sync - - -@log -def func_test_entry_sync_inc(x: int, /) -> int: - return x + 1 - - -@log -def func_test_entry_sync_dec(x: int, /) -> int: - return x - 1 - - -@log -def func_test_entry_sync_inc_and_dec(x: int, /) -> tuple[int, int]: - return func_test_entry_sync_inc(x), func_test_entry_sync_dec(x) - - -# test entry async - - -@log -async def func_test_entry_async_inc(x: int, /) -> int: - await sleep(0.01) - return x + 1 - - -@log -async def func_test_entry_async_dec(x: int, /) -> int: - await sleep(0.01) - return x - 1 - - -@log -async def func_test_entry_async_inc_and_dec(x: int, /) -> tuple[int, int]: - return (await func_test_entry_async_inc(x), await func_test_entry_async_dec(x)) - - -# test entry disabled - - -@log(entry=None) -def func_test_entry_disabled_sync(x: int, /) -> int: - return x + 1 - - -@log(entry=None) -async def func_test_entry_disabled_async(x: int, /) -> int: - await sleep(0.01) - return x + 1 - - -# test entry custom level - - -@log(entry=LogLevel.INFO) -def func_test_entry_custom_level(x: int, /) -> int: - return x + 1 - - # test error @@ -84,14 +24,6 @@ class Remainder1Error(Exception): ... class Remainder2Error(Exception): ... -@log -def func_test_error_sync(x: int, /) -> int | None: - if x % 2 == 0: - return x + 1 - msg = f"Got an odd number {x}" - raise ValueError(msg) - - @log def func_test_error_chain_outer_sync(x: int, /) -> int | None: try: diff --git a/src/tests/test_loguru.py b/src/tests/test_loguru.py index 6545304c5..9168c6b63 100644 --- a/src/tests/test_loguru.py +++ b/src/tests/test_loguru.py @@ -11,22 +11,12 @@ from loguru._recattrs import RecordFile, RecordLevel, RecordProcess, RecordThread from pytest import CaptureFixture, mark, param, raises -from tests.functions import ( - Remainder2Error, - func_test_decorated, - func_test_entry_async_inc_and_dec, - func_test_entry_custom_level, - func_test_entry_disabled_async, - func_test_entry_disabled_sync, - func_test_entry_sync_inc_and_dec, - func_test_error_async, - func_test_error_chain_outer_async, - func_test_error_chain_outer_sync, - func_test_error_sync, - func_test_exit_async, - func_test_exit_custom_level, - func_test_exit_predicate, - func_test_exit_sync, +from tests.test_loguru_functions import ( + func_test_entry_disabled, + func_test_entry_inc_and_dec, + func_test_entry_non_default_level, + func_test_error, + func_test_error_expected, ) from utilities.hypothesis import text_ascii from utilities.loguru import ( @@ -143,147 +133,93 @@ def test_main(self, *, capsys: CaptureFixture) -> None: class TestLog: datetime: ClassVar[str] = r"\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3} \| " trace: ClassVar[str] = datetime + r"TRACE \| " + debug: ClassVar[str] = datetime + r"DEBUG \| " info: ClassVar[str] = datetime + r"INFO \| " warning: ClassVar[str] = datetime + r"WARNING \| " error: ClassVar[str] = datetime + r"ERROR \| " - def test_entry_sync(self, *, capsys: CaptureFixture) -> None: - default_format = ensure_str(LOGURU_FORMAT) - handler: HandlerConfiguration = { - "sink": sys.stdout, - "level": LogLevel.TRACE, - "format": f"{default_format} | {{extra}}", - } - _ = logger.configure(handlers=[cast(dict[str, Any], handler)]) - - assert func_test_entry_sync_inc_and_dec(1) == (2, 0) - out = capsys.readouterr().out - line1, line2, line3 = out.splitlines() - expected1 = ( - self.trace - + r"tests\.test_loguru:test_entry_sync:\d+ - ⋯ \| {'𝑓': 'func_test_entry_sync_inc_and_dec'}$" # noqa: RUF001 - ) - assert search(expected1, line1), line1 - trace_and_func = ( - self.trace - + r"tests\.functions:func_test_entry_sync_inc_and_dec:\d+ - ⋯ \| " - ) - expected2 = trace_and_func + "{'𝑓': 'func_test_entry_sync_inc'}$" # noqa: RUF001 - assert search(expected2, line2), line2 - expected3 = trace_and_func + "{'𝑓': 'func_test_entry_sync_dec'}$" # noqa: RUF001 - assert search(expected3, line3), line3 - - async def test_entry_async(self, *, capsys: CaptureFixture) -> None: - default_format = ensure_str(LOGURU_FORMAT) - handler: HandlerConfiguration = { - "sink": sys.stdout, - "level": LogLevel.TRACE, - "format": f"{default_format} | {{extra}}", - } + @mark.only + def test_entry(self, *, capsys: CaptureFixture) -> None: + handler: HandlerConfiguration = {"sink": sys.stdout, "level": LogLevel.TRACE} _ = logger.configure(handlers=[cast(dict[str, Any], handler)]) - assert await func_test_entry_async_inc_and_dec(1) == (2, 0) + assert func_test_entry_inc_and_dec(1) == (2, 0) + head = self.trace + r"tests\.test_loguru_functions:" out = capsys.readouterr().out line1, line2, line3 = out.splitlines() - expected1 = ( - self.trace - + r"tests\.test_loguru:test_entry_async:\d+ - ⋯ \| {'𝑓': 'func_test_entry_async_inc_and_dec'}$" # noqa: RUF001 - ) + expected1 = head + r"func_test_entry_inc_and_dec:\d+ - ➢$" assert search(expected1, line1), line1 - trace_and_func = ( - self.trace - + r"tests\.functions:func_test_entry_async_inc_and_dec:\d+ - ⋯ \| " - ) - expected2 = trace_and_func + "{'𝑓': 'func_test_entry_async_inc'}$" # noqa: RUF001 + expected2 = head + r"_func_test_entry_inc:\d+ - ➢$" assert search(expected2, line2), line2 - expected3 = trace_and_func + "{'𝑓': 'func_test_entry_async_dec'}$" # noqa: RUF001 + expected3 = head + r"_func_test_entry_dec:\d+ - ➢$" assert search(expected3, line3), line3 - def test_entry_disabled_sync(self, *, capsys: CaptureFixture) -> None: + @mark.only + def test_entry_disabled(self, *, capsys: CaptureFixture) -> None: handler: HandlerConfiguration = {"sink": sys.stdout, "level": LogLevel.TRACE} _ = logger.configure(handlers=[cast(dict[str, Any], handler)]) - assert func_test_entry_disabled_sync(1) == 2 + assert func_test_entry_disabled(1) == 2 out = capsys.readouterr().out assert out == "" - async def test_entry_disabled_async(self, *, capsys: CaptureFixture) -> None: + @mark.only + def test_entry_non_default_level(self, *, capsys: CaptureFixture) -> None: handler: HandlerConfiguration = {"sink": sys.stdout, "level": LogLevel.TRACE} _ = logger.configure(handlers=[cast(dict[str, Any], handler)]) - assert await func_test_entry_disabled_async(1) == 2 - out = capsys.readouterr().out - assert out == "" - - def test_entry_custom_level(self, *, capsys: CaptureFixture) -> None: - default_format = ensure_str(LOGURU_FORMAT) - handler: HandlerConfiguration = { - "sink": sys.stdout, - "level": LogLevel.TRACE, - "format": f"{default_format} | {{extra}}", - } - _ = logger.configure(handlers=[cast(dict[str, Any], handler)]) - - assert func_test_entry_custom_level(1) == 2 + assert func_test_entry_non_default_level(1) == 2 out = capsys.readouterr().out expected = ( - self.info - + r"tests\.test_loguru:test_entry_custom_level:\d+ - ⋯ \| {'𝑓': 'func_test_entry_custom_level'}$" # noqa: RUF001 + self.debug + + r"tests\.test_loguru_functions:func_test_entry_non_default_level:\d+ - ➢$" ) assert search(expected, out), out + @mark.only def test_error_no_effect_sync(self, *, capsys: CaptureFixture) -> None: handler: HandlerConfiguration = {"sink": sys.stdout, "level": LogLevel.TRACE} _ = logger.configure(handlers=[cast(dict[str, Any], handler)]) - assert func_test_error_sync(0) == 1 - out = capsys.readouterr().out - (line,) = out.splitlines() - expected = self.trace + r"tests\.test_loguru:test_error_no_effect_sync:\d+ - ⋯$" - assert search(expected, line), line - - def test_error_catch_sync(self, *, capsys: CaptureFixture) -> None: - handler: HandlerConfiguration = {"sink": sys.stdout, "level": LogLevel.TRACE} - _ = logger.configure(handlers=[cast(dict[str, Any], handler)]) - - with raises(ValueError, match="Got an odd number 1"): - assert func_test_error_sync(1) + with raises(ValueError, match="Got an odd number: 1"): + _ = func_test_error(1) out = capsys.readouterr().out line1, line2, line3, *_ = out.splitlines() - expected1 = self.trace + r"tests\.test_loguru:test_error_catch_sync:\d+ - ⋯$" + expected1 = ( + self.trace + r"tests\.test_loguru_functions:func_test_error:\d+ - ➢$" + ) assert search(expected1, line1), line1 expected2 = ( self.error - + r"tests\.test_loguru:test_error_catch_sync:\d+ - ValueError\('Got an odd number 1'\)$" + + r"tests\.test_loguru_functions:func_test_error:\d+ - ValueError\('Got an odd number: 1'\)$" ) assert search(expected2, line2), line2 assert line3 == "Traceback (most recent call last):" exp_last = strip_and_dedent( """ raise ValueError(msg) - └ 'Got an odd number 1' + └ 'Got an odd number: 1' - ValueError: Got an odd number 1 + ValueError: Got an odd number: 1 """ ) lines_last = "\n".join(out.splitlines()[-4:]) assert lines_last == exp_last - def test_error_chain_no_effect_sync(self, *, capsys: CaptureFixture) -> None: + @mark.only + def test_error_expected(self, *, capsys: CaptureFixture) -> None: handler: HandlerConfiguration = {"sink": sys.stdout, "level": LogLevel.TRACE} _ = logger.configure(handlers=[cast(dict[str, Any], handler)]) - assert func_test_error_chain_outer_sync(0) == 1 + with raises(ValueError, match="Got an odd number: 1"): + _ = func_test_error_expected(1) out = capsys.readouterr().out - line1, line2 = out.splitlines() - expected1 = ( - self.trace + r"tests\.test_loguru:test_error_chain_no_effect_sync:\d+ - ⋯$" - ) - assert search(expected1, line1), line1 - expected2 = ( - self.trace + r"tests\.functions:func_test_error_chain_outer_sync:\d+ - ⋯$" + (line,) = out.splitlines() + expected = ( + self.trace + + r"tests\.test_loguru_functions:func_test_error_expected:\d+ - ➢$" ) - assert search(expected2, line2), line2 + assert search(expected, line), line def test_error_chain_caught_sync(self, *, capsys: CaptureFixture) -> None: handler: HandlerConfiguration = {"sink": sys.stdout, "level": LogLevel.TRACE} @@ -293,11 +229,11 @@ def test_error_chain_caught_sync(self, *, capsys: CaptureFixture) -> None: out = capsys.readouterr().out line1, line2 = out.splitlines() expected1 = ( - self.trace + r"tests\.test_loguru:test_error_chain_caught_sync:\d+ - ⋯$" + self.trace + r"tests\.test_loguru:test_error_chain_caught_sync:\d+ - ➢$" ) assert search(expected1, line1), line1 expected2 = ( - self.trace + r"tests\.functions:func_test_error_chain_outer_sync:\d+ - ⋯$" + self.trace + r"tests\.functions:func_test_error_chain_outer_sync:\d+ - ➢$" ) assert search(expected2, line2), line2 @@ -310,11 +246,11 @@ def test_error_chain_uncaught_sync(self, *, capsys: CaptureFixture) -> None: out = capsys.readouterr().out line1, line2, line3, line4, *_ = out.splitlines() expected1 = ( - self.trace + r"tests\.test_loguru:test_error_chain_uncaught_sync:\d+ - ⋯$" + self.trace + r"tests\.test_loguru:test_error_chain_uncaught_sync:\d+ - ➢$" ) assert search(expected1, line1), line1 expected2 = ( - self.trace + r"tests\.functions:func_test_error_chain_outer_sync:\d+ - ⋯$" + self.trace + r"tests\.functions:func_test_error_chain_outer_sync:\d+ - ➢$" ) assert search(expected2, line2), line2 expected3 = ( @@ -343,7 +279,7 @@ async def test_error_no_effect_async(self, *, capsys: CaptureFixture) -> None: out = capsys.readouterr().out (line,) = out.splitlines() expected = ( - self.trace + r"tests\.test_loguru:test_error_no_effect_async:\d+ - ⋯$" + self.trace + r"tests\.test_loguru:test_error_no_effect_async:\d+ - ➢$" ) assert search(expected, line), line @@ -355,7 +291,7 @@ async def test_error_catch_async(self, *, capsys: CaptureFixture) -> None: assert await func_test_error_async(1) out = capsys.readouterr().out line1, line2, line3, *_ = out.splitlines() - expected1 = self.trace + r"tests\.test_loguru:test_error_catch_async:\d+ - ⋯$" + expected1 = self.trace + r"tests\.test_loguru:test_error_catch_async:\d+ - ➢$" assert search(expected1, line1), line1 expected2 = ( self.error @@ -382,11 +318,11 @@ async def test_error_chain_no_effect_async(self, *, capsys: CaptureFixture) -> N out = capsys.readouterr().out line1, line2 = out.splitlines() expected1 = ( - self.trace + r"tests\.test_loguru:test_error_chain_no_effect_async:\d+ - ⋯$" + self.trace + r"tests\.test_loguru:test_error_chain_no_effect_async:\d+ - ➢$" ) assert search(expected1, line1), line1 expected2 = ( - self.trace + r"tests\.functions:func_test_error_chain_outer_async:\d+ - ⋯$" + self.trace + r"tests\.functions:func_test_error_chain_outer_async:\d+ - ➢$" ) assert search(expected2, line2), line2 @@ -398,11 +334,11 @@ async def test_error_chain_caught_async(self, *, capsys: CaptureFixture) -> None out = capsys.readouterr().out line1, line2 = out.splitlines() expected1 = ( - self.trace + r"tests\.test_loguru:test_error_chain_caught_async:\d+ - ⋯$" + self.trace + r"tests\.test_loguru:test_error_chain_caught_async:\d+ - ➢$" ) assert search(expected1, line1), line1 expected2 = ( - self.trace + r"tests\.functions:func_test_error_chain_outer_async:\d+ - ⋯$" + self.trace + r"tests\.functions:func_test_error_chain_outer_async:\d+ - ➢$" ) assert search(expected2, line2), line2 @@ -415,11 +351,11 @@ async def test_error_chain_uncaught_async(self, *, capsys: CaptureFixture) -> No out = capsys.readouterr().out line1, line2, line3, line4, *_ = out.splitlines() expected1 = ( - self.trace + r"tests\.test_loguru:test_error_chain_uncaught_async:\d+ - ⋯$" + self.trace + r"tests\.test_loguru:test_error_chain_uncaught_async:\d+ - ➢$" ) assert search(expected1, line1), line1 expected2 = ( - self.trace + r"tests\.functions:func_test_error_chain_outer_async:\d+ - ⋯$" + self.trace + r"tests\.functions:func_test_error_chain_outer_async:\d+ - ➢$" ) assert search(expected2, line2), line2 expected3 = ( @@ -447,7 +383,7 @@ def test_exit_sync(self, *, capsys: CaptureFixture) -> None: assert func_test_exit_sync(1) == 2 out = capsys.readouterr().out line1, line2, line3 = out.splitlines() - expected1 = self.trace + r"tests\.test_loguru:test_exit_sync:\d+ - ⋯$" + expected1 = self.trace + r"tests\.test_loguru:test_exit_sync:\d+ - ➢$" assert search(expected1, line1), line1 expected2 = self.info + r"tests\.functions:func_test_exit_sync:\d+ - Starting$" assert search(expected2, line2), line2 @@ -461,7 +397,7 @@ async def test_exit_async(self, *, capsys: CaptureFixture) -> None: assert await func_test_exit_async(1) == 2 out = capsys.readouterr().out line1, line2, line3 = out.splitlines() - expected1 = self.trace + r"tests\.test_loguru:test_exit_async:\d+ - ⋯$" + expected1 = self.trace + r"tests\.test_loguru:test_exit_async:\d+ - ➢$" assert search(expected1, line1), line1 expected2 = self.info + r"tests\.functions:func_test_exit_async:\d+ - Starting$" assert search(expected2, line2), line2 @@ -475,7 +411,7 @@ def test_exit_custom_level(self, *, capsys: CaptureFixture) -> None: assert func_test_exit_custom_level(1) == 2 out = capsys.readouterr().out (line1, line2, line3) = out.splitlines() - expected1 = self.trace + r"tests\.test_loguru:test_exit_custom_level:\d+ - ⋯$" + expected1 = self.trace + r"tests\.test_loguru:test_exit_custom_level:\d+ - ➢$" assert search(expected1, line1), line1 expected2 = ( self.info + r"tests\.functions:func_test_exit_custom_level:\d+ - Starting$" @@ -492,7 +428,7 @@ def test_exit_predicate_no_filter(self, *, capsys: CaptureFixture) -> None: out = capsys.readouterr().out (line1, line2, line3) = out.splitlines() expected1 = ( - self.trace + r"tests\.test_loguru:test_exit_predicate_no_filter:\d+ - ⋯$" + self.trace + r"tests\.test_loguru:test_exit_predicate_no_filter:\d+ - ➢$" ) assert search(expected1, line1), line1 expected2 = ( @@ -512,7 +448,7 @@ def test_exit_predicate_filter(self, *, capsys: CaptureFixture) -> None: out = capsys.readouterr().out (line1, line2) = out.splitlines() expected1 = ( - self.trace + r"tests\.test_loguru:test_exit_predicate_filter:\d+ - ⋯$" + self.trace + r"tests\.test_loguru:test_exit_predicate_filter:\d+ - ➢$" ) assert search(expected1, line1), line1 expected2 = ( @@ -527,15 +463,15 @@ def test_decorated(self, *, capsys: CaptureFixture) -> None: assert func_test_decorated(0) == (1, 2) out = capsys.readouterr().out (line1, line2, line3, line4, line5) = out.splitlines() - expected1 = self.trace + r"tests\.test_loguru:test_decorated:\d+ - ⋯$" + expected1 = self.trace + r"tests\.test_loguru:test_decorated:\d+ - ➢$" assert search(expected1, line1), line1 - expected2 = self.trace + r"tests\.test_loguru:test_decorated:\d+ - ⋯$" + expected2 = self.trace + r"tests\.test_loguru:test_decorated:\d+ - ➢$" assert search(expected2, line2), line2 expected3 = ( self.info + r"tests\.functions:func_test_decorated:\d+ - Starting x=0$" ) assert search(expected3, line3), line3 - expected4 = self.trace + r"tests\.test_loguru:test_decorated:\d+ - ⋯$" + expected4 = self.trace + r"tests\.test_loguru:test_decorated:\d+ - ➢$" assert search(expected4, line4), line4 expected5 = ( self.info + r"tests\.functions:func_test_decorated:\d+ - Starting x=1$" diff --git a/src/tests/test_loguru_functions.py b/src/tests/test_loguru_functions.py new file mode 100644 index 000000000..d022e0e40 --- /dev/null +++ b/src/tests/test_loguru_functions.py @@ -0,0 +1,46 @@ +from __future__ import annotations + +from utilities.loguru import LogLevel, log + + +def func_test_entry_inc_and_dec(x: int, /) -> tuple[int, int]: + with log(): + inc = _func_test_entry_inc(x) + dec = _func_test_entry_dec(x) + return inc, dec + + +def _func_test_entry_inc(x: int, /) -> int: + with log(): + return x + 1 + + +def _func_test_entry_dec(x: int, /) -> int: + with log(): + return x - 1 + + +def func_test_entry_disabled(x: int, /) -> int: + with log(entry_level=None): + return x + 1 + + +def func_test_entry_non_default_level(x: int, /) -> int: + with log(entry_level=LogLevel.DEBUG): + return x + 1 + + +def func_test_error(x: int, /) -> int | None: + with log(): + if x % 2 == 0: + return x + 1 + msg = f"Got an odd number: {x}" + raise ValueError(msg) + + +def func_test_error_expected(x: int, /) -> int | None: + with log(error_expected=ValueError): + if x % 2 == 0: + return x + 1 + msg = f"Got an odd number: {x}" + raise ValueError(msg) From d8a576cd589ed4ee8d3a9bce356ffab5090ea499 Mon Sep 17 00:00:00 2001 From: Derek Wan Date: Sun, 15 Sep 2024 22:06:43 +0900 Subject: [PATCH 04/11] save --- src/tests/functions.py | 65 ------- src/tests/test_loguru.py | 293 +++-------------------------- src/tests/test_loguru_functions.py | 13 ++ src/utilities/loguru.py | 4 +- 4 files changed, 40 insertions(+), 335 deletions(-) diff --git a/src/tests/functions.py b/src/tests/functions.py index b0ba5338a..0bfb1c413 100644 --- a/src/tests/functions.py +++ b/src/tests/functions.py @@ -15,71 +15,6 @@ from collections.abc import Callable -# test error - - -class Remainder1Error(Exception): ... - - -class Remainder2Error(Exception): ... - - -@log -def func_test_error_chain_outer_sync(x: int, /) -> int | None: - try: - return func_test_error_chain_inner_sync(x) - except Remainder1Error: - return x + 1 - - -@log(error_expected=Remainder1Error) -def func_test_error_chain_inner_sync(x: int, /) -> int | None: - if x % 3 == 0: - return x + 1 - if x % 3 == 1: - msg = "Got a remainder of 1" - raise Remainder1Error(msg) - msg = "Got a remainder of 2" - raise Remainder2Error(msg) - - -@log -async def func_test_error_async(x: int, /) -> int | None: - await sleep(0.01) - if x % 2 == 0: - return x + 1 - msg = f"Got an odd number {x}" - raise ValueError(msg) - - -@log -async def func_test_error_chain_outer_async(x: int, /) -> int | None: - try: - return await func_test_error_chain_inner_async(x) - except Remainder1Error: - return x + 1 - - -@log(error_expected=Remainder1Error) -async def func_test_error_chain_inner_async(x: int, /) -> int | None: - if x % 3 == 0: - return x + 1 - if x % 3 == 1: - msg = "Got a remainder of 1" - raise Remainder1Error(msg) - msg = "Got a remainder of 2" - raise Remainder2Error(msg) - - -# test exit - - -@log(exit_=LogLevel.INFO) -def func_test_exit_sync(x: int, /) -> int: - logger.info("Starting") - return x + 1 - - @log(exit_=LogLevel.INFO) async def func_test_exit_async(x: int, /) -> int: logger.info("Starting") diff --git a/src/tests/test_loguru.py b/src/tests/test_loguru.py index 9168c6b63..1319b5a14 100644 --- a/src/tests/test_loguru.py +++ b/src/tests/test_loguru.py @@ -17,6 +17,8 @@ func_test_entry_non_default_level, func_test_error, func_test_error_expected, + func_test_exit_duration, + func_test_exit_explicit, ) from utilities.hypothesis import text_ascii from utilities.loguru import ( @@ -132,29 +134,27 @@ def test_main(self, *, capsys: CaptureFixture) -> None: class TestLog: datetime: ClassVar[str] = r"\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3} \| " - trace: ClassVar[str] = datetime + r"TRACE \| " - debug: ClassVar[str] = datetime + r"DEBUG \| " - info: ClassVar[str] = datetime + r"INFO \| " - warning: ClassVar[str] = datetime + r"WARNING \| " - error: ClassVar[str] = datetime + r"ERROR \| " + loguru: ClassVar[str] = r"tests\.test_loguru_functions:" + trace: ClassVar[str] = datetime + r"TRACE \| " + loguru + debug: ClassVar[str] = datetime + r"DEBUG \| " + loguru + info: ClassVar[str] = datetime + r"INFO \| " + loguru + warning: ClassVar[str] = datetime + r"WARNING \| " + loguru + error: ClassVar[str] = datetime + r"ERROR \| " + loguru - @mark.only def test_entry(self, *, capsys: CaptureFixture) -> None: handler: HandlerConfiguration = {"sink": sys.stdout, "level": LogLevel.TRACE} _ = logger.configure(handlers=[cast(dict[str, Any], handler)]) assert func_test_entry_inc_and_dec(1) == (2, 0) - head = self.trace + r"tests\.test_loguru_functions:" out = capsys.readouterr().out line1, line2, line3 = out.splitlines() - expected1 = head + r"func_test_entry_inc_and_dec:\d+ - ➢$" + expected1 = self.trace + r"func_test_entry_inc_and_dec:\d+ - ➢$" assert search(expected1, line1), line1 - expected2 = head + r"_func_test_entry_inc:\d+ - ➢$" + expected2 = self.trace + r"_func_test_entry_inc:\d+ - ➢$" assert search(expected2, line2), line2 - expected3 = head + r"_func_test_entry_dec:\d+ - ➢$" + expected3 = self.trace + r"_func_test_entry_dec:\d+ - ➢$" assert search(expected3, line3), line3 - @mark.only def test_entry_disabled(self, *, capsys: CaptureFixture) -> None: handler: HandlerConfiguration = {"sink": sys.stdout, "level": LogLevel.TRACE} _ = logger.configure(handlers=[cast(dict[str, Any], handler)]) @@ -163,21 +163,16 @@ def test_entry_disabled(self, *, capsys: CaptureFixture) -> None: out = capsys.readouterr().out assert out == "" - @mark.only def test_entry_non_default_level(self, *, capsys: CaptureFixture) -> None: handler: HandlerConfiguration = {"sink": sys.stdout, "level": LogLevel.TRACE} _ = logger.configure(handlers=[cast(dict[str, Any], handler)]) assert func_test_entry_non_default_level(1) == 2 out = capsys.readouterr().out - expected = ( - self.debug - + r"tests\.test_loguru_functions:func_test_entry_non_default_level:\d+ - ➢$" - ) + expected = self.debug + r"func_test_entry_non_default_level:\d+ - ➢$" assert search(expected, out), out - @mark.only - def test_error_no_effect_sync(self, *, capsys: CaptureFixture) -> None: + def test_error(self, *, capsys: CaptureFixture) -> None: handler: HandlerConfiguration = {"sink": sys.stdout, "level": LogLevel.TRACE} _ = logger.configure(handlers=[cast(dict[str, Any], handler)]) @@ -185,13 +180,10 @@ def test_error_no_effect_sync(self, *, capsys: CaptureFixture) -> None: _ = func_test_error(1) out = capsys.readouterr().out line1, line2, line3, *_ = out.splitlines() - expected1 = ( - self.trace + r"tests\.test_loguru_functions:func_test_error:\d+ - ➢$" - ) + expected1 = self.trace + r"func_test_error:\d+ - ➢$" assert search(expected1, line1), line1 expected2 = ( - self.error - + r"tests\.test_loguru_functions:func_test_error:\d+ - ValueError\('Got an odd number: 1'\)$" + self.error + r"func_test_error:\d+ - ValueError\('Got an odd number: 1'\)$" ) assert search(expected2, line2), line2 assert line3 == "Traceback (most recent call last):" @@ -206,7 +198,6 @@ def test_error_no_effect_sync(self, *, capsys: CaptureFixture) -> None: lines_last = "\n".join(out.splitlines()[-4:]) assert lines_last == exp_last - @mark.only def test_error_expected(self, *, capsys: CaptureFixture) -> None: handler: HandlerConfiguration = {"sink": sys.stdout, "level": LogLevel.TRACE} _ = logger.configure(handlers=[cast(dict[str, Any], handler)]) @@ -215,269 +206,33 @@ def test_error_expected(self, *, capsys: CaptureFixture) -> None: _ = func_test_error_expected(1) out = capsys.readouterr().out (line,) = out.splitlines() - expected = ( - self.trace - + r"tests\.test_loguru_functions:func_test_error_expected:\d+ - ➢$" - ) - assert search(expected, line), line - - def test_error_chain_caught_sync(self, *, capsys: CaptureFixture) -> None: - handler: HandlerConfiguration = {"sink": sys.stdout, "level": LogLevel.TRACE} - _ = logger.configure(handlers=[cast(dict[str, Any], handler)]) - - assert func_test_error_chain_outer_sync(1) == 2 - out = capsys.readouterr().out - line1, line2 = out.splitlines() - expected1 = ( - self.trace + r"tests\.test_loguru:test_error_chain_caught_sync:\d+ - ➢$" - ) - assert search(expected1, line1), line1 - expected2 = ( - self.trace + r"tests\.functions:func_test_error_chain_outer_sync:\d+ - ➢$" - ) - assert search(expected2, line2), line2 - - def test_error_chain_uncaught_sync(self, *, capsys: CaptureFixture) -> None: - handler: HandlerConfiguration = {"sink": sys.stdout, "level": LogLevel.TRACE} - _ = logger.configure(handlers=[cast(dict[str, Any], handler)]) - - with raises(Remainder2Error): - assert func_test_error_chain_outer_sync(2) - out = capsys.readouterr().out - line1, line2, line3, line4, *_ = out.splitlines() - expected1 = ( - self.trace + r"tests\.test_loguru:test_error_chain_uncaught_sync:\d+ - ➢$" - ) - assert search(expected1, line1), line1 - expected2 = ( - self.trace + r"tests\.functions:func_test_error_chain_outer_sync:\d+ - ➢$" - ) - assert search(expected2, line2), line2 - expected3 = ( - self.error - + r"tests\.functions:func_test_error_chain_outer_sync:\d+ - Remainder2Error\('Got a remainder of 2'\)$" - ) - assert search(expected3, line3), line3 - assert line4 == "Traceback (most recent call last):" - exp_last = strip_and_dedent( - """ - raise Remainder2Error(msg) - │ └ 'Got a remainder of 2' - └ - - tests.functions.Remainder2Error: Got a remainder of 2 - """ - ) - lines_last = "\n".join(out.splitlines()[-5:]) - assert lines_last == exp_last - - async def test_error_no_effect_async(self, *, capsys: CaptureFixture) -> None: - handler: HandlerConfiguration = {"sink": sys.stdout, "level": LogLevel.TRACE} - _ = logger.configure(handlers=[cast(dict[str, Any], handler)]) - - assert await func_test_error_async(0) == 1 - out = capsys.readouterr().out - (line,) = out.splitlines() - expected = ( - self.trace + r"tests\.test_loguru:test_error_no_effect_async:\d+ - ➢$" - ) + expected = self.trace + r"func_test_error_expected:\d+ - ➢$" assert search(expected, line), line - async def test_error_catch_async(self, *, capsys: CaptureFixture) -> None: - handler: HandlerConfiguration = {"sink": sys.stdout, "level": LogLevel.TRACE} - _ = logger.configure(handlers=[cast(dict[str, Any], handler)]) - - with raises(ValueError, match="Got an odd number 1"): - assert await func_test_error_async(1) - out = capsys.readouterr().out - line1, line2, line3, *_ = out.splitlines() - expected1 = self.trace + r"tests\.test_loguru:test_error_catch_async:\d+ - ➢$" - assert search(expected1, line1), line1 - expected2 = ( - self.error - + r"tests\.test_loguru:test_error_catch_async:\d+ - ValueError\('Got an odd number 1'\)$" - ) - assert search(expected2, line2), line2 - assert line3 == "Traceback (most recent call last):" - exp_last = strip_and_dedent( - """ - raise ValueError(msg) - └ 'Got an odd number 1' - - ValueError: Got an odd number 1 - """ - ) - lines_last = "\n".join(out.splitlines()[-4:]) - assert lines_last == exp_last - - async def test_error_chain_no_effect_async(self, *, capsys: CaptureFixture) -> None: + def test_exit_explicit(self, *, capsys: CaptureFixture) -> None: handler: HandlerConfiguration = {"sink": sys.stdout, "level": LogLevel.TRACE} _ = logger.configure(handlers=[cast(dict[str, Any], handler)]) - assert await func_test_error_chain_outer_async(0) == 1 + assert func_test_exit_explicit(1) == 2 out = capsys.readouterr().out line1, line2 = out.splitlines() - expected1 = ( - self.trace + r"tests\.test_loguru:test_error_chain_no_effect_async:\d+ - ➢$" - ) + expected1 = self.trace + r"func_test_exit_explicit:\d+ - ➢$" assert search(expected1, line1), line1 - expected2 = ( - self.trace + r"tests\.functions:func_test_error_chain_outer_async:\d+ - ➢$" - ) + expected2 = self.debug + r"func_test_exit_explicit:\d+ - ✔$" assert search(expected2, line2), line2 - async def test_error_chain_caught_async(self, *, capsys: CaptureFixture) -> None: + def test_exit_duration(self, *, capsys: CaptureFixture) -> None: handler: HandlerConfiguration = {"sink": sys.stdout, "level": LogLevel.TRACE} _ = logger.configure(handlers=[cast(dict[str, Any], handler)]) - assert await func_test_error_chain_outer_async(1) == 2 + assert func_test_exit_duration(1) == 2 out = capsys.readouterr().out line1, line2 = out.splitlines() - expected1 = ( - self.trace + r"tests\.test_loguru:test_error_chain_caught_async:\d+ - ➢$" - ) + expected1 = self.trace + r"func_test_exit_duration:\d+ - ➢$" assert search(expected1, line1), line1 - expected2 = ( - self.trace + r"tests\.functions:func_test_error_chain_outer_async:\d+ - ➢$" - ) + expected2 = self.trace + r"func_test_exit_duration:\d+ - ✔$" assert search(expected2, line2), line2 - async def test_error_chain_uncaught_async(self, *, capsys: CaptureFixture) -> None: - handler: HandlerConfiguration = {"sink": sys.stdout, "level": LogLevel.TRACE} - _ = logger.configure(handlers=[cast(dict[str, Any], handler)]) - - with raises(Remainder2Error): - assert await func_test_error_chain_outer_async(2) - out = capsys.readouterr().out - line1, line2, line3, line4, *_ = out.splitlines() - expected1 = ( - self.trace + r"tests\.test_loguru:test_error_chain_uncaught_async:\d+ - ➢$" - ) - assert search(expected1, line1), line1 - expected2 = ( - self.trace + r"tests\.functions:func_test_error_chain_outer_async:\d+ - ➢$" - ) - assert search(expected2, line2), line2 - expected3 = ( - self.error - + r"tests\.functions:func_test_error_chain_outer_async:\d+ - Remainder2Error\('Got a remainder of 2'\)$" - ) - assert search(expected3, line3), line3 - assert line4 == "Traceback (most recent call last):" - exp_last = strip_and_dedent( - """ - raise Remainder2Error(msg) - │ └ 'Got a remainder of 2' - └ - - tests.functions.Remainder2Error: Got a remainder of 2 - """ - ) - lines_last = "\n".join(out.splitlines()[-5:]) - assert lines_last == exp_last - - def test_exit_sync(self, *, capsys: CaptureFixture) -> None: - handler: HandlerConfiguration = {"sink": sys.stdout, "level": LogLevel.TRACE} - _ = logger.configure(handlers=[cast(dict[str, Any], handler)]) - - assert func_test_exit_sync(1) == 2 - out = capsys.readouterr().out - line1, line2, line3 = out.splitlines() - expected1 = self.trace + r"tests\.test_loguru:test_exit_sync:\d+ - ➢$" - assert search(expected1, line1), line1 - expected2 = self.info + r"tests\.functions:func_test_exit_sync:\d+ - Starting$" - assert search(expected2, line2), line2 - expected3 = self.info + r"tests\.test_loguru:test_exit_sync:\d+ - ✔$" - assert search(expected3, line3), line3 - - async def test_exit_async(self, *, capsys: CaptureFixture) -> None: - handler: HandlerConfiguration = {"sink": sys.stdout, "level": LogLevel.TRACE} - _ = logger.configure(handlers=[cast(dict[str, Any], handler)]) - - assert await func_test_exit_async(1) == 2 - out = capsys.readouterr().out - line1, line2, line3 = out.splitlines() - expected1 = self.trace + r"tests\.test_loguru:test_exit_async:\d+ - ➢$" - assert search(expected1, line1), line1 - expected2 = self.info + r"tests\.functions:func_test_exit_async:\d+ - Starting$" - assert search(expected2, line2), line2 - expected3 = self.info + r"tests\.test_loguru:test_exit_async:\d+ - ✔$" - assert search(expected3, line3), line3 - - def test_exit_custom_level(self, *, capsys: CaptureFixture) -> None: - handler: HandlerConfiguration = {"sink": sys.stdout, "level": LogLevel.TRACE} - _ = logger.configure(handlers=[cast(dict[str, Any], handler)]) - - assert func_test_exit_custom_level(1) == 2 - out = capsys.readouterr().out - (line1, line2, line3) = out.splitlines() - expected1 = self.trace + r"tests\.test_loguru:test_exit_custom_level:\d+ - ➢$" - assert search(expected1, line1), line1 - expected2 = ( - self.info + r"tests\.functions:func_test_exit_custom_level:\d+ - Starting$" - ) - assert search(expected2, line2), line2 - expected3 = self.warning + r"tests\.test_loguru:test_exit_custom_level:\d+ - ✔$" - assert search(expected3, line3), line3 - - def test_exit_predicate_no_filter(self, *, capsys: CaptureFixture) -> None: - handler: HandlerConfiguration = {"sink": sys.stdout, "level": LogLevel.TRACE} - _ = logger.configure(handlers=[cast(dict[str, Any], handler)]) - - assert func_test_exit_predicate(0) == 1 - out = capsys.readouterr().out - (line1, line2, line3) = out.splitlines() - expected1 = ( - self.trace + r"tests\.test_loguru:test_exit_predicate_no_filter:\d+ - ➢$" - ) - assert search(expected1, line1), line1 - expected2 = ( - self.info + r"tests\.functions:func_test_exit_predicate:\d+ - Starting$" - ) - assert search(expected2, line2), line2 - expected3 = ( - self.info + r"tests\.test_loguru:test_exit_predicate_no_filter:\d+ - ✔$" - ) - assert search(expected3, line3), line3 - - def test_exit_predicate_filter(self, *, capsys: CaptureFixture) -> None: - handler: HandlerConfiguration = {"sink": sys.stdout, "level": LogLevel.TRACE} - _ = logger.configure(handlers=[cast(dict[str, Any], handler)]) - - assert func_test_exit_predicate(1) is None - out = capsys.readouterr().out - (line1, line2) = out.splitlines() - expected1 = ( - self.trace + r"tests\.test_loguru:test_exit_predicate_filter:\d+ - ➢$" - ) - assert search(expected1, line1), line1 - expected2 = ( - self.info + r"tests\.functions:func_test_exit_predicate:\d+ - Starting$" - ) - assert search(expected2, line2), line2 - - def test_decorated(self, *, capsys: CaptureFixture) -> None: - handler: HandlerConfiguration = {"sink": sys.stdout, "level": LogLevel.TRACE} - _ = logger.configure(handlers=[cast(dict[str, Any], handler)]) - - assert func_test_decorated(0) == (1, 2) - out = capsys.readouterr().out - (line1, line2, line3, line4, line5) = out.splitlines() - expected1 = self.trace + r"tests\.test_loguru:test_decorated:\d+ - ➢$" - assert search(expected1, line1), line1 - expected2 = self.trace + r"tests\.test_loguru:test_decorated:\d+ - ➢$" - assert search(expected2, line2), line2 - expected3 = ( - self.info + r"tests\.functions:func_test_decorated:\d+ - Starting x=0$" - ) - assert search(expected3, line3), line3 - expected4 = self.trace + r"tests\.test_loguru:test_decorated:\d+ - ➢$" - assert search(expected4, line4), line4 - expected5 = ( - self.info + r"tests\.functions:func_test_decorated:\d+ - Starting x=1$" - ) - assert search(expected5, line5), line5 - class TestLoggedSleep: @mark.parametrize("duration", [param(0.01), param(dt.timedelta(seconds=0.1))]) diff --git a/src/tests/test_loguru_functions.py b/src/tests/test_loguru_functions.py index d022e0e40..dad278b67 100644 --- a/src/tests/test_loguru_functions.py +++ b/src/tests/test_loguru_functions.py @@ -1,5 +1,7 @@ from __future__ import annotations +from time import sleep + from utilities.loguru import LogLevel, log @@ -44,3 +46,14 @@ def func_test_error_expected(x: int, /) -> int | None: return x + 1 msg = f"Got an odd number: {x}" raise ValueError(msg) + + +def func_test_exit_explicit(x: int, /) -> int: + with log(exit_level=LogLevel.DEBUG): + return x + 1 + + +def func_test_exit_duration(x: int, /) -> int: + with log(exit_duration=0.01): + sleep(0.02) + return x + 1 diff --git a/src/utilities/loguru.py b/src/utilities/loguru.py index 242a34ef8..8ddea3708 100644 --- a/src/utilities/loguru.py +++ b/src/utilities/loguru.py @@ -11,7 +11,7 @@ from enum import StrEnum, unique from logging import Handler, LogRecord from sys import __excepthook__, _getframe, stderr -from typing import TYPE_CHECKING, Any, TextIO, TypedDict, cast +from typing import TYPE_CHECKING, Any, TextIO, TypedDict, assert_never, cast from loguru import logger from typing_extensions import override @@ -226,6 +226,8 @@ def log( exit_level_use = ( LogLevel.TRACE if entry_level is None else entry_level ) + case _ as never: # pyright: ignore[reportUnnecessaryComparison] + assert_never(never) logger_exit = logger if exit_bind is None else logger.bind(**exit_bind) logger_exit.opt(depth=depth).log( exit_level_use, exit_message, timer=timer From df82fd7e27edbdb30de5a44142c469547ebe6049 Mon Sep 17 00:00:00 2001 From: Derek Wan Date: Sun, 15 Sep 2024 22:10:28 +0900 Subject: [PATCH 05/11] fix --- src/tests/functions.py | 54 +----------------------------- src/tests/test_loguru.py | 51 ++++++++++++++-------------- src/tests/test_loguru_functions.py | 45 +++++++++++++++++++------ src/tests/test_tenacity.py | 4 +-- 4 files changed, 63 insertions(+), 91 deletions(-) diff --git a/src/tests/functions.py b/src/tests/functions.py index 0bfb1c413..5daa3fd8d 100644 --- a/src/tests/functions.py +++ b/src/tests/functions.py @@ -1,6 +1,5 @@ from __future__ import annotations -from asyncio import sleep from functools import wraps from typing import TYPE_CHECKING @@ -12,59 +11,8 @@ from utilities.tenacity import before_sleep_log if TYPE_CHECKING: + from asyncio import sleep from collections.abc import Callable -@log(exit_=LogLevel.INFO) -async def func_test_exit_async(x: int, /) -> int: - logger.info("Starting") - await sleep(0.01) - return x + 1 - - -@log(exit_=LogLevel.WARNING) -def func_test_exit_custom_level(x: int, /) -> int: - logger.info("Starting") - return x + 1 - - -@log(exit_=LogLevel.INFO, exit_predicate=is_not_none) -def func_test_exit_predicate(x: int, /) -> int | None: - logger.info("Starting") - return (x + 1) if x % 2 == 0 else None - - -# test decorated - - -def make_new(func: Callable[[int], int], /) -> Callable[[int], tuple[int, int]]: - @wraps(func) - @log - def wrapped(x: int, /) -> tuple[int, int]: - first = func(x) - second = func(x + 1) - return first, second - - return wrapped - - -@make_new -@log(depth=3) -def func_test_decorated(x: int, /) -> int: - logger.info(f"Starting x={x}") - return x + 1 - - # test tenacity - - -_counter = 0 - - -@retry(wait=wait_fixed(0.01), before_sleep=before_sleep_log()) -def func_test_before_sleep_log() -> int: - global _counter # noqa: PLW0603 - _counter += 1 - if _counter >= 3: - return _counter - raise ValueError(_counter) diff --git a/src/tests/test_loguru.py b/src/tests/test_loguru.py index 1319b5a14..c36992c20 100644 --- a/src/tests/test_loguru.py +++ b/src/tests/test_loguru.py @@ -12,13 +12,13 @@ from pytest import CaptureFixture, mark, param, raises from tests.test_loguru_functions import ( - func_test_entry_disabled, - func_test_entry_inc_and_dec, - func_test_entry_non_default_level, - func_test_error, - func_test_error_expected, - func_test_exit_duration, - func_test_exit_explicit, + func_test_log_entry_disabled, + func_test_log_entry_inc_and_dec, + func_test_log_entry_non_default_level, + func_test_log_error, + func_test_log_error_expected, + func_test_log_exit_duration, + func_test_log_exit_explicit, ) from utilities.hypothesis import text_ascii from utilities.loguru import ( @@ -145,21 +145,21 @@ def test_entry(self, *, capsys: CaptureFixture) -> None: handler: HandlerConfiguration = {"sink": sys.stdout, "level": LogLevel.TRACE} _ = logger.configure(handlers=[cast(dict[str, Any], handler)]) - assert func_test_entry_inc_and_dec(1) == (2, 0) + assert func_test_log_entry_inc_and_dec(1) == (2, 0) out = capsys.readouterr().out line1, line2, line3 = out.splitlines() - expected1 = self.trace + r"func_test_entry_inc_and_dec:\d+ - ➢$" + expected1 = self.trace + r"func_test_log_entry_inc_and_dec:\d+ - ➢$" assert search(expected1, line1), line1 - expected2 = self.trace + r"_func_test_entry_inc:\d+ - ➢$" + expected2 = self.trace + r"_func_test_log_entry_inc:\d+ - ➢$" assert search(expected2, line2), line2 - expected3 = self.trace + r"_func_test_entry_dec:\d+ - ➢$" + expected3 = self.trace + r"_func_test_log_entry_dec:\d+ - ➢$" assert search(expected3, line3), line3 def test_entry_disabled(self, *, capsys: CaptureFixture) -> None: handler: HandlerConfiguration = {"sink": sys.stdout, "level": LogLevel.TRACE} _ = logger.configure(handlers=[cast(dict[str, Any], handler)]) - assert func_test_entry_disabled(1) == 2 + assert func_test_log_entry_disabled(1) == 2 out = capsys.readouterr().out assert out == "" @@ -167,9 +167,9 @@ def test_entry_non_default_level(self, *, capsys: CaptureFixture) -> None: handler: HandlerConfiguration = {"sink": sys.stdout, "level": LogLevel.TRACE} _ = logger.configure(handlers=[cast(dict[str, Any], handler)]) - assert func_test_entry_non_default_level(1) == 2 + assert func_test_log_entry_non_default_level(1) == 2 out = capsys.readouterr().out - expected = self.debug + r"func_test_entry_non_default_level:\d+ - ➢$" + expected = self.debug + r"func_test_log_entry_non_default_level:\d+ - ➢$" assert search(expected, out), out def test_error(self, *, capsys: CaptureFixture) -> None: @@ -177,13 +177,14 @@ def test_error(self, *, capsys: CaptureFixture) -> None: _ = logger.configure(handlers=[cast(dict[str, Any], handler)]) with raises(ValueError, match="Got an odd number: 1"): - _ = func_test_error(1) + _ = func_test_log_error(1) out = capsys.readouterr().out line1, line2, line3, *_ = out.splitlines() - expected1 = self.trace + r"func_test_error:\d+ - ➢$" + expected1 = self.trace + r"func_test_log_error:\d+ - ➢$" assert search(expected1, line1), line1 expected2 = ( - self.error + r"func_test_error:\d+ - ValueError\('Got an odd number: 1'\)$" + self.error + + r"func_test_log_error:\d+ - ValueError\('Got an odd number: 1'\)$" ) assert search(expected2, line2), line2 assert line3 == "Traceback (most recent call last):" @@ -203,34 +204,34 @@ def test_error_expected(self, *, capsys: CaptureFixture) -> None: _ = logger.configure(handlers=[cast(dict[str, Any], handler)]) with raises(ValueError, match="Got an odd number: 1"): - _ = func_test_error_expected(1) + _ = func_test_log_error_expected(1) out = capsys.readouterr().out (line,) = out.splitlines() - expected = self.trace + r"func_test_error_expected:\d+ - ➢$" + expected = self.trace + r"func_test_log_error_expected:\d+ - ➢$" assert search(expected, line), line def test_exit_explicit(self, *, capsys: CaptureFixture) -> None: handler: HandlerConfiguration = {"sink": sys.stdout, "level": LogLevel.TRACE} _ = logger.configure(handlers=[cast(dict[str, Any], handler)]) - assert func_test_exit_explicit(1) == 2 + assert func_test_log_exit_explicit(1) == 2 out = capsys.readouterr().out line1, line2 = out.splitlines() - expected1 = self.trace + r"func_test_exit_explicit:\d+ - ➢$" + expected1 = self.trace + r"func_test_log_exit_explicit:\d+ - ➢$" assert search(expected1, line1), line1 - expected2 = self.debug + r"func_test_exit_explicit:\d+ - ✔$" + expected2 = self.debug + r"func_test_log_exit_explicit:\d+ - ✔$" assert search(expected2, line2), line2 def test_exit_duration(self, *, capsys: CaptureFixture) -> None: handler: HandlerConfiguration = {"sink": sys.stdout, "level": LogLevel.TRACE} _ = logger.configure(handlers=[cast(dict[str, Any], handler)]) - assert func_test_exit_duration(1) == 2 + assert func_test_log_exit_duration(1) == 2 out = capsys.readouterr().out line1, line2 = out.splitlines() - expected1 = self.trace + r"func_test_exit_duration:\d+ - ➢$" + expected1 = self.trace + r"func_test_log_exit_duration:\d+ - ➢$" assert search(expected1, line1), line1 - expected2 = self.trace + r"func_test_exit_duration:\d+ - ✔$" + expected2 = self.trace + r"func_test_log_exit_duration:\d+ - ✔$" assert search(expected2, line2), line2 diff --git a/src/tests/test_loguru_functions.py b/src/tests/test_loguru_functions.py index dad278b67..9dedf2b74 100644 --- a/src/tests/test_loguru_functions.py +++ b/src/tests/test_loguru_functions.py @@ -1,38 +1,49 @@ from __future__ import annotations +from asyncio import sleep +from functools import wraps from time import sleep +from typing import TYPE_CHECKING +from loguru import logger +from tenacity import retry, wait_fixed + +from utilities.functions import is_not_none from utilities.loguru import LogLevel, log +from utilities.tenacity import before_sleep_log + +if TYPE_CHECKING: + from collections.abc import Callable -def func_test_entry_inc_and_dec(x: int, /) -> tuple[int, int]: +def func_test_log_entry_inc_and_dec(x: int, /) -> tuple[int, int]: with log(): - inc = _func_test_entry_inc(x) - dec = _func_test_entry_dec(x) + inc = _func_test_log_entry_inc(x) + dec = _func_test_log_entry_dec(x) return inc, dec -def _func_test_entry_inc(x: int, /) -> int: +def _func_test_log_entry_inc(x: int, /) -> int: with log(): return x + 1 -def _func_test_entry_dec(x: int, /) -> int: +def _func_test_log_entry_dec(x: int, /) -> int: with log(): return x - 1 -def func_test_entry_disabled(x: int, /) -> int: +def func_test_log_entry_disabled(x: int, /) -> int: with log(entry_level=None): return x + 1 -def func_test_entry_non_default_level(x: int, /) -> int: +def func_test_log_entry_non_default_level(x: int, /) -> int: with log(entry_level=LogLevel.DEBUG): return x + 1 -def func_test_error(x: int, /) -> int | None: +def func_test_log_error(x: int, /) -> int | None: with log(): if x % 2 == 0: return x + 1 @@ -40,7 +51,7 @@ def func_test_error(x: int, /) -> int | None: raise ValueError(msg) -def func_test_error_expected(x: int, /) -> int | None: +def func_test_log_error_expected(x: int, /) -> int | None: with log(error_expected=ValueError): if x % 2 == 0: return x + 1 @@ -48,12 +59,24 @@ def func_test_error_expected(x: int, /) -> int | None: raise ValueError(msg) -def func_test_exit_explicit(x: int, /) -> int: +def func_test_log_exit_explicit(x: int, /) -> int: with log(exit_level=LogLevel.DEBUG): return x + 1 -def func_test_exit_duration(x: int, /) -> int: +def func_test_log_exit_duration(x: int, /) -> int: with log(exit_duration=0.01): sleep(0.02) return x + 1 + + +_counter = 0 + + +@retry(wait=wait_fixed(0.01), before_sleep=before_sleep_log()) +def func_test_tenacity_before_sleep_log() -> int: + global _counter # noqa: PLW0603 + _counter += 1 + if _counter >= 3: + return _counter + raise ValueError(_counter) diff --git a/src/tests/test_tenacity.py b/src/tests/test_tenacity.py index 83ae89bea..7bfa0fcbd 100644 --- a/src/tests/test_tenacity.py +++ b/src/tests/test_tenacity.py @@ -8,7 +8,7 @@ from hypothesis.strategies import floats from loguru import logger -from tests.functions import func_test_before_sleep_log +from tests.test_loguru_functions import func_test_tenacity_before_sleep_log from utilities.hypothesis import durations from utilities.tenacity import wait_exponential_jitter @@ -35,7 +35,7 @@ def test_main(self, *, capsys: CaptureFixture) -> None: handler: HandlerConfiguration = {"sink": sys.stdout} _ = logger.configure(handlers=[cast(dict[str, Any], handler)]) - assert func_test_before_sleep_log() == 3 + assert func_test_tenacity_before_sleep_log() == 3 out = capsys.readouterr().out lines = out.splitlines() assert len(lines) == 2 From ec903e0953d186dfdd4ec66bf297d89d374c67df Mon Sep 17 00:00:00 2001 From: Derek Wan Date: Sun, 15 Sep 2024 22:10:41 +0900 Subject: [PATCH 06/11] remove --- src/tests/functions.py | 18 ------------------ 1 file changed, 18 deletions(-) delete mode 100644 src/tests/functions.py diff --git a/src/tests/functions.py b/src/tests/functions.py deleted file mode 100644 index 5daa3fd8d..000000000 --- a/src/tests/functions.py +++ /dev/null @@ -1,18 +0,0 @@ -from __future__ import annotations - -from functools import wraps -from typing import TYPE_CHECKING - -from loguru import logger -from tenacity import retry, wait_fixed - -from utilities.functions import is_not_none -from utilities.loguru import LogLevel, log -from utilities.tenacity import before_sleep_log - -if TYPE_CHECKING: - from asyncio import sleep - from collections.abc import Callable - - -# test tenacity From de2f1558fcf6c12ba405e10d67ad64626c33de50 Mon Sep 17 00:00:00 2001 From: Derek Wan Date: Sun, 15 Sep 2024 22:50:35 +0900 Subject: [PATCH 07/11] more --- src/utilities/loguru.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/utilities/loguru.py b/src/utilities/loguru.py index 8ddea3708..d8c629647 100644 --- a/src/utilities/loguru.py +++ b/src/utilities/loguru.py @@ -201,7 +201,7 @@ def log( exit_message: str = "✔", **kwargs: Any, ) -> Iterator[None]: - """Log the function call.""" + """Log the function entry/error/exit/duration.""" with logger.contextualize(**kwargs), Timer() as timer: if entry_level is not None: logger_entry = logger if entry_bind is None else logger.bind(**entry_bind) From bc41b746b399196b5c4f11edd84c4967bf8eff6d Mon Sep 17 00:00:00 2001 From: Derek Wan Date: Sun, 15 Sep 2024 22:53:31 +0900 Subject: [PATCH 08/11] more --- requirements.txt | 2 +- requirements/altair.txt | 2 +- requirements/streamlit.txt | 2 +- src/tests/test_loguru.py | 3 +-- src/tests/test_loguru_functions.py | 8 -------- src/utilities/__init__.py | 2 +- 6 files changed, 5 insertions(+), 14 deletions(-) diff --git a/requirements.txt b/requirements.txt index 5df356853..b09e65e4e 100644 --- a/requirements.txt +++ b/requirements.txt @@ -186,7 +186,7 @@ multidict==6.1.0 # via # aiohttp # yarl -narwhals==1.8.0 +narwhals==1.8.1 # via altair nest-asyncio==1.6.0 # via dycw-utilities (pyproject.toml) diff --git a/requirements/altair.txt b/requirements/altair.txt index a98882572..e194c61b4 100644 --- a/requirements/altair.txt +++ b/requirements/altair.txt @@ -29,7 +29,7 @@ lxml==5.3.0 # via pikepdf markupsafe==2.1.5 # via jinja2 -narwhals==1.8.0 +narwhals==1.8.1 # via altair packaging==24.1 # via diff --git a/requirements/streamlit.txt b/requirements/streamlit.txt index 518c63f8d..164a3c113 100644 --- a/requirements/streamlit.txt +++ b/requirements/streamlit.txt @@ -43,7 +43,7 @@ markupsafe==2.1.5 # via jinja2 mdurl==0.1.2 # via markdown-it-py -narwhals==1.8.0 +narwhals==1.8.1 # via altair numpy==2.1.1 # via diff --git a/src/tests/test_loguru.py b/src/tests/test_loguru.py index c36992c20..346e7a131 100644 --- a/src/tests/test_loguru.py +++ b/src/tests/test_loguru.py @@ -7,7 +7,6 @@ from hypothesis import given from loguru import logger -from loguru._defaults import LOGURU_FORMAT from loguru._recattrs import RecordFile, RecordLevel, RecordProcess, RecordThread from pytest import CaptureFixture, mark, param, raises @@ -38,7 +37,7 @@ make_slack_sink, make_slack_sink_async, ) -from utilities.text import ensure_str, strip_and_dedent +from utilities.text import strip_and_dedent if TYPE_CHECKING: from collections.abc import Callable diff --git a/src/tests/test_loguru_functions.py b/src/tests/test_loguru_functions.py index 9dedf2b74..978c2ee25 100644 --- a/src/tests/test_loguru_functions.py +++ b/src/tests/test_loguru_functions.py @@ -1,20 +1,12 @@ from __future__ import annotations -from asyncio import sleep -from functools import wraps from time import sleep -from typing import TYPE_CHECKING -from loguru import logger from tenacity import retry, wait_fixed -from utilities.functions import is_not_none from utilities.loguru import LogLevel, log from utilities.tenacity import before_sleep_log -if TYPE_CHECKING: - from collections.abc import Callable - def func_test_log_entry_inc_and_dec(x: int, /) -> tuple[int, int]: with log(): diff --git a/src/utilities/__init__.py b/src/utilities/__init__.py index cc958bf75..1cdad2321 100644 --- a/src/utilities/__init__.py +++ b/src/utilities/__init__.py @@ -1,3 +1,3 @@ from __future__ import annotations -__version__ = "0.55.1" +__version__ = "0.55.2" From 44fce06cedd5633074ae5d7f7b4b7491a266434d Mon Sep 17 00:00:00 2001 From: Derek Wan Date: Sun, 15 Sep 2024 23:11:52 +0900 Subject: [PATCH 09/11] more --- src/tests/test_tenacity.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/tests/test_tenacity.py b/src/tests/test_tenacity.py index 7bfa0fcbd..c5d44ff35 100644 --- a/src/tests/test_tenacity.py +++ b/src/tests/test_tenacity.py @@ -41,7 +41,7 @@ def test_main(self, *, capsys: CaptureFixture) -> None: assert len(lines) == 2 for i, line in enumerate(lines, start=1): expected = ( - r"\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3} \| INFO \| utilities\.tenacity:log:\d+ - Retrying tests\.functions\.func_test_before_sleep_log in 0\.01 seconds as it raised ValueError: " + r"\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3} \| INFO \| utilities\.tenacity:log:\d+ - Retrying tests\.test_loguru_functions\.func_test_tenacity_before_sleep_log in 0\.01 seconds as it raised ValueError: " + str(i) + r"\." ) From e1f6e8975e74f06e82499814fe776e40cf1c71a9 Mon Sep 17 00:00:00 2001 From: Derek Wan Date: Mon, 16 Sep 2024 07:24:12 +0900 Subject: [PATCH 10/11] hi --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index b09e65e4e..c88c613b6 100644 --- a/requirements.txt +++ b/requirements.txt @@ -128,7 +128,7 @@ hyperlink==21.0.0 # via hatch hypothesis==6.112.1 # via dycw-utilities (pyproject.toml) -idna==3.9 +idna==3.10 # via # anyio # httpx From a2ae96d597b95449d305a17db2729de8f3af4911 Mon Sep 17 00:00:00 2001 From: Derek Wan Date: Mon, 16 Sep 2024 07:26:30 +0900 Subject: [PATCH 11/11] more --- requirements/jupyter.txt | 4 ++-- requirements/slack-sdk.txt | 2 +- requirements/streamlit.txt | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/requirements/jupyter.txt b/requirements/jupyter.txt index e7554ba5b..cd111a4af 100644 --- a/requirements/jupyter.txt +++ b/requirements/jupyter.txt @@ -60,7 +60,7 @@ httpx==0.27.2 # via jupyterlab hypothesis==6.112.1 # via dycw-utilities (pyproject.toml) -idna==3.9 +idna==3.10 # via # anyio # httpx @@ -245,7 +245,7 @@ rpds-py==0.20.0 # referencing send2trash==1.8.3 # via jupyter-server -setuptools==74.1.2 +setuptools==75.0.0 # via jupyterlab six==1.16.0 # via diff --git a/requirements/slack-sdk.txt b/requirements/slack-sdk.txt index 5263f8e26..670110b40 100644 --- a/requirements/slack-sdk.txt +++ b/requirements/slack-sdk.txt @@ -18,7 +18,7 @@ frozenlist==1.4.1 # aiosignal hypothesis==6.112.1 # via dycw-utilities (pyproject.toml) -idna==3.9 +idna==3.10 # via yarl iniconfig==2.0.0 # via pytest diff --git a/requirements/streamlit.txt b/requirements/streamlit.txt index 164a3c113..09b854037 100644 --- a/requirements/streamlit.txt +++ b/requirements/streamlit.txt @@ -25,7 +25,7 @@ gitpython==3.1.43 # via streamlit hypothesis==6.112.1 # via dycw-utilities (pyproject.toml) -idna==3.9 +idna==3.10 # via requests iniconfig==2.0.0 # via pytest