From 532e7e328eda48d1cb1a861d307bf59d56200eea Mon Sep 17 00:00:00 2001 From: Delgan Date: Sun, 3 Dec 2023 11:43:53 +0100 Subject: [PATCH] Avoid repetition of Mypy tests when possible Unfortunately, "force_uppercase_builtins" and "force_union_syntax" options are not supported by Mypy for Python < 3.7, therefore there are still some duplicated tests. The additional change in "invalid_configuration" is to avoid failures after Mypy upgrade to 1.7.1, since "" will be changed to "Never". --- tests/typesafety/test_logger.yml | 95 ++++++++++++-------------------- 1 file changed, 36 insertions(+), 59 deletions(-) diff --git a/tests/typesafety/test_logger.yml b/tests/typesafety/test_logger.yml index 3815a7e7..8e4ae136 100644 --- a/tests/typesafety/test_logger.yml +++ b/tests/typesafety/test_logger.yml @@ -194,17 +194,19 @@ main:5: note: Revealed type is "loguru.Contextualizer" - case: level_get - skip: sys.version_info < (3, 9) + skip: sys.version_info < (3, 7) main: | from loguru import logger import loguru level = logger.level("INFO") reveal_type(level) out: | - main:4: note: Revealed type is "tuple[builtins.str, builtins.int, builtins.str, builtins.str, fallback=loguru.Level]" + main:4: note: Revealed type is "Tuple[builtins.str, builtins.int, builtins.str, builtins.str, fallback=loguru.Level]" + mypy_config: | + force_uppercase_builtins = true -- case: level_get_pre39 - skip: not sys.version_info < (3, 9) +- case: level_get_pre37 + skip: not sys.version_info < (3, 7) main: | from loguru import logger import loguru @@ -214,17 +216,19 @@ main:4: note: Revealed type is "Tuple[builtins.str, builtins.int, builtins.str, builtins.str, fallback=loguru.Level]" - case: level_set - skip: sys.version_info < (3, 9) + skip: sys.version_info < (3, 7) main: | from loguru import logger import loguru level = logger.level("FOO", no=11, icon="!", color="") reveal_type(level) out: | - main:4: note: Revealed type is "tuple[builtins.str, builtins.int, builtins.str, builtins.str, fallback=loguru.Level]" + main:4: note: Revealed type is "Tuple[builtins.str, builtins.int, builtins.str, builtins.str, fallback=loguru.Level]" + mypy_config: | + force_uppercase_builtins = true -- case: level_set_pre39 - skip: not sys.version_info < (3, 9) +- case: level_set_pre37 + skip: not sys.version_info < (3, 7) main: | from loguru import logger import loguru @@ -234,17 +238,19 @@ main:4: note: Revealed type is "Tuple[builtins.str, builtins.int, builtins.str, builtins.str, fallback=loguru.Level]" - case: level_update - skip: sys.version_info < (3, 9) + skip: sys.version_info < (3, 7) main: | from loguru import logger import loguru level = logger.level("INFO", color="") reveal_type(level) out: | - main:4: note: Revealed type is "tuple[builtins.str, builtins.int, builtins.str, builtins.str, fallback=loguru.Level]" + main:4: note: Revealed type is "Tuple[builtins.str, builtins.int, builtins.str, builtins.str, fallback=loguru.Level]" + mypy_config: | + force_uppercase_builtins = true -- case: level_update_pre39 - skip: not sys.version_info < (3, 9) +- case: level_update_pre37 + skip: not sys.version_info < (3, 7) main: | from loguru import logger import loguru @@ -286,35 +292,23 @@ main:6: note: Revealed type is "builtins.dict[builtins.str, Any]" - case: invalid_add_argument - skip: sys.version_info < (3, 10) - main: | - from loguru import logger - logger.add(lambda m: None, foobar=123) - out: | - main:2: error: No overload variant of "add" of "Logger" matches argument types "Callable[[Any], None]", "int" - main:2: note: Possible overload variants: - main:2: note: def add(self, sink: TextIO | Writable | Callable[[Message], None] | Handler, *, level: str | int = ..., format: str | Callable[[Record], str] = ..., filter: str | Callable[[Record], bool] | dict[str | None, str | int | bool] | None = ..., colorize: bool | None = ..., serialize: bool = ..., backtrace: bool = ..., diagnose: bool = ..., enqueue: bool = ..., context: str | BaseContext | None = ..., catch: bool = ...) -> int - main:2: note: def add(self, sink: Callable[[Message], Awaitable[None]], *, level: str | int = ..., format: str | Callable[[Record], str] = ..., filter: str | Callable[[Record], bool] | dict[str | None, str | int | bool] | None = ..., colorize: bool | None = ..., serialize: bool = ..., backtrace: bool = ..., diagnose: bool = ..., enqueue: bool = ..., context: str | BaseContext | None = ..., catch: bool = ..., loop: AbstractEventLoop | None = ...) -> int - main:2: note: def add(self, sink: str | PathLike[str], *, level: str | int = ..., format: str | Callable[[Record], str] = ..., filter: str | Callable[[Record], bool] | dict[str | None, str | int | bool] | None = ..., colorize: bool | None = ..., serialize: bool = ..., backtrace: bool = ..., diagnose: bool = ..., enqueue: bool = ..., context: str | BaseContext | None = ..., catch: bool = ..., rotation: str | int | time | timedelta | Callable[[Message, TextIO], bool] | None = ..., retention: str | int | timedelta | Callable[[list[str]], None] | None = ..., compression: str | Callable[[str], None] | None = ..., delay: bool = ..., watch: bool = ..., mode: str = ..., buffering: int = ..., encoding: str = ..., **kwargs: Any) -> int - mypy_config: | - show_error_codes = false - -- case: invalid_add_argument_pre310 - skip: not (3, 9) <= sys.version_info < (3, 10) + skip: sys.version_info < (3, 7) main: | from loguru import logger logger.add(lambda m: None, foobar=123) out: | main:2: error: No overload variant of "add" of "Logger" matches argument types "Callable[[Any], None]", "int" main:2: note: Possible overload variants: - main:2: note: def add(self, sink: Union[TextIO, Writable, Callable[[Message], None], Handler], *, level: Union[str, int] = ..., format: Union[str, Callable[[Record], str]] = ..., filter: Union[str, Callable[[Record], bool], dict[Optional[str], Union[str, int, bool]], None] = ..., colorize: Optional[bool] = ..., serialize: bool = ..., backtrace: bool = ..., diagnose: bool = ..., enqueue: bool = ..., context: Union[str, BaseContext, None] = ..., catch: bool = ...) -> int - main:2: note: def add(self, sink: Callable[[Message], Awaitable[None]], *, level: Union[str, int] = ..., format: Union[str, Callable[[Record], str]] = ..., filter: Union[str, Callable[[Record], bool], dict[Optional[str], Union[str, int, bool]], None] = ..., colorize: Optional[bool] = ..., serialize: bool = ..., backtrace: bool = ..., diagnose: bool = ..., enqueue: bool = ..., context: Union[str, BaseContext, None] = ..., catch: bool = ..., loop: Optional[AbstractEventLoop] = ...) -> int - main:2: note: def add(self, sink: Union[str, PathLike[str]], *, level: Union[str, int] = ..., format: Union[str, Callable[[Record], str]] = ..., filter: Union[str, Callable[[Record], bool], dict[Optional[str], Union[str, int, bool]], None] = ..., colorize: Optional[bool] = ..., serialize: bool = ..., backtrace: bool = ..., diagnose: bool = ..., enqueue: bool = ..., context: Union[str, BaseContext, None] = ..., catch: bool = ..., rotation: Union[str, int, time, timedelta, Callable[[Message, TextIO], bool], None] = ..., retention: Union[str, int, timedelta, Callable[[list[str]], None], None] = ..., compression: Union[str, Callable[[str], None], None] = ..., delay: bool = ..., watch: bool = ..., mode: str = ..., buffering: int = ..., encoding: str = ..., **kwargs: Any) -> int + main:2: note: def add(self, sink: Union[TextIO, Writable, Callable[[Message], None], Handler], *, level: Union[str, int] = ..., format: Union[str, Callable[[Record], str]] = ..., filter: Union[str, Callable[[Record], bool], Dict[Optional[str], Union[str, int, bool]], None] = ..., colorize: Optional[bool] = ..., serialize: bool = ..., backtrace: bool = ..., diagnose: bool = ..., enqueue: bool = ..., context: Union[str, BaseContext, None] = ..., catch: bool = ...) -> int + main:2: note: def add(self, sink: Callable[[Message], Awaitable[None]], *, level: Union[str, int] = ..., format: Union[str, Callable[[Record], str]] = ..., filter: Union[str, Callable[[Record], bool], Dict[Optional[str], Union[str, int, bool]], None] = ..., colorize: Optional[bool] = ..., serialize: bool = ..., backtrace: bool = ..., diagnose: bool = ..., enqueue: bool = ..., context: Union[str, BaseContext, None] = ..., catch: bool = ..., loop: Optional[AbstractEventLoop] = ...) -> int + main:2: note: def add(self, sink: Union[str, PathLike[str]], *, level: Union[str, int] = ..., format: Union[str, Callable[[Record], str]] = ..., filter: Union[str, Callable[[Record], bool], Dict[Optional[str], Union[str, int, bool]], None] = ..., colorize: Optional[bool] = ..., serialize: bool = ..., backtrace: bool = ..., diagnose: bool = ..., enqueue: bool = ..., context: Union[str, BaseContext, None] = ..., catch: bool = ..., rotation: Union[str, int, time, timedelta, Callable[[Message, TextIO], bool], None] = ..., retention: Union[str, int, timedelta, Callable[[List[str]], None], None] = ..., compression: Union[str, Callable[[str], None], None] = ..., delay: bool = ..., watch: bool = ..., mode: str = ..., buffering: int = ..., encoding: str = ..., **kwargs: Any) -> int mypy_config: | show_error_codes = false + force_uppercase_builtins = true + force_union_syntax = true -- case: invalid_add_argument_pre39 - skip: not sys.version_info < (3, 9) +- case: invalid_add_argument_pre37 + skip: not sys.version_info < (3, 7) main: | from loguru import logger logger.add(lambda m: None, foobar=123) @@ -354,26 +348,7 @@ show_error_codes = false - case: invalid_configuration - skip: sys.version_info < (3, 10) - main: | - from loguru import logger - logger.configure( - handlers=[{"x": "y"}], - levels=[{"baz": 1}], - patcher=123, - activation=[{"foo": "bar"}], - extra=[], - ) - out: | - main:4: error: Extra key "baz" for TypedDict "LevelConfig" - main:5: error: Argument "patcher" to "configure" of "Logger" has incompatible type "int"; expected "Callable[[Record], None] | None" - main:6: error: List item 0 has incompatible type "dict[str, str]"; expected "tuple[str | None, bool]" - main:7: error: Argument "extra" to "configure" of "Logger" has incompatible type "list[]"; expected "dict[Any, Any] | None" - mypy_config: | - show_error_codes = false - -- case: invalid_configuration_pre310 - skip: not (3, 9) <= sys.version_info < (3, 10) + skip: sys.version_info < (3, 7) main: | from loguru import logger logger.configure( @@ -381,18 +356,20 @@ levels=[{"baz": 1}], patcher=123, activation=[{"foo": "bar"}], - extra=[], + extra=[1], ) out: | main:4: error: Extra key "baz" for TypedDict "LevelConfig" main:5: error: Argument "patcher" to "configure" of "Logger" has incompatible type "int"; expected "Optional[Callable[[Record], None]]" - main:6: error: List item 0 has incompatible type "dict[str, str]"; expected "tuple[Optional[str], bool]" - main:7: error: Argument "extra" to "configure" of "Logger" has incompatible type "list[]"; expected "Optional[dict[Any, Any]]" + main:6: error: List item 0 has incompatible type "Dict[str, str]"; expected "Tuple[Optional[str], bool]" + main:7: error: Argument "extra" to "configure" of "Logger" has incompatible type "List[int]"; expected "Optional[Dict[Any, Any]]" mypy_config: | show_error_codes = false + force_uppercase_builtins = true + force_union_syntax = true -- case: invalid_configuration_pre39 - skip: not sys.version_info < (3, 9) +- case: invalid_configuration_pre37 + skip: not sys.version_info < (3, 7) main: | from loguru import logger logger.configure( @@ -400,12 +377,12 @@ levels=[{"baz": 1}], patcher=123, activation=[{"foo": "bar"}], - extra=[], + extra=[1], ) out: | main:4: error: Extra key "baz" for TypedDict "LevelConfig" main:5: error: Argument "patcher" to "configure" of "Logger" has incompatible type "int"; expected "Optional[Callable[[Record], None]]" main:6: error: List item 0 has incompatible type "Dict[str, str]"; expected "Tuple[Optional[str], bool]" - main:7: error: Argument "extra" to "configure" of "Logger" has incompatible type "List[]"; expected "Optional[Dict[Any, Any]]" + main:7: error: Argument "extra" to "configure" of "Logger" has incompatible type "List[int]"; expected "Optional[Dict[Any, Any]]" mypy_config: | show_error_codes = false