From 85869a0690035b9441fef0bf8e1e60e2698ae4da Mon Sep 17 00:00:00 2001 From: Jesse Bannon Date: Sat, 31 May 2025 11:25:57 -0700 Subject: [PATCH] level --- .../scripting/scripting_functions.rst | 12 ++++-- .../script/functions/print_functions.py | 37 +++++++++++++++--- .../script/functions/test_print_functions.py | 38 +++++++++++++++---- 3 files changed, 70 insertions(+), 17 deletions(-) diff --git a/docs/source/config_reference/scripting/scripting_functions.rst b/docs/source/config_reference/scripting/scripting_functions.rst index 7ffa9f97..b36573de 100644 --- a/docs/source/config_reference/scripting/scripting_functions.rst +++ b/docs/source/config_reference/scripting/scripting_functions.rst @@ -528,24 +528,30 @@ Print Functions print ~~~~~ -:spec: ``print(message: AnyArgument, passthrough: ReturnableArgument) -> ReturnableArgument`` +:spec: ``print(message: AnyArgument, passthrough: ReturnableArgument, level: Optional[Integer]) -> ReturnableArgument`` :description: Print the ``message`` and return ``passthrough``. + Optionally can pass level, where < 0 is debug, 0 is info, 1 is warning, > 1 is error. + Defaults to info. print_if_false ~~~~~~~~~~~~~~ -:spec: ``print_if_false(message: AnyArgument, passthrough: ReturnableArgument) -> ReturnableArgument`` +:spec: ``print_if_false(message: AnyArgument, passthrough: ReturnableArgument, level: Optional[Integer]) -> ReturnableArgument`` :description: Print the ``message`` if ``passthrough`` evaluates to ``false``. Return ``passthrough``. + Optionally can pass level, where < 0 is debug, 0 is info, 1 is warning, > 1 is error. + Defaults to info. print_if_true ~~~~~~~~~~~~~ -:spec: ``print_if_true(message: AnyArgument, passthrough: ReturnableArgument) -> ReturnableArgument`` +:spec: ``print_if_true(message: AnyArgument, passthrough: ReturnableArgument, level: Optional[Integer]) -> ReturnableArgument`` :description: Print the ``message`` if ``passthrough`` evaluates to ``true``. Return ``passthrough``. + Optionally can pass level, where < 0 is debug, 0 is info, 1 is warning, > 1 is error. + Defaults to info. ---------------------------------------------------------------------------------------------------- diff --git a/src/ytdl_sub/script/functions/print_functions.py b/src/ytdl_sub/script/functions/print_functions.py index fca4bfd4..a89bcd28 100644 --- a/src/ytdl_sub/script/functions/print_functions.py +++ b/src/ytdl_sub/script/functions/print_functions.py @@ -1,42 +1,67 @@ +from typing import Optional + from ytdl_sub.script.types.resolvable import AnyArgument +from ytdl_sub.script.types.resolvable import Integer from ytdl_sub.script.types.resolvable import ReturnableArgument from ytdl_sub.utils.logger import Logger logger = Logger.get(name="preset") +def _log(message: AnyArgument, level: Optional[Integer]) -> None: + if level is None: + logger.info(str(message)) + return + + level_value: int = level.native + if level_value < 0: + logger.debug(str(message)) + elif level_value == 0: + logger.info(str(message)) + elif level_value == 1: + logger.warning(str(message)) + else: # > 1 + logger.error(str(message)) + + class PrintFunctions: @staticmethod def print( - message: AnyArgument, passthrough: ReturnableArgument + message: AnyArgument, passthrough: ReturnableArgument, level: Optional[Integer] = None ) -> ReturnableArgument: """ :description: Print the ``message`` and return ``passthrough``. + Optionally can pass level, where < 0 is debug, 0 is info, 1 is warning, > 1 is error. + Defaults to info. """ - logger.info(str(message)) + _log(message=message, level=level) return passthrough @staticmethod def print_if_true( - message: AnyArgument, passthrough: ReturnableArgument + message: AnyArgument, passthrough: ReturnableArgument, level: Optional[Integer] = None ) -> ReturnableArgument: """ :description: Print the ``message`` if ``passthrough`` evaluates to ``true``. Return ``passthrough``. + Optionally can pass level, where < 0 is debug, 0 is info, 1 is warning, > 1 is error. + Defaults to info. """ if passthrough.value: - logger.info(str(message)) + _log(message=message, level=level) return passthrough @staticmethod def print_if_false( - message: AnyArgument, passthrough: ReturnableArgument + message: AnyArgument, passthrough: ReturnableArgument, level: Optional[Integer] = None ) -> ReturnableArgument: """ :description: Print the ``message`` if ``passthrough`` evaluates to ``false``. Return ``passthrough``. + Optionally can pass level, where < 0 is debug, 0 is info, 1 is warning, > 1 is error. + Defaults to info. """ if not passthrough.value: - logger.info(str(message)) + _log(message=message, level=level) return passthrough diff --git a/tests/unit/script/functions/test_print_functions.py b/tests/unit/script/functions/test_print_functions.py index af4186bf..a23f447d 100644 --- a/tests/unit/script/functions/test_print_functions.py +++ b/tests/unit/script/functions/test_print_functions.py @@ -1,29 +1,31 @@ import logging -from typing import Any, Optional +from typing import Any +from typing import Optional from unittest.mock import patch import pytest from unit.script.conftest import single_variable_output - class TestPrintFunctions: @pytest.mark.parametrize( "function_str, expected_print, expected_output", [ # print - ("{%print('hi mom', True)}", 'hi mom', True), - ("{%print('this is great', [1, 2, 3])}", 'this is great', [1, 2, 3]), - ("{%print([1, 2], [3, 4])}", '[1, 2]', [3, 4]), + ("{%print('hi mom', True)}", "hi mom", True), + ("{%print('this is great', [1, 2, 3])}", "this is great", [1, 2, 3]), + ("{%print([1, 2], [3, 4])}", "[1, 2]", [3, 4]), # print_if_true - ("{%print_if_true('hi mom', True)}", 'hi mom', True), + ("{%print_if_true('hi mom', True)}", "hi mom", True), ("{%print_if_true('hi mom', False)}", None, False), # print_if_false ("{%print_if_false('hi mom', True)}", None, True), - ("{%print_if_false('hi mom', False)}", 'hi mom', False), + ("{%print_if_false('hi mom', False)}", "hi mom", False), ], ) - def test_print_functions(self, function_str: str, expected_print: Optional[str], expected_output: Any): + def test_print_functions( + self, function_str: str, expected_print: Optional[str], expected_output: Any + ): with patch.object(logging.Logger, "info") as mock_logger: output = single_variable_output(function_str) assert output == expected_output @@ -34,3 +36,23 @@ class TestPrintFunctions: else: assert mock_logger.call_count == 0 + @pytest.mark.parametrize( + "function_str, expected_print, expected_output", + [ + # print + ("{%print('hi mom', True, LEVEL)}", "hi mom", True), + # print_if_true + ("{%print_if_true('hi mom', True, LEVEL)}", "hi mom", True), + # print_if_false + ("{%print_if_false('hi mom', False, LEVEL)}", "hi mom", False), + ], + ) + @pytest.mark.parametrize("level", [-1, 0, 1, 2]) + def test_levels(self, function_str: str, expected_print: str, expected_output: str, level: int): + level_mapping = {-1: "debug", 0: "info", 1: "warning", 2: "error"} + with patch.object(logging.Logger, level_mapping[level]) as mock_logger: + output = single_variable_output(function_str.replace("LEVEL", str(level))) + assert output == expected_output + + assert mock_logger.call_count == 1 + assert mock_logger.call_args.args[0] == expected_print