ch15: draft examples

ramalho · ramalho · commit 1689eec623a0 · 2021-05-20T22:58:05.000-03:00
diff --git a/15-more-types/cafeteria/cafeteria.py b/15-more-types/cafeteria/cafeteria.py
@@ -0,0 +1,41 @@
+from typing import TypeVar, Generic
+
+
+class Beverage:
+    """Any beverage"""
+
+
+class Juice(Beverage):
+    """Any fruit juice"""
+
+
+class OrangeJuice(Juice):
+    """Delicious juice Brazilian oranges"""
+
+
+class Coak(Beverage):
+    """Secret formula with lots of sugar"""
+
+
+BeverageT = TypeVar('BeverageT', bound=Beverage)
+JuiceT = TypeVar('JuiceT', bound=Juice)
+
+
+class BeverageDispenser(Generic[BeverageT]):
+
+    beverage: BeverageT
+
+    def __init__(self, beverage: BeverageT) -> None:
+        self.beverage = beverage
+
+    def dispense(self) -> BeverageT:
+        return self.beverage
+
+
+class JuiceDispenser(BeverageDispenser[JuiceT]):
+    pass
+
+
+class Cafeteria:
+    def __init__(self, dispenser: BeverageDispenser[JuiceT]):
+        self.dispenser = dispenser
diff --git a/15-more-types/cafeteria/cafeteria_demo.py b/15-more-types/cafeteria/cafeteria_demo.py
@@ -0,0 +1,23 @@
+from cafeteria import (
+    Cafeteria,
+    BeverageDispenser,
+    JuiceDispenser,
+    Juice,
+    OrangeJuice,
+    Coak,
+)
+
+orange = OrangeJuice()
+
+orange_dispenser: JuiceDispenser[OrangeJuice] = JuiceDispenser(orange)
+
+juice: Juice = orange_dispenser.dispense()
+
+soda = Coak()
+
+## Value of type variable "JuiceT" of "JuiceDispenser" cannot be "Coak"
+# soda_dispenser = JuiceDispenser(soda)
+
+soda_dispenser = BeverageDispenser(soda)
+
+arnold_hall = Cafeteria(soda_dispenser)
diff --git a/15-more-types/collections_variance.py b/15-more-types/collections_variance.py
@@ -0,0 +1,16 @@
+from collections.abc import Collection, Sequence
+
+col_int: Collection[int]
+
+seq_int: Sequence[int] = (1, 2, 3)
+
+## Incompatible types in assignment
+##   expression has type "Collection[int]"
+##     variable has type "Sequence[int]"
+# seq_int = col_int
+
+col_int = seq_int
+
+## List item 0 has incompatible type "float"
+##   expected "int"
+# col_int = [1.1]
diff --git a/15-more-types/erp.py b/15-more-types/erp.py
diff --git a/15-more-types/erp_test.py b/15-more-types/erp_test.py
@@ -1,5 +1,4 @@
-import random
-from typing import Iterable, TYPE_CHECKING, List
+from typing import TYPE_CHECKING
 
 from erp import EnterpriserRandomPopper
 import randompop
@@ -9,7 +8,6 @@ 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
diff --git a/15-more-types/gen_contra.py b/15-more-types/gen_contra.py
@@ -0,0 +1,59 @@
+"""
+In ``Generator[YieldType, SendType, ReturnType]``,
+``SendType`` is contravariant.
+The other type variables are covariant.
+
+This is how ``typing.Generator`` is declared::
+
+    class Generator(Iterator[T_co], Generic[T_co, T_contra, V_co]):
+
+(from https://docs.python.org/3/library/typing.html#typing.Generator)
+
+"""
+
+from typing import Generator
+
+
+# Generator[YieldType, SendType, ReturnType]
+
+def gen_float_take_int() -> Generator[float, int, str]:
+    received = yield -1.0
+    while received:
+        received = yield float(received)
+    return 'Done'
+
+
+def gen_float_take_float() -> Generator[float, float, str]:
+    received = yield -1.0
+    while received:
+        received = yield float(received)
+    return 'Done'
+
+
+def gen_float_take_complex() -> Generator[float, complex, str]:
+    received = yield -1.0
+    while received:
+        received = yield abs(received)
+    return 'Done'
+
+# Generator[YieldType, SendType, ReturnType]
+
+g0: Generator[float, float, str] = gen_float_take_float()
+
+g1: Generator[complex, float, str] = gen_float_take_float()
+
+## Incompatible types in assignment
+##   expression has type "Generator[float, float, str]"
+##     variable has type "Generator[int, float, str]")
+# g2: Generator[int, float, str] = gen_float_take_float()
+
+
+# Generator[YieldType, SendType, ReturnType]
+
+g3: Generator[float, int, str] = gen_float_take_float()
+
+## Incompatible types in assignment
+##   expression has type "Generator[float, float, str]"
+##     variable has type "Generator[float, complex, str]")
+## g4: Generator[float, complex, str] = gen_float_take_float()
+
diff --git a/15-more-types/petbox/petbox.py b/15-more-types/petbox/petbox.py
@@ -0,0 +1,47 @@
+from typing import TypeVar, Generic, Any
+
+
+class Pet:
+    """Domestic animal kept for companionship."""
+
+
+class Dog(Pet):
+    """Canis familiaris"""
+
+
+class Cat(Pet):
+    """Felis catus"""
+
+
+class Siamese(Cat):
+    """Cat breed from Thailand"""
+
+
+T = TypeVar('T')
+
+
+class Box(Generic[T]):
+    def put(self, item: T) -> None:
+        self.contents = item
+
+    def get(self) -> T:
+        return self.contents
+
+
+T_contra = TypeVar('T_contra', contravariant=True)
+
+
+class InBox(Generic[T_contra]):
+    def put(self, item: T) -> None:
+        self.contents = item
+
+
+T_co = TypeVar('T_co', covariant=True)
+
+
+class OutBox(Generic[T_co]):
+    def __init__(self, contents: Any):
+        self.contents = contents
+
+    def get(self) -> Any:
+        return self.contents
diff --git a/15-more-types/petbox/petbox_demo.py b/15-more-types/petbox/petbox_demo.py
@@ -0,0 +1,42 @@
+from typing import TYPE_CHECKING
+
+from petbox import *
+
+
+cat_box: Box[Cat] = Box()
+
+si = Siamese()
+
+cat_box.put(si)
+
+animal = cat_box.get()
+
+#if TYPE_CHECKING:
+#    reveal_type(animal)  # Revealed: petbox.Cat*
+
+
+################### Covariance
+
+out_box: OutBox[Cat] = OutBox(Cat())
+
+out_box_si: OutBox[Siamese] = OutBox(Siamese())
+
+## Incompatible types in assignment
+##   expression has type "OutBox[Cat]"
+#      variable has type "OutBox[Siamese]"
+# out_box_si = out_box
+
+out_box = out_box_si
+
+################### Contravariance
+
+in_box: InBox[Cat] = InBox()
+
+in_box_si: InBox[Siamese] = InBox()
+
+in_box_si = in_box
+
+## Incompatible types in assignment
+##   expression has type "InBox[Siamese]"
+##     variable has type "InBox[Cat]"
+# in_box = in_box_si
diff --git a/15-more-types/randompick_generic.py b/15-more-types/randompick_generic.py
diff --git a/15-more-types/randompick_generic_test.py b/15-more-types/randompick_generic_test.py
@@ -4,7 +4,7 @@
 from randompick_generic import GenericRandomPicker
 
 
-class LottoPicker():
+class LottoPicker:
     def __init__(self, items: Iterable[int]) -> None:
         self._items = list(items)
         random.shuffle(self._items)
diff --git a/15-more-types/randompop.py b/15-more-types/randompop.py
@@ -1,4 +1,4 @@
-from typing import Protocol, TypeVar, runtime_checkable, Any
+from typing import Protocol, runtime_checkable, Any
 
 
 @runtime_checkable
diff --git a/15-more-types/randompop_test.py b/15-more-types/randompop_test.py
@@ -3,7 +3,7 @@
 from typing import Any, Iterable, TYPE_CHECKING
 
 
-class SimplePopper():
+class SimplePopper:
     def __init__(self, items: Iterable) -> None:
         self._items = list(items)
         random.shuffle(self._items)
diff --git a/15-more-types/typeddict/books.py b/15-more-types/typeddict/books.py
@@ -0,0 +1,32 @@
+# tag::BOOKDICT[]
+from typing import TypedDict, List
+import json
+
+class BookDict(TypedDict):
+    isbn: str
+    title: str
+    authors: List[str]
+    pagecount: int
+# end::BOOKDICT[]
+
+# tag::TOXML[]
+AUTHOR_EL = '<AUTHOR>{}</AUTHOR>'
+
+def to_xml(book: BookDict) -> str:  # <1>
+    elements: List[str] = []  # <2>
+    for key, value in book.items():
+        if isinstance(value, list):  # <3>
+            elements.extend(
+                AUTHOR_EL.format(n) for n in value)  # <4>
+        else:
+            tag = key.upper()
+            elements.append(f'<{tag}>{value}</{tag}>')
+    xml = '\n\t'.join(elements)
+    return f'<BOOK>\n\t{xml}\n</BOOK>'
+# end::TOXML[]
+
+# tag::FROMJSON[]
+def from_json(data: str) -> BookDict:
+    whatever: BookDict = json.loads(data)  # <1>
+    return whatever  # <2>
+# end::FROMJSON[]
diff --git a/15-more-types/typeddict/books_any.py b/15-more-types/typeddict/books_any.py
@@ -0,0 +1,32 @@
+# tag::BOOKDICT[]
+from typing import TypedDict, List
+import json
+
+class BookDict(TypedDict):
+    isbn: str
+    title: str
+    authors: List[str]
+    pagecount: int
+# end::BOOKDICT[]
+
+# tag::TOXML[]
+AUTHOR_EL = '<AUTHOR>{}</AUTHOR>'
+
+def to_xml(book: BookDict) -> str:  # <1>
+    elements: List[str] = []  # <2>
+    for key, value in book.items():
+        if isinstance(value, list):  # <3>
+            elements.extend(AUTHOR_EL.format(n)
+                for n in value)
+        else:
+            tag = key.upper()
+            elements.append(f'<{tag}>{value}</{tag}>')
+    xml = '\n\t'.join(elements)
+    return f'<BOOK>\n\t{xml}\n</BOOK>'
+# end::TOXML[]
+
+# tag::FROMJSON[]
+def from_json(data: str) -> BookDict:
+    whatever = json.loads(data)  # <1>
+    return whatever  # <2>
+# end::FROMJSON[]
diff --git a/15-more-types/typeddict/demo_books.py b/15-more-types/typeddict/demo_books.py
@@ -0,0 +1,20 @@
+from books import BookDict
+from typing import TYPE_CHECKING
+
+def demo() -> None:  # <1>
+    book = BookDict(  # <2>
+        isbn='0134757599',
+        title='Refactoring, 2e',
+        authors=['Martin Fowler', 'Kent Beck'],
+        pagecount=478
+    )
+    authors = book['authors'] # <3>
+    if TYPE_CHECKING:  # <4>
+        reveal_type(authors)  # <5>
+    authors = 'Bob'  # <6>
+    book['weight'] = 4.2
+    del book['title']
+
+
+if __name__ == '__main__':
+    demo()
diff --git a/15-more-types/typeddict/demo_not_book.py b/15-more-types/typeddict/demo_not_book.py
@@ -0,0 +1,23 @@
+from books import to_xml, from_json
+from typing import TYPE_CHECKING
+
+def demo() -> None:
+    NOT_BOOK_JSON = """
+        {"title": "Andromeda Strain",
+         "flavor": "pistachio",
+         "authors": true}
+    """
+    not_book = from_json(NOT_BOOK_JSON)  # <1>
+    if TYPE_CHECKING:  # <2>
+        reveal_type(not_book)
+        reveal_type(not_book['authors'])
+
+    print(not_book)  # <3>
+    print(not_book['flavor'])  # <4>
+
+    xml = to_xml(not_book)  # <5>
+    print(xml)  # <6>
+
+
+if __name__ == '__main__':
+    demo()
diff --git a/15-more-types/typeddict/test_books.py b/15-more-types/typeddict/test_books.py
diff --git a/15-more-types/typeddict/test_books_check_fails.py b/15-more-types/typeddict/test_books_check_fails.py
diff --git a/README.md b/README.md
