ch08, 09, 10: example files

Author: ramalho

08-def-type-hints/README.asciidoc

@@ -0,0 +1 @@
+== Type Hints in Function Definitions

08-def-type-hints/RPN_calc/calc.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+
+import sys
+from array import array
+from typing import Mapping, MutableSequence, Callable, Iterable, Sequence, Union, Any
+
+
+OPERATORS: Mapping[str, Callable[[float, float], float]] = {
+    '+': lambda a, b: a + b,
+    '-': lambda a, b: a - b,
+    '*': lambda a, b: a * b,
+    '/': lambda a, b: a / b,
+    '^': lambda a, b: a ** b,
+}
+
+
+Stack = MutableSequence[float]
+
+
+def parse_token(token: str) -> Union[str, float]:
+    try:
+        return float(token)
+    except ValueError:
+        return token
+
+
+def evaluate(tokens: Iterable[str], stack: Stack) -> None:
+    for token in tokens:
+        atom = parse_token(token)
+        if isinstance(atom, float):
+            stack.append(atom)
+        else:  # not float, must be operator
+            op = OPERATORS[atom]
+            x, y = stack.pop(), stack.pop()
+            result = op(y, x)
+            stack.append(result)
+
+
+def display(s: Stack) -> str:
+    items = (repr(n) for n in s)
+    return ' │ '.join(items) + ' →'
+
+
+def repl(input_fn: Callable[[Any], str] = input) -> None:
+    """Read-Eval-Print-Loop"""
+
+    print('Use CTRL+C to quit.', file=sys.stderr)
+    stack: Stack = array('d')
+
+    while True:
+        try:
+            line = input_fn('> ')              # Read
+        except (EOFError, KeyboardInterrupt):
+            break
+        try:
+            evaluate(line.split(), stack)      # Eval
+        except IndexError:
+            print('*** Not enough arguments.', file=sys.stderr)
+        except KeyError as exc:
+            print('*** Unknown operator:', exc.args[0], file=sys.stderr)
+        print(display(stack))                  # Print
+
+    print()
+
+
+if __name__ == '__main__':
+    repl()

08-def-type-hints/RPN_calc/calc_test.py

@@ -0,0 +1,51 @@
+from pytest import mark, approx  # type: ignore
+
+from dialogue import Dialogue  # type: ignore
+
+from calc import evaluate, repl, display, Stack
+
+TOLERANCE = .0001
+
+@mark.parametrize("source, want", [
+    ('2', 2),
+    ('2 3 +', 5),
+    ('5 3 -', 2),
+    ('3 5 * 2 +', 17),
+    ('2 3 4 5 * * *', 120),
+    ('1.1 1.1 1.1 + +', approx(3.3, TOLERANCE)),
+    ('100 32 - 5 * 9 /', approx(37.78, TOLERANCE)),
+])
+def test_evaluate(source, want) -> None:
+    stack: Stack = []
+    evaluate(source.split(), stack)
+    assert want == stack[-1]
+
+
+@mark.parametrize("value, want", [
+    ([], ' →'),
+    ([3.], '3.0 →'),
+    ([3., 4., 5.], '3.0 │ 4.0 │ 5.0 →'),
+])
+def test_display(value, want) -> None:
+    assert want == display(value)
+
+
+@mark.parametrize("session", [
+    """
+    > 3
+    3.0 →
+    """,
+    """
+    > 3 5 6
+    3.0 │ 5.0 │ 6.0 →
+    > *
+    3.0 │ 30.0 →
+    > -
+    -27.0 →
+    """,
+])
+def test_repl(capsys, session) -> None:
+    dlg = Dialogue(session)
+    repl(dlg.fake_input)
+    captured = capsys.readouterr()
+    assert dlg.session.strip() == captured.out.strip()

08-def-type-hints/arg_lab.py

@@ -0,0 +1,36 @@
+import typing
+from typing import Optional
+
+
+def f(a: str, *b: int, **c: float) -> None:
+    if typing.TYPE_CHECKING:
+        # reveal_type(b)
+        reveal_type(c)
+    print(a, b, c)
+
+
+def g(__a: int) -> None:
+    print(__a)
+
+
+def h(a: int, /) -> None:
+    print(a)
+
+
+def tag(
+    name: str,
+    /,
+    *content: str,
+    class_: Optional[str] = None,
+    foo: Optional[str] = None,
+    **attrs: str,
+) -> str:
+    return repr((name, content, class_, attrs))
+
+
+f(a='1')
+f('1', 2, 3, x=4, y=5)
+g(__a=1)
+# h(a=1)
+print(tag('li', 'first', 'second', id='#123'))
+print(tag('li', 'first', 'second', class_='menu', id='#123'))

08-def-type-hints/birds/birds.py

@@ -0,0 +1,15 @@
+class Bird:
+    pass
+
+class Duck(Bird):  # <1>
+    def quack(self):
+        print('Quack!')
+
+def alert(birdie):  # <2>
+    birdie.quack()
+
+def alert_duck(birdie: Duck) -> None:  # <3>
+    birdie.quack()
+
+def alert_bird(birdie: Bird) -> None:  # <4>
+    birdie.quack()

08-def-type-hints/birds/daffy.py

@@ -0,0 +1,6 @@
+from birds import *
+
+daffy = Duck()
+alert(daffy)       # <1>
+alert_duck(daffy)  # <2>
+alert_bird(daffy)  # <3>

08-def-type-hints/birds/protocol/lake.py

@@ -0,0 +1,9 @@
+from typing import Protocol                    # <1>
+
+class GooseLike(Protocol):
+    def honk(self, times: int) -> None: ...    # <2>
+    def swim(self) -> None: ...
+
+
+def alert(waterfowl: GooseLike) -> None:       # <3>
+    waterfowl.honk(2)

08-def-type-hints/birds/protocol/parrot.py

@@ -0,0 +1,10 @@
+from lake import alert
+
+class Parrot:
+    def honk(self, times: int) -> None:  # <1>
+        print('Honk! ' * times * 2)
+
+
+ze_carioca = Parrot()
+
+alert(ze_carioca)                              # <2>

08-def-type-hints/birds/protocol/swan.py

@@ -0,0 +1,13 @@
+from lake import alert                         # <1>
+
+class Swan:                                    # <2>
+    def honk(self, repetitions: int) -> None:  # <3>
+        print('Honk! ' * repetitions)
+
+    def swim(self) -> None:                    # <4>
+        pass
+
+
+bella = Swan()
+
+alert(bella)                                   # <5>

08-def-type-hints/birds/woody.py

@@ -0,0 +1,6 @@
+from birds import *
+
+woody = Bird()
+alert(woody)
+alert_duck(woody)
+alert_bird(woody)