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)

08-def-type-hints/bus.py

@@ -0,0 +1,29 @@
+
+"""
+>>> import copy
+>>> bus1 = Bus(['Alice', 'Bill', 'Claire', 'David'])
+>>> bus2 = copy.copy(bus1)
+>>> bus3 = copy.deepcopy(bus1)
+>>> bus1.drop('Bill')
+>>> bus2.passengers
+['Alice', 'Claire', 'David']
+>>> bus3.passengers
+['Alice', 'Bill', 'Claire', 'David']
+
+"""
+
+# tag::BUS_CLASS[]
+class Bus:
+
+    def __init__(self, passengers=None):
+        if passengers is None:
+            self.passengers = []
+        else:
+            self.passengers = list(passengers)
+
+    def pick(self, name):
+        self.passengers.append(name)
+
+    def drop(self, name):
+        self.passengers.remove(name)
+# end::BUS_CLASS[]

08-def-type-hints/charindex.py

@@ -0,0 +1,35 @@
+"""
+``name_index`` builds an inverted index mapping words to sets of Unicode
+characters which contain that word in their names. For example::
+
+    >>> index = name_index(32, 65)
+    >>> sorted(index['SIGN'])
+    ['#', '$', '%', '+', '<', '=', '>']
+    >>> sorted(index['DIGIT'])
+    ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
+    >>> index['DIGIT'] & index['EIGHT']
+    {'8'}
+"""
+
+# tag::CHARINDEX[]
+import sys
+import re
+import unicodedata
+from typing import Dict, Set, Iterator
+
+RE_WORD = re.compile('\w+')
+STOP_CODE = sys.maxunicode + 1
+
+def tokenize(text: str) -> Iterator[str]:  # <1>
+    """return iterable of uppercased words"""
+    for match in RE_WORD.finditer(text):
+        yield match.group().upper()
+
+def name_index(start: int = 32, end: int = STOP_CODE) -> Dict[str, Set[str]]:
+    index: Dict[str, Set[str]] = {}  # <2>
+    for char in (chr(i) for i in range(start, end)):
+        if name := unicodedata.name(char, ''):  # <3>
+            for word in tokenize(name):
+                index.setdefault(word, set()).add(char)
+    return index
+# end::CHARINDEX[]

08-def-type-hints/clip_annot.py

@@ -0,0 +1,38 @@
+"""
+    >>> clip('banana ', 6)
+    'banana'
+    >>> clip('banana ', 7)
+    'banana'
+    >>> clip('banana ', 5)
+    'banana'
+    >>> clip('banana split', 6)
+    'banana'
+    >>> clip('banana split', 7)
+    'banana'
+    >>> clip('banana split', 10)
+    'banana'
+    >>> clip('banana split', 11)
+    'banana'
+    >>> clip('banana split', 12)
+    'banana split'
+"""
+
+# tag::CLIP_ANNOT[]
+def clip(text: str, max_len: int = 80) -> str:
+    """Return new ``str`` clipped at last space before or after ``max_len``.
+       Return full ``text`` if no space found.
+    """
+    end = None
+    if len(text) > max_len:
+        space_before = text.rfind(' ', 0, max_len)
+        if space_before >= 0:
+            end = space_before
+        else:
+            space_after = text.rfind(' ', max_len)
+            if space_after >= 0:
+                end = space_after
+    if end is None:
+        end = len(text)
+    return text[:end].rstrip()
+
+# end::CLIP_ANNOT[]

08-def-type-hints/clip_annot_1ed.py

@@ -0,0 +1,38 @@
+"""
+    >>> clip('banana ', 6)
+    'banana'
+    >>> clip('banana ', 7)
+    'banana'
+    >>> clip('banana ', 5)
+    'banana'
+    >>> clip('banana split', 6)
+    'banana'
+    >>> clip('banana split', 7)
+    'banana'
+    >>> clip('banana split', 10)
+    'banana'
+    >>> clip('banana split', 11)
+    'banana'
+    >>> clip('banana split', 12)
+    'banana split'
+"""
+
+# tag::CLIP_ANNOT[]
+
+def clip(text:str, max_len:'int > 0'=80) -> str:  # <1>
+    """Return text clipped at the last space before or after max_len
+    """
+    end = None
+    if len(text) > max_len:
+        space_before = text.rfind(' ', 0, max_len)
+        if space_before >= 0:
+            end = space_before
+        else:
+            space_after = text.rfind(' ', max_len)
+            if space_after >= 0:
+                end = space_after
+    if end is None:  # no spaces were found
+        end = len(text)
+    return text[:end].rstrip()
+
+# end::CLIP_ANNOT[]

08-def-type-hints/clip_annot_signature.rst

@@ -0,0 +1,10 @@
+>>> from clip_annot import clip
+>>> from inspect import signature
+>>> sig = signature(clip)
+>>> sig.return_annotation
+<class 'str'>
+>>> for param in sig.parameters.values():
+...     note = repr(param.annotation).ljust(13)
+...     print(note, ':', param.name, '=', param.default)
+<class 'str'> : text = <class 'inspect._empty'>
+'int > 0'     : max_len = 80