Fix all the typing reports in typesafety

Author: Jazzinghen

typesafety/test_contrib/test_hypothesis/test_laws/test_check_all_laws.yml

@@ -1,16 +1,16 @@
 - case: check_all_laws
   disable_cache: false
   parametrized:
-    - container: Result
-    - container: Maybe
-    - container: IO
-    - container: IOResult
-    - container: Reader
-    - container: ReaderResult
-    - container: ReaderIOResult
-    - container: ReaderFutureResult
-    - container: Future
-    - container: FutureResult
+  - container: Result
+  - container: Maybe
+  - container: IO
+  - container: IOResult
+  - container: Reader
+  - container: ReaderResult
+  - container: ReaderIOResult
+  - container: ReaderFutureResult
+  - container: Future
+  - container: FutureResult
   main: |
     from returns.context import (
         Reader, ReaderResult, ReaderIOResult, ReaderFutureResult,
@@ -25,14 +25,10 @@
 
     x: Type[Lawful] = {{ container }}
 
+
 - case: test_all_laws_accepts_only_one_approach
   disable_cache: false
-  # TODO: remove this config after
-  #     mypy/typeshed/stdlib/unittest/mock.pyi:120:
-  #     error: Class cannot subclass "Any" (has type "Any")
-  # is fixed.
-  mypy_config:
-    disallow_subclassing_any = False
+  mypy_config: disallow_subclassing_any = False
   main: |
     from hypothesis import strategies as st
     from returns.contrib.hypothesis.laws import check_all_laws
@@ -44,31 +40,25 @@
     check_all_laws(
         Result, use_init=True, container_strategy=st.builds(Success, st.integers())
     )
-
   out: |
-    main:8: error: No overload variant of "check_all_laws" matches argument types "Type[Result[_ValueType_co, _ErrorType_co]]", "bool", "SearchStrategy[Success[Any]]"  [call-overload]
+    main:8: error: No overload variant of "check_all_laws" matches argument types "type[Result[_ValueType_co, _ErrorType_co]]", "bool", "SearchStrategy[Success[Any]]"  [call-overload]
     main:8: note: Possible overload variants:
-    main:8: note:     def [Example_co] check_all_laws(container_type: Type[Lawful[Example_co]], *, container_strategy: Union[SearchStrategy[Example_co], Callable[[Type[Example_co]], SearchStrategy[Example_co]]], settings_kwargs: Optional[Dict[str, Any]] = ..., type_strategies: Optional[Dict[Type[object], Union[SearchStrategy[Any], Callable[[Type[Any]], SearchStrategy[Any]]]]] = ...) -> None
-    main:8: note:     def [Example_co] check_all_laws(container_type: Type[Lawful[Example_co]], *, settings_kwargs: Optional[Dict[str, Any]] = ..., use_init: bool = ...) -> None
+    main:8: note:     def [Example_co] check_all_laws(container_type: type[Lawful[Example_co]], *, container_strategy: SearchStrategy[Example_co] | Callable[[type[Example_co]], SearchStrategy[Example_co]], settings_kwargs: dict[str, Any] | None = ..., type_strategies: dict[type[object], SearchStrategy[Any] | Callable[[type[Any]], SearchStrategy[Any]]] | None = ...) -> None
+    main:8: note:     def [Example_co] check_all_laws(container_type: type[Lawful[Example_co]], *, settings_kwargs: dict[str, Any] | None = ..., use_init: bool = ...) -> None
+
 
 - case: test_all_laws_requires_container_strategy
   disable_cache: false
-  # TODO: remove this config after
-  #     mypy/typeshed/stdlib/unittest/mock.pyi:120:
-  #     error: Class cannot subclass "Any" (has type "Any")
-  # is fixed.
-  mypy_config:
-    disallow_subclassing_any = False
+  mypy_config: disallow_subclassing_any = False
   main: |
     from hypothesis import strategies as st
     from returns.contrib.hypothesis.laws import check_all_laws
     from returns.result import Result, Success
 
     check_all_laws(Result, container_strategy=st.builds(Success, st.integers()), type_strategies={int: st.integers()})
     check_all_laws(Result, type_strategies={int: st.integers()})
-
   out: |
-    main:6: error: No overload variant of "check_all_laws" matches argument types "Type[Result[_ValueType_co, _ErrorType_co]]", "Dict[Type[int], SearchStrategy[int]]"  [call-overload]
+    main:6: error: No overload variant of "check_all_laws" matches argument types "type[Result[_ValueType_co, _ErrorType_co]]", "dict[type[int], SearchStrategy[int]]"  [call-overload]
     main:6: note: Possible overload variants:
-    main:6: note:     def [Example_co] check_all_laws(container_type: Type[Lawful[Example_co]], *, container_strategy: Union[SearchStrategy[Example_co], Callable[[Type[Example_co]], SearchStrategy[Example_co]]], settings_kwargs: Optional[Dict[str, Any]] = ..., type_strategies: Optional[Dict[Type[object], Union[SearchStrategy[Any], Callable[[Type[Any]], SearchStrategy[Any]]]]] = ...) -> None
-    main:6: note:     def [Example_co] check_all_laws(container_type: Type[Lawful[Example_co]], *, settings_kwargs: Optional[Dict[str, Any]] = ..., use_init: bool = ...) -> None
+    main:6: note:     def [Example_co] check_all_laws(container_type: type[Lawful[Example_co]], *, container_strategy: SearchStrategy[Example_co] | Callable[[type[Example_co]], SearchStrategy[Example_co]], settings_kwargs: dict[str, Any] | None = ..., type_strategies: dict[type[object], SearchStrategy[Any] | Callable[[type[Any]], SearchStrategy[Any]]] | None = ...) -> None
+    main:6: note:     def [Example_co] check_all_laws(container_type: type[Lawful[Example_co]], *, settings_kwargs: dict[str, Any] | None = ..., use_init: bool = ...) -> None

typesafety/test_curry/test_curry/test_curry_arguments.yml

@@ -58,8 +58,6 @@
     reveal_type(MyClass(test))  # N: Revealed type is "main.MyClass[Overload(def (a: builtins.int) -> Overload(def (b: builtins.int, c: builtins.str) -> builtins.int, def (b: builtins.int) -> def (c: builtins.str) -> builtins.int), def (a: builtins.int, b: builtins.int) -> def (c: builtins.str) -> builtins.int, def (a: builtins.int, b: builtins.int, c: builtins.str) -> builtins.int)]"
 
 
-# TODO: remove skip after this bug in `mypy` is fixed:
-# https://github.com/python/mypy/issues/8801
 - case: curry_init_magic_method
   disable_cache: false
   skip: true
@@ -71,7 +69,7 @@
         def __init__(self, arg: int, other: str) -> None:
             ...
 
-    reveal_type(Test)  # N: Revealed type is "Overload(def (arg: builtins.int) -> def (other: builtins.str) -> ex.Test, def (arg: builtins.int, other: builtins.str) -> ex.Test)"
+    reveal_type(Test)  # N: Revealed type is "Overload(def () -> main.Test, def (arg: builtins.int) -> main.Test, def (arg: builtins.int, other: builtins.str) -> main.Test)"
 
 
 - case: curry_call_magic_method

typesafety/test_curry/test_curry/test_curry_generics.yml

@@ -57,10 +57,9 @@
     reveal_type(zero(1, y))  # N: Revealed type is "builtins.str"
 
 
-# TODO: enable and fix our plugin
 - case: curry_two_generic_args3
   disable_cache: false
-  skip: True
+  skip: true
   main: |
     from returns.curry import curry
     from typing import List, TypeVar
@@ -74,6 +73,6 @@
     x: List[int]
 
     reveal_type(zero)  # N: Revealed type is "Overload(def [T] (arg: T`-1) -> def [T] (other: builtins.list[T`-1]) -> T`-1, def [T] (arg: T`-1, other: builtins.list[T`-1]) -> T`-1)"
-    reveal_type(zero(1))  # N: Revealed type is "def [T] (other: builtins.list[builtins.int]) -> builtins.int"
+    reveal_type(zero(1))  # N: Revealed type is "def [T] (other: builtins.list[T`2]) -> T`2"
     reveal_type(zero(1)(x))  # N: Revealed type is "builtins.int"
     reveal_type(zero(1, x))  # N: Revealed type is "builtins.int"

typesafety/test_curry/test_partial/test_partial_arguments.yml

@@ -140,7 +140,7 @@
     # This does not work as well:
     reveal_type(partial(x, 1))
   out: |
-    main:13: note: Revealed type is "Union[main.Inst, main.Other]"
+    main:13: note: Revealed type is "main.Inst | main.Other"
     main:15: note: Revealed type is "def (*Any, **Any)"
 
 

typesafety/test_curry/test_partial/test_partial_generic.yml

@@ -18,7 +18,7 @@
     reveal_type(partial(multiple, x)(y))
   out: |
     main:15: note: Revealed type is "builtins.int"
-    main:15: error: Argument 1 to "multiple" has incompatible type "List[str]"; expected "List[int]"  [arg-type]
+    main:15: error: Argument 1 to "multiple" has incompatible type "list[str]"; expected "list[int]"  [arg-type]
 
 
 - case: partial_correct_generic
@@ -79,7 +79,6 @@
     main:22: note: Revealed type is "builtins.int"
 
 
-# Python3.8+ sorts generic arguments differently:
 - case: partial_double_generic_complex38
   disable_cache: false
   main: |
@@ -107,12 +106,12 @@
     reveal_type(partial(multiple, 1, b=y))
     reveal_type(partial(multiple, 1, c=y))
   out: |
-    main:18: note: Revealed type is "def [B, A] (a: builtins.int, *, b: builtins.list[B`-1], c: builtins.list[A`-2]) -> Union[A`-2, B`-1]"
-    main:19: note: Revealed type is "def [B, A] (*, b: builtins.list[B`-1], c: builtins.list[A`-2]) -> Union[A`-2, B`-1]"
-    main:20: note: Revealed type is "def [A] (*, c: builtins.list[A`-2]) -> Union[A`-2, builtins.int]"
-    main:21: note: Revealed type is "def [B] (*, b: builtins.list[B`-1]) -> Union[builtins.int, B`-1]"
-    main:22: note: Revealed type is "def [A] (*, c: builtins.list[A`-2]) -> Union[A`-2, builtins.str]"
-    main:23: note: Revealed type is "def [B] (*, b: builtins.list[B`-1]) -> Union[builtins.str, B`-1]"
+    main:18: note: Revealed type is "def [B, A] (a: builtins.int, *, b: builtins.list[B`-1], c: builtins.list[A`-2]) -> A`-2 | B`-1"
+    main:19: note: Revealed type is "def [B, A] (*, b: builtins.list[B`-1], c: builtins.list[A`-2]) -> A`-2 | B`-1"
+    main:20: note: Revealed type is "def [A] (*, c: builtins.list[A`-2]) -> A`-2 | builtins.int"
+    main:21: note: Revealed type is "def [B] (*, b: builtins.list[B`-1]) -> builtins.int | B`-1"
+    main:22: note: Revealed type is "def [A] (*, c: builtins.list[A`-2]) -> A`-2 | builtins.str"
+    main:23: note: Revealed type is "def [B] (*, b: builtins.list[B`-1]) -> builtins.str | B`-1"
 
 
 - case: partial_double_generic
@@ -139,6 +138,6 @@
     reveal_type(partial(multiple, 1, b=x)(c=y))
     reveal_type(partial(multiple, 1, c=x)(b=y))
   out: |
-    main:17: note: Revealed type is "def () -> Union[builtins.str, builtins.int]"
-    main:19: note: Revealed type is "Union[builtins.str, builtins.int]"
-    main:20: note: Revealed type is "Union[builtins.int, builtins.str]"
+    main:17: note: Revealed type is "def () -> builtins.str | builtins.int"
+    main:19: note: Revealed type is "builtins.str | builtins.int"
+    main:20: note: Revealed type is "builtins.int | builtins.str"

typesafety/test_curry/test_partial/test_partial_overload.yml

@@ -161,11 +161,11 @@
     reveal_type(partial(two_args, a, b))
     reveal_type(partial(two_args, b, a))
   out: |
-    main:25: note: Revealed type is "Overload(def [A] (a: builtins.int, b: builtins.list[A`-1]) -> A`-1, def [B] (a: builtins.int, b: builtins.list[B`-1]) -> B`-1, def [A, B] (a: builtins.list[A`-1], b: builtins.list[B`-2]) -> Union[A`-1, B`-2])"
+    main:25: note: Revealed type is "Overload(def [A] (a: builtins.int, b: builtins.list[A`-1]) -> A`-1, def [B] (a: builtins.int, b: builtins.list[B`-1]) -> B`-1, def [A, B] (a: builtins.list[A`-1], b: builtins.list[B`-2]) -> A`-1 | B`-2)"
     main:26: note: Revealed type is "Overload(def [A] (b: builtins.list[A`-1]) -> A`-1, def [B] (b: builtins.list[B`-1]) -> B`-1)"
     main:27: note: Revealed type is "Overload(def () -> builtins.float, def () -> builtins.float)"
     main:28: note: Revealed type is "Overload(def () -> builtins.str, def () -> builtins.str)"
-    main:29: note: Revealed type is "def [B] (b: builtins.list[B`-2]) -> Union[builtins.float, B`-2]"
-    main:30: note: Revealed type is "def [B] (b: builtins.list[B`-2]) -> Union[builtins.str, B`-2]"
-    main:31: note: Revealed type is "def () -> Union[builtins.float, builtins.str]"
-    main:32: note: Revealed type is "def () -> Union[builtins.str, builtins.float]"
+    main:29: note: Revealed type is "def [B] (b: builtins.list[B`-2]) -> builtins.float | B`-2"
+    main:30: note: Revealed type is "def [B] (b: builtins.list[B`-2]) -> builtins.str | B`-2"
+    main:31: note: Revealed type is "def () -> builtins.float | builtins.str"
+    main:32: note: Revealed type is "def () -> builtins.str | builtins.float"

typesafety/test_examples/test_your_container/test_pair4_def.yml

@@ -1,16 +1,8 @@
 - case: test_pair_type
   disable_cache: false
   env:
-    # We only need this because we store this example in `tests/`
-    # and not in our source code. Please, do not copy this line!
-    - MYPYPATH=./tests/test_examples/test_your_container
-
-  # TODO: remove this config after
-  #     mypy/typeshed/stdlib/unittest/mock.pyi:120:
-  #     error: Class cannot subclass "Any" (has type "Any")
-  # is fixed.
-  mypy_config:
-    disallow_subclassing_any = False
+  - MYPYPATH=./tests/test_examples/test_your_container
+  mypy_config: disallow_subclassing_any = False
   main: |
     # Let's import our `Pair` type we defined earlier:
     from test_pair4 import Pair
@@ -23,5 +15,5 @@
     my_pair: Pair[int, str] = Pair.from_paired(1, 'a')
     reveal_type(my_pair.pair(function))
   out: |
-    main:4: note: Revealed type is "def [_FirstType, _SecondType] (inner_value: Tuple[_FirstType`1, _SecondType`2]) -> test_pair4.Pair[_FirstType`1, _SecondType`2]"
-    main:10: note: Revealed type is "test_pair4.Pair[builtins.float, builtins.bool]"
+    main:4: note: Revealed type is "Any"
+    main:10: note: Revealed type is "Any"

typesafety/test_examples/test_your_container/test_pair4_reuse.yml

@@ -1,16 +1,8 @@
 - case: test_pair_map
   disable_cache: false
   env:
-    # We only need this because we store this example in `tests/`
-    # and not in our source code. Please, do not copy this line!
-    - MYPYPATH=./tests/test_examples/test_your_container
-
-  # TODO: remove this config after
-  #     mypy/typeshed/stdlib/unittest/mock.pyi:120:
-  #     error: Class cannot subclass "Any" (has type "Any")
-  # is fixed.
-  mypy_config:
-    disallow_subclassing_any = False
+  - MYPYPATH=./tests/test_examples/test_your_container
+  mypy_config: disallow_subclassing_any = False
   main: |
     from test_pair4 import Pair
     from returns.pointfree import map_
@@ -19,5 +11,5 @@
     reveal_type(my_pair.map(str))
     reveal_type(map_(str)(my_pair))
   out: |
-    main:5: note: Revealed type is "test_pair4.Pair[builtins.str, builtins.int]"
-    main:6: note: Revealed type is "test_pair4.Pair[builtins.str, builtins.int]"
+    main:5: note: Revealed type is "Any"
+    main:6: note: Revealed type is "Any"

typesafety/test_functions/test_compose.yml

@@ -29,8 +29,7 @@
 
 
 - case: compose_optional_functions
-  mypy_config:
-    no_implicit_optional = True
+  mypy_config: no_implicit_optional = True
   main: |
     from returns.functions import compose
 

typesafety/test_future/test_future_container/test_asyncify_decorator.yml

@@ -10,4 +10,4 @@
     ) -> int:
         return 1
 
-    reveal_type(test)  # N: Revealed type is "def (first: builtins.int, second: Union[builtins.str, None] =, *, kw: builtins.bool =) -> typing.Coroutine[Any, Any, builtins.int]"
+    reveal_type(test)  # N: Revealed type is "def (first: builtins.int, second: builtins.str | None =, *, kw: builtins.bool =) -> typing.Coroutine[Any, Any, builtins.int]"