update from O'Reilly repo

15-type-hints/erp.py

@@ -0,0 +1,14 @@
+import random
+from typing import TypeVar, Generic, List, Iterable
+
+
+T = TypeVar('T')
+
+
+class EnterpriserRandomPopper(Generic[T]):
+    def __init__(self, items: Iterable[T]) -> None:
+        self._items: List[T] = list(items)
+        random.shuffle(self._items)
+
+    def pop_random(self) -> T:
+        return self._items.pop()

15-type-hints/erp_test.py

@@ -0,0 +1,38 @@
+import random
+from typing import Iterable, TYPE_CHECKING, List
+
+from erp import EnterpriserRandomPopper
+import randompop
+
+
+def test_issubclass() -> None:
+    assert issubclass(EnterpriserRandomPopper, randompop.RandomPopper)
+
+
+
+def test_isinstance_untyped_items_argument() -> None:
+    items = [1, 2, 3]
+    popper = EnterpriserRandomPopper(items)  # [int] is not required
+    if TYPE_CHECKING:
+        reveal_type(popper)
+        # Revealed type is 'erp.EnterpriserRandomPopper[builtins.int*]'
+    assert isinstance(popper, randompop.RandomPopper)
+
+
+def test_isinstance_untyped_items_in_var_type() -> None:
+    items = [1, 2, 3]
+    popper: EnterpriserRandomPopper = EnterpriserRandomPopper[int](items)
+    if TYPE_CHECKING:
+        reveal_type(popper)
+        # Revealed type is 'erp.EnterpriserRandomPopper[Any]'
+    assert isinstance(popper, randompop.RandomPopper)
+
+
+def test_isinstance_item() -> None:
+    items = [1, 2, 3]
+    popper = EnterpriserRandomPopper[int](items)  # [int] is not required
+    popped = popper.pop_random()
+    if TYPE_CHECKING:
+        reveal_type(popped)
+        # Revealed type is 'builtins.int*'
+    assert isinstance(popped, int)

15-type-hints/randompick_generic.py

@@ -0,0 +1,7 @@
+from typing import Protocol, runtime_checkable, TypeVar
+
+T_co = TypeVar('T_co', covariant=True)
+
+@runtime_checkable
+class GenericRandomPicker(Protocol[T_co]):
+    def pick(self) -> T_co: ...

15-type-hints/randompick_generic_test.py

@@ -0,0 +1,35 @@
+import random
+from typing import Iterable, TYPE_CHECKING
+
+from randompick_generic import GenericRandomPicker
+
+
+class LottoPicker():
+    def __init__(self, items: Iterable[int]) -> None:
+        self._items = list(items)
+        random.shuffle(self._items)
+
+    def pick(self) -> int:
+        return self._items.pop()
+
+
+def test_issubclass() -> None:
+    assert issubclass(LottoPicker, GenericRandomPicker)
+
+
+def test_isinstance() -> None:
+    popper: GenericRandomPicker = LottoPicker([1])
+    if TYPE_CHECKING:
+        reveal_type(popper)
+        # Revealed type is '???'
+    assert isinstance(popper, LottoPicker)
+
+
+def test_pick_type() -> None:
+    balls = [1, 2, 3]
+    popper = LottoPicker(balls)
+    pick = popper.pick()
+    assert pick in balls
+    if TYPE_CHECKING:
+        reveal_type(pick)
+        # Revealed type is '???'

15-type-hints/randompop.py

@@ -0,0 +1,6 @@
+from typing import Protocol, TypeVar, runtime_checkable, Any
+
+
+@runtime_checkable
+class RandomPopper(Protocol):
+    def pop_random(self) -> Any: ...

15-type-hints/randompop_test.py

@@ -0,0 +1,24 @@
+from randompop import RandomPopper
+import random
+from typing import Any, Iterable, TYPE_CHECKING
+
+
+class SimplePopper():
+    def __init__(self, items: Iterable) -> None:
+        self._items = list(items)
+        random.shuffle(self._items)
+
+    def pop_random(self) -> Any:
+        return self._items.pop()
+
+
+def test_issubclass() -> None:
+    assert issubclass(SimplePopper, RandomPopper)
+
+
+def test_isinstance() -> None:
+    popper: RandomPopper = SimplePopper([1])
+    if TYPE_CHECKING:
+        reveal_type(popper)
+        # Revealed type is 'randompop.RandomPopper'
+    assert isinstance(popper, RandomPopper)