chore: finish

Author: GreyElaina

challenges/advance-descriptor-basic/question.py

@@ -9,30 +9,18 @@ class Descriptor:
     ...
 
 
-def should_pass():
-    class TestClass:
-        a = Descriptor()
-    
-    def descriptor_self(x: Descriptor) -> None:
-        ...
-
-    def string_value(x: str) -> None:
-        ...
-    
-    descriptor_self(TestClass.a)
-    string_value(TestClass().a)
-
+## End of your code ##
+class TestClass:
+    a = Descriptor()
 
-def should_fail():
-    class TestClass:
-        a = Descriptor()
-    
-    def descriptor_self(x: Descriptor) -> None:
-        ...
+def descriptor_self(x: Descriptor) -> None:
+    ...
 
-    def string_value(x: str) -> None:
-        ...
+def string_value(x: str) -> None:
+    ...
 
-    descriptor_self(TestClass().a)
-    string_value(TestClass.a)
+descriptor_self(TestClass.a)
+string_value(TestClass().a)
 
+descriptor_self(TestClass().a)  # expect-type-error
+string_value(TestClass.a)  # expect-type-error

challenges/advance-descriptor-basic/solution.py

@@ -0,0 +1,39 @@
+"""
+TODO:
+
+Define a descriptor, make test case works.
+"""
+
+from typing import overload, Self, Any
+
+class Descriptor:
+    @overload
+    def __get__(self, instance: None, owner: type) -> Self:
+        ...
+    
+    @overload
+    def __get__(self, instance: Any, owner: type) -> str:
+        ...
+    
+    def __get__(self, instance: Any, owner: type) -> Self | str:
+        if instance is None:
+            return self
+    
+        return ""
+
+
+## End of your code ##
+class TestClass:
+    a = Descriptor()
+
+def descriptor_self(x: Descriptor) -> None:
+    ...
+
+def string_value(x: str) -> None:
+    ...
+    
+descriptor_self(TestClass.a)
+string_value(TestClass().a)
+
+descriptor_self(TestClass().a)  # expect-type-error
+string_value(TestClass.a)  # expect-type-error

challenges/advance-my-method/question.py

@@ -17,27 +17,18 @@ def __get__(self, instance, owner) -> None:
         return
 
 
+## End of your code ##
+class Foo:
+    @MyMethod
+    def do_something(self, value: int) -> None:
+        ...
 
-def should_pass():
-    class Foo:
-        @MyMethod
-        def do_something(self, value: int) -> None:
-            ...
+foo = Foo()
 
-    foo = Foo()
+Foo.do_something(foo, 1111)
+foo.do_something(1111)
 
-    Foo.do_something(foo, 1111)
-    foo.do_something(1111)
 
-
-def should_fail():
-    class Foo:
-        @MyMethod
-        def do_something(self, value: int) -> None:
-            ...
-
-    foo = Foo()
-
-    Foo.do_something(1111)
-    foo.do_something(11111, foo)
-    foo.do_something(foo, 11111)
+Foo.do_something(1111)  # expect-type-error
+foo.do_something(11111, foo)  # expect-type-error
+foo.do_something(foo, 11111)  # expect-type-error

challenges/advance-my-method/solution.py

@@ -0,0 +1,48 @@
+"""
+TODO:
+
+a method-like descriptor, implements the `__get__` only.
+"""
+from typing import Any, ParamSpec, TypeVar, Concatenate, Callable, Generic, overload
+
+P = ParamSpec("P")
+T = TypeVar("T")
+R = TypeVar("R")
+
+class MyMethod(Generic[T, P, R]):
+    def __init__(self, func: Callable[Concatenate[T, P], R]) -> None:
+        self.func = func
+    
+    @overload
+    def __get__(self, instance: None, owner: type) -> Callable[Concatenate[T, P], R]:
+        ...
+    
+    @overload
+    def __get__(self, instance: Any, owner: type) -> Callable[P, R]:
+        ...
+    
+    def __get__(self, instance: Any | None, owner: type):
+        if instance is None:
+            return self.func
+
+        def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+            return self.func(instance, *args, **kwargs)
+    
+        return wrapper
+
+
+## End of your code ##
+class Foo:
+    @MyMethod
+    def do_something(self, value: int) -> None:
+        ...
+
+foo = Foo()
+
+Foo.do_something(foo, 1111)
+foo.do_something(1111)
+
+
+Foo.do_something(1111)  # expect-type-error
+foo.do_something(11111, foo)  # expect-type-error
+foo.do_something(foo, 11111)  # expect-type-error

challenges/extreme-self-casting/question.py

@@ -16,24 +16,16 @@ def __init__(self, f: VnCallable) -> None:
     def into_callable(self) -> None:
         ...
 
+## End of your code ##
+@Fn
+def example(a: int, b: str, c: float, *, d: bool = False) -> None:
+    return
 
-def should_pass():
-    @Fn
-    def example(a: int, b: str, c: float, *, d: bool = False) -> None:
-        return
 
-    assert_type(example.f(1, "1", 1., d=False), None)
+assert_type(example.f(1, "1", 1., d=False), None)
 
-    a: Any = 11111111
+a: Any = 11111111
+b = example.into_callable()(a, 1, "1", 1., d=False)
+assert_type(b, None)
 
-    b = example.into_callable()(a, 1, "1", 1., d=False)
-
-    assert_type(b, None)
-
-
-def should_fail():
-    @Fn
-    def example(a: int, b: str, c: float, *, d: bool = False) -> None:
-        ...
-
-    example.into_callable()(1, "1", 1., d=False)
+example.into_callable()(1, "1", 1., d=False)  # expect-type-error

challenges/extreme-self-casting/solution.py

@@ -0,0 +1,33 @@
+"""
+TODO:
+
+make Fn[VnCallable] could be casted to a Callable with a Any value.
+you MUST NOT modify anything expect the `Fn.into_callable`'s annotation.
+"""
+
+from typing import Callable, Concatenate, ParamSpec, TypeVar, Generic, Any, assert_type
+
+P = ParamSpec("P")
+R = TypeVar("R", covariant=True)
+VnCallable = TypeVar("VnCallable", bound=Callable)
+
+class Fn(Generic[VnCallable]):
+    def __init__(self, f: VnCallable) -> None:
+        self.f = f
+
+    def into_callable(self: 'Fn[Callable[P, R]]') -> Callable[Concatenate[Any, P], R]:
+        ...
+
+## End of your code ##
+@Fn
+def example(a: int, b: str, c: float, *, d: bool = False) -> None:
+    return
+
+
+assert_type(example.f(1, "1", 1., d=False), None)
+
+a: Any = 11111111
+b = example.into_callable()(a, 1, "1", 1., d=False)
+assert_type(b, None)
+
+example.into_callable()(1, "1", 1., d=False)  # expect-type-error