Migrate old challenges and solutions to the new layout laike9m#10

Author: laike9m

challenges/advanced-overload-generic/question.py

@@ -5,22 +5,25 @@
 """
 from typing import TypeVar, Generic
 
-T = TypeVar('T')
+T = TypeVar("T")
+
 
 class Foo(Generic[T]):
     a: T
 
+
 def foo(value: Foo):
     ...
 
 
-def should_pass():
-    foo(Foo[int]()).bit_length()
-    foo(Foo[str]()).upper()
-    foo(Foo[list]()).a.append(1)
+## End of your code ##
+
+
+foo(Foo[int]()).bit_length()
+foo(Foo[str]()).upper()
+foo(Foo[list]()).a.append(1)
 
 
-def should_fail():
-    foo(Foo[int]()).upper()
-    foo(Foo[str]()).bit_length()
-    foo(Foo[list]()).bit_length()
+foo(Foo[int]()).upper()  # expect-type-error
+foo(Foo[str]()).bit_length()  # expect-type-error
+foo(Foo[list]()).bit_length()  # expect-type-error

challenges/advanced-overload-generic/solution.py

@@ -5,34 +5,38 @@
 """
 from typing import Any, TypeVar, Generic, overload
 
-T = TypeVar('T')
+T = TypeVar("T")
+
 
 class Foo(Generic[T]):
     a: T
 
+
 @overload
 def foo(value: Foo[int]) -> int:
     ...
 
+
 @overload
 def foo(value: Foo[str]) -> str:
     ...
 
+
 @overload
 def foo(value: Foo[T]) -> Foo[T]:
     ...
 
+
 def foo(value: Foo) -> Any:
     ...
 
 
-def should_pass():
-    foo(Foo[int]()).bit_length()
-    foo(Foo[str]()).upper()
-    foo(Foo[list]()).a.append(1)
+## End of your code ##
 
+foo(Foo[int]()).bit_length()
+foo(Foo[str]()).upper()
+foo(Foo[list]()).a.append(1)
 
-def should_fail():
-    foo(Foo[int]()).upper()
-    foo(Foo[str]()).bit_length()
-    foo(Foo[list]()).bit_length()
+foo(Foo[int]()).upper()  # expect-type-error
+foo(Foo[str]()).bit_length()  # expect-type-error
+foo(Foo[list]()).bit_length()  # expect-type-error

challenges/advanced-overload-literal/question.py

@@ -9,15 +9,14 @@ def foo(value, flag):
     ...
 
 
-def should_pass():
-    foo("42", 1).bit_length()
-    foo(42, 2).upper()
-    foo(True, 3).append(1)
-    foo({}, "4").keys()
+## End of your code ##
 
+foo("42", 1).bit_length()
+foo(42, 2).upper()
+foo(True, 3).append(1)
+foo({}, "4").keys()
 
-def should_fail():
-    foo("42", 1).upper()
-    foo(42, 2).append(1)
-    foo(True, 3).bit_length()
-    foo({}, "4").upper()
+foo("42", 1).upper()  # expect-type-error
+foo(42, 2).append(1)  # expect-type-error
+foo(True, 3).bit_length()  # expect-type-error
+foo({}, "4").upper()  # expect-type-error

challenges/advanced-overload-literal/solution.py

@@ -5,20 +5,24 @@
 """
 from typing import Any, Literal, overload, TypeVar
 
-T = TypeVar('T')
+T = TypeVar("T")
+
 
 @overload
 def foo(value: Any, flag: Literal[1]) -> int:
     ...
 
+
 @overload
 def foo(value: Any, flag: Literal[2]) -> str:
     ...
 
+
 @overload
 def foo(value: Any, flag: Literal[3]) -> list:
     ...
 
+
 @overload
 def foo(value: T, flag: Any) -> T:
     ...
@@ -28,15 +32,15 @@ def foo(value, flag) -> Any:
     ...
 
 
-def should_pass():
-    foo("42", 1).bit_length()
-    foo(42, 2).upper()
-    foo(True, 3).append(1)
-    foo({}, "4").keys()
+## End of your code ##
+
+foo("42", 1).bit_length()
+foo(42, 2).upper()
+foo(True, 3).append(1)
+foo({}, "4").keys()
 
 
-def should_fail():
-    foo("42", 1).upper()
-    foo(42, 2).append(1)
-    foo(True, 3).bit_length()
-    foo({}, "4").upper()
+foo("42", 1).upper()  # expect-type-error
+foo(42, 2).append(1)  # expect-type-error
+foo(True, 3).bit_length()  # expect-type-error
+foo({}, "4").upper()  # expect-type-error

challenges/extreme-constructor-parameter/question.py

@@ -2,35 +2,40 @@
 TODO:
 
 Define a decorator `constructor_parameter` that accepts the type of Foo.
-and return a wrapper function with the same signature as the constructor of Foo, 
+and return a wrapper function with the same signature as the constructor of Foo,
 and function decorated by `constructor_parameter` can be called with an instance of Foo.
 """
 
+
 class Foo:
     a: int
     b: str
 
     def __init__(self, a: int, b: str) -> None:
         ...
 
+
 def constructor_parameter():
     ...
 
 
-def should_pass():
-    @constructor_parameter(Foo)
-    def func(foo: Foo) -> list[Foo]:
-        ...
+## End of your code ##
 
-    res = func(1, "2")
-    res[0].a.bit_length()
-    res[0].b.upper()
 
+@constructor_parameter(Foo)
+def func_pass(foo: Foo) -> list[Foo]:
+    ...
+
+
+res = func_pass(1, "2")
+res[0].a.bit_length()
+res[0].b.upper()
+
+
+@constructor_parameter(Foo)
+def func_fail(foo: Foo) -> list:
+    ...
 
-def should_fail():
-    @constructor_parameter(Foo)
-    def func(foo: Foo) -> list:
-        ...
 
-    func("1", "2")
-    func([1, 2, 3])
+func_fail("1", "2")  # expect-type-error
+func_fail([1, 2, 3])  # expect-type-error

challenges/extreme-constructor-parameter/solution.py

@@ -2,42 +2,47 @@
 TODO:
 
 Define a decorator `constructor_parameter` that accepts the type of Foo.
-and return a wrapper function with the same signature as the constructor of Foo, 
+and return a wrapper function with the same signature as the constructor of Foo,
 and function decorated by `constructor_parameter` can be called with an instance of Foo.
 """
 from typing import TypeVar, Callable
 from typing_extensions import ParamSpec, Concatenate
 
+
 class Foo:
     a: int
     b: str
 
     def __init__(self, a: int, b: str) -> None:
         ...
 
-T = TypeVar('T')
-P = ParamSpec('P')
-R = TypeVar('R')
+
+T = TypeVar("T")
+P = ParamSpec("P")
+R = TypeVar("R")
 
 
-def constructor_parameter(cls: Callable[P, T]) -> Callable[[Callable[[T], R]], Callable[P, R]]:
+def constructor_parameter(
+    cls: Callable[P, T]
+) -> Callable[[Callable[[T], R]], Callable[P, R]]:
     ...
 
 
-def should_pass():
-    @constructor_parameter(Foo)
-    def func(foo: Foo) -> list[Foo]:
-        ...
+## End of your code ##
+@constructor_parameter(Foo)
+def func_pass(foo: Foo) -> list[Foo]:
+    ...
 
-    res = func(1, "2")
-    res[0].a.bit_length()
-    res[0].b.upper()
 
+res = func_pass(1, "2")
+res[0].a.bit_length()
+res[0].b.upper()
+
+
+@constructor_parameter(Foo)
+def func_fail(foo: Foo) -> list:
+    ...
 
-def should_fail():
-    @constructor_parameter(Foo)
-    def func(foo: Foo) -> list:
-        ...
 
-    func("1", "2")
-    func([1, 2, 3])
+func_fail("1", "2")  # expect-type-error
+func_fail([1, 2, 3])  # expect-type-error

views/utils.py

@@ -90,11 +90,13 @@ def _load_challenges() -> dict[ChallengeName, Challenge]:
     @classmethod
     def _type_check_with_mypy(cls, code: str) -> TypeCheckResult:
         buffer = io.StringIO(code)
+
         # This produces a stream of TokenInfos, example:
         # TokenInfo(type=4 (NEWLINE), string='\n', start=(4, 3), end=(4, 4), line='"""\n'),
         # TokenInfo(type=62 (NL), string='\n', start=(5, 0), end=(5, 1), line='\n')
         # See https://docs.python.org/3/library/tokenize.html#tokenize.tokenize for more details
         tokens = list(tokenize.generate_tokens(buffer.readline))
+
         # Find all lines that are followed by a comment # expect-type-error
         expect_error_line_numbers = [
             token.start[0]