feat: improve the layout and judgement of challenges, to make it more strict (laike9m#10)

Author: frostming

.github/workflows/test.yaml

@@ -0,0 +1,22 @@
+name: Unit Test
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up PDM
+        uses: pdm-project/setup-pdm@v3
+        with:
+          python-version: 3.12
+          cache: true
+      - name: Install dependencies
+        run: pdm install
+
+      - name: Run tests
+        run: pdm run pytest

challenges/advanced-callable-protocol/question.py

@@ -0,0 +1,33 @@
+"""
+TODO:
+
+Define a callable type that accepts a string parameter called `name` and returns None.
+
+HINT: Use Protocol
+"""
+
+
+class SingleStringInput:
+    ...
+
+
+## End of your code ##
+def accept_single_string_input(func: SingleStringInput) -> None:
+    func(name="name")
+
+
+def string_name(name: str) -> None:
+    ...
+
+
+def string_value(value: str) -> None:
+    ...
+
+
+def return_string(name: str) -> str:
+    return name
+
+
+accept_single_string_input(string_name)
+accept_single_string_input(string_value)  # expect-type-error
+accept_single_string_input(return_string)  # expect-type-error

challenges/advanced-callable/question.py

@@ -15,11 +15,10 @@ def unwrap(self):
         return self.value
 
 
-def should_pass(w: Box[str]):
-    a: str = w.unwrap()
-    b: int = Box(1).unwrap()
+## End of your code ##
+from typing import assert_type
 
 
-def should_fail(w: Box[str]):
-    a: int = w.unwrap()
-    b: str = Box(1).unwrap()
+def should_pass(w: Box[str]):
+    assert_type(w.unwrap(), str)
+    assert_type(Box(1).unwrap(), int)

challenges/advanced-generic-param/question.py

@@ -9,11 +9,15 @@ def foo(value=None):
     ...
 
 
+## End of your code ##
+from typing import assert_type
+
+
 def should_pass():
-    foo(42).upper()
-    foo().bit_length()
+    assert_type(foo(42), str)
+    assert_type(foo(), int)
 
 
 def should_fail():
-    foo(42).bit_length()
-    foo().upper()
+    assert_type(foo(42), int)  # expect-type-error
+    assert_type(foo(), str)  # expect-type-error

challenges/advanced-overload/question.py

@@ -9,7 +9,7 @@
 class SupportsQuack:
     ...
 
-
+## End of your code ##
 class Duck:
     def quack(self) -> None:
         print("quack!")
@@ -20,9 +20,5 @@ def bark(self) -> None:
         print("bark!")
 
 
-def should_pass():
-    duck: SupportsQuack = Duck()
-
-
-def should_fail():
-    dog: SupportsQuack = Dog()
+duck: SupportsQuack = Duck()
+dog: SupportsQuack = Dog()  # expect-type-error

challenges/advanced-protocol/question.py

@@ -4,19 +4,20 @@
 Define a `Tree` type. `Tree` is a dictionary, whose keys are string, values are also `Tree`.
 """
 
+Tree = ...
 
+
+## End of your code ##
 def f(t: Tree):
     pass
 
 
-def should_pass():
-    f({})
-    f({"foo": {}})
-    f({"foo": {"bar": {}}})
-    f({"foo": {"bar": {"baz": {}}}})
+f({})
+f({"foo": {}})
+f({"foo": {"bar": {}}})
+f({"foo": {"bar": {"baz": {}}}})
 
 
-def should_fail():
-    f(1)
-    f({"foo": []})
-    f({"foo": {1: {}}})
+f(1)  # expect-type-error
+f({"foo": []})  # expect-type-error
+f({"foo": {1: {}}})  # expect-type-error

challenges/advanced-recursive/question.py

@@ -12,6 +12,7 @@ def return_self(self):
         return self
 
 
+## End of your code ##
 class SubclassOfFoo(Foo):
     pass
 
@@ -22,4 +23,4 @@ def should_pass():
 
 
 def should_fail():
-    sf: SubclassOfFoo = Foo().return_self()
+    sf: SubclassOfFoo = Foo().return_self()  # expect-type-error

challenges/advanced-self/question.py

@@ -13,13 +13,11 @@ def is_string(value: Any):
     ...
 
 
-def should_pass():
-    a: str | None = "hello"
-    if is_string(a):
-        a.strip()
+## End of your code ##
+from typing import assert_type
 
-
-def should_fail():
-    a: str | None = "hello"
-    if not is_string(a):
-        a.strip()
+a: str | None = "hello"
+if is_string(a):
+    assert_type(a, str)
+else:
+    assert_type(a, type(None))

challenges/advanced-typeguard/question.py

@@ -4,17 +4,12 @@
 foo should accept an argument of arbitrary type.
 """
 
-import typing
-
 
 def foo(x):
     pass
 
 
-def should_pass():
-    foo(1)
-    foo("10")
-
-
-def should_fail():
-    foo(1, 2)
+## End of your code ##
+foo(1)
+foo("10")
+foo(1, 2)  # expect-type-error