update from O'Reilly repo

Author: ramalho

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

@@ -1,4 +1,4 @@
 from typing import Protocol, Any
 
-class Comparable(Protocol):  # <1>
+class SupportsLessThan(Protocol):  # <1>
     def __lt__(self, other: Any) -> bool: ...  # <2>

08-def-type-hints/comparable/mymax.py

@@ -1,35 +1,35 @@
 # tag::MYMAX_TYPES[]
 from typing import Protocol, Any, TypeVar, overload, Callable, Iterable, Union
 
-class _Comparable(Protocol):
+class SupportsLessThan(Protocol):
     def __lt__(self, other: Any) -> bool: ...
 
-_T = TypeVar('_T')
-_CT = TypeVar('_CT', bound=_Comparable)
-_DT = TypeVar('_DT')
+T = TypeVar('T')
+LT = TypeVar('LT', bound=SupportsLessThan)
+DT = TypeVar('DT')
 
 MISSING = object()
 EMPTY_MSG = 'max() arg is an empty sequence'
 
 @overload
-def max(__arg1: _CT, __arg2: _CT, *_args: _CT, key: None = ...) -> _CT:
+def max(__arg1: LT, __arg2: LT, *_args: LT, key: None = ...) -> LT:
     ...
 @overload
-def max(__arg1: _T, __arg2: _T, *_args: _T, key: Callable[[_T], _CT]) -> _T:
+def max(__arg1: T, __arg2: T, *_args: T, key: Callable[[T], LT]) -> T:
     ...
 @overload
-def max(__iterable: Iterable[_CT], *, key: None = ...) -> _CT:
+def max(__iterable: Iterable[LT], *, key: None = ...) -> LT:
     ...
 @overload
-def max(__iterable: Iterable[_T], *, key: Callable[[_T], _CT]) -> _T:
+def max(__iterable: Iterable[T], *, key: Callable[[T], LT]) -> T:
     ...
 @overload
-def max(__iterable: Iterable[_CT], *, key: None = ...,
-        default: _DT) -> Union[_CT, _DT]:
+def max(__iterable: Iterable[LT], *, key: None = ...,
+        default: DT) -> Union[LT, DT]:
     ...
 @overload
-def max(__iterable: Iterable[_T], *, key: Callable[[_T], _CT],
-        default: _DT) -> Union[_T, _DT]:
+def max(__iterable: Iterable[T], *, key: Callable[[T], LT],
+        default: DT) -> Union[T, DT]:
     ...
 # end::MYMAX_TYPES[]
 # tag::MYMAX[]
@@ -57,4 +57,4 @@ def max(first, *args, key=None, default=MISSING):
                 candidate = current
                 candidate_key = current_key
     return candidate
-# end::MYMAX[]
+# end::MYMAX[]

08-def-type-hints/comparable/mymax_demo.py

@@ -116,6 +116,7 @@ def error_single_arg_not_iterable() -> None:
     except TypeError as exc:
         print(exc)
 
+###################################### run demo and error functions
 
 def main():
     for name, val in globals().items():

08-def-type-hints/comparable/top.py

@@ -21,10 +21,10 @@
 
 # tag::TOP[]
 from typing import TypeVar, Iterable, List
-from comparable import Comparable
+from comparable import SupportsLessThan
 
-CT = TypeVar('CT', bound=Comparable)
+LT = TypeVar('LT', bound=SupportsLessThan)
 
-def top(series: Iterable[CT], length: int) -> List[CT]:
+def top(series: Iterable[LT], length: int) -> List[LT]:
     return sorted(series, reverse=True)[:length]
 # end::TOP[]

08-def-type-hints/comparable/top_test.py

@@ -29,6 +29,7 @@ def test_top_tuples() -> None:
         reveal_type(result)
     assert result == expected
 
+# intentional type error
 def test_top_objects_error() -> None:
     series = [object() for _ in range(4)]
     if TYPE_CHECKING:

08-def-type-hints/passdrill.py

@@ -54,7 +54,9 @@ def load_hash() -> Tuple[bytes, bytes]:
             salted_hash = fp.read()
     except FileNotFoundError:
         print('ERROR: passphrase hash file not found.', HELP)
-        sys.exit(2)
+        # "standard" exit status codes:
+        # https://stackoverflow.com/questions/1101957/are-there-any-standard-exit-status-codes-in-linux/40484670#40484670
+        sys.exit(74)  # input/output error
 
     salt, stored_hash = salted_hash.split(b':')
     return b64decode(salt), b64decode(stored_hash)
@@ -93,7 +95,7 @@ def main(argv: Sequence[str]) -> None:
         save_hash()
     else:
         print('ERROR: invalid argument.', HELP)
-        sys.exit(1)
+        sys.exit(2)  # command line usage error
 
 
 if __name__ == '__main__':

11-pythonic-obj/mem_test.py

@@ -9,7 +9,7 @@
     module = importlib.import_module(module_name)
 else:
     print(f'Usage: {sys.argv[0]} <vector-module-to-test>')
-    sys.exit(1)
+    sys.exit(2)  # command line usage error
 
 fmt = 'Selected Vector2d type: {.__name__}.{.__name__}'
 print(fmt.format(module, module.Vector2d))

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: ...