fixes #75

Author: jph00

CHANGELOG.md

@@ -1,6 +1,7 @@
 # Release notes
 
 <!-- do not remove -->
+
 ## 1.0.2
 
 ### Bugs Squashed

README.md

@@ -57,7 +57,7 @@ The documentation also contains links to any related functions or classes, which
 
 ### Testing
 
-fastcore's testing module is designed to work well with [nbdev](https://nbdev.fast.ai), which is a full literate programming environment built on Jupyter Notebooks. That means that your tests, docs, and code all live together in the same notebook. fastcore and nbdev's approach to testing starts with the premise that your all your tests should pass. If one fails, no more tests in a notebook are run.
+fastcore's testing module is designed to work well with [nbdev](https://nbdev.fast.ai), which is a full literate programming environment built on Jupyter Notebooks. That means that your tests, docs, and code all live together in the same notebook. fastcore and nbdev's approach to testing starts with the premise that all your tests should pass. If one fails, no more tests in a notebook are run.
 
 Tests look like this:
 
@@ -181,9 +181,8 @@ Looking at that `ProductPage` example, it's rather verbose and duplicates a lot
 
 ```python
 class ProductPage:
-    store_attrs = 'author,price,cost'
     def __init__(self,author,price,cost): store_attr()
-    __repr__ = basic_repr(store_attrs)
+    __repr__ = basic_repr('author,price,cost')
 
 ProductPage("Jeremy", 1.50, 0.50)
 ```
@@ -244,7 +243,7 @@ p
 
 
 
-    (#20) [10,7,9,17,18,4,16,15,19,14...]
+    (#20) [17,10,7,18,12,13,5,16,15,19...]
 
 
 
@@ -257,7 +256,7 @@ p[2,4,6]
 
 
 
-    (#3) [9,18,16]
+    (#3) [7,12,5]
 
 
 
@@ -270,7 +269,7 @@ p.argwhere(ge(15))
 
 
 
-    (#5) [3,4,6,7,8]
+    (#5) [0,3,7,8,9]
 
 
 
@@ -295,11 +294,11 @@ Most Python programmers use object oriented methods and inheritance to allow dif
 
 ```python
 @typedispatch
-def f_td_test(x:numbers.Integral, y): return x+1
+def _f(x:numbers.Integral, y): return x+1
 @typedispatch
-def f_td_test(x:int, y:float): return x+y
+def _f(x:int, y:float): return x+y
 
-f_td_test(3,2.0), f_td_test(3,2)
+_f(3,2.0), _f(3,2)
 ```
 
 

fastcore/_nbdev.py

@@ -41,6 +41,7 @@
          "arg3": "01_foundation.ipynb",
          "arg4": "01_foundation.ipynb",
          "coll_repr": "01_foundation.ipynb",
+         "is_bool": "01_foundation.ipynb",
          "mask2idxs": "01_foundation.ipynb",
          "cycle": "01_foundation.ipynb",
          "zip_cycle": "01_foundation.ipynb",
@@ -130,11 +131,6 @@
          "parallel_chunks": "02_utils.ipynb",
          "run_procs": "02_utils.ipynb",
          "parallel_gen": "02_utils.ipynb",
-         "ipython_shell": "02_utils.ipynb",
-         "in_ipython": "02_utils.ipynb",
-         "in_colab": "02_utils.ipynb",
-         "in_jupyter": "02_utils.ipynb",
-         "in_notebook": "02_utils.ipynb",
          "type_hints": "03_dispatch.ipynb",
          "anno_ret": "03_dispatch.ipynb",
          "cmp_instance": "03_dispatch.ipynb",

fastcore/dispatch.py

@@ -7,6 +7,7 @@
 from .imports import *
 from .foundation import *
 from .utils import *
+from collections import defaultdict
 
 # Cell
 def type_hints(f):
@@ -163,7 +164,7 @@ def default_set_meta(self, x, copy_meta=False):
 def cast(x, typ):
     "cast `x` to type `typ` (may also change `x` inplace)"
     res = typ._before_cast(x) if hasattr(typ, '_before_cast') else x
-    if isinstance(res, ndarray): res = res.view(typ)
+    if isinstance_str(res, 'ndarray'): res = res.view(typ)
     elif hasattr(res, 'as_subclass'): res = res.as_subclass(typ)
     else:
         try: res.__class__ = typ

fastcore/foundation.py

@@ -2,11 +2,15 @@
 
 __all__ = ['defaults', 'FixSigMeta', 'PrePostInitMeta', 'NewChkMeta', 'BypassNewMeta', 'copy_func', 'patch_to', 'patch',
            'patch_property', 'use_kwargs_dict', 'use_kwargs', 'delegates', 'method', 'funcs_kwargs', 'add_docs', 'docs',
-           'custom_dir', 'arg0', 'arg1', 'arg2', 'arg3', 'arg4', 'coll_repr', 'mask2idxs', 'cycle', 'zip_cycle',
-           'is_indexer', 'negate_func', 'GetAttr', 'delegate_attr', 'bind', 'listable_types', 'CollBase', 'L']
+           'custom_dir', 'arg0', 'arg1', 'arg2', 'arg3', 'arg4', 'coll_repr', 'is_bool', 'mask2idxs', 'cycle',
+           'zip_cycle', 'is_indexer', 'negate_func', 'GetAttr', 'delegate_attr', 'bind', 'listable_types', 'CollBase',
+           'L']
 
 # Cell
 from .imports import *
+from contextlib import contextmanager
+from copy import copy
+import random
 
 # Cell
 defaults = SimpleNamespace()
@@ -216,6 +220,11 @@ def coll_repr(c, max_n=10):
     return f'(#{len(c)}) [' + ','.join(itertools.islice(map(repr,c), max_n)) + (
         '...' if len(c)>10 else '') + ']'
 
+# Cell
+def is_bool(x):
+    "Check whether `x` is a bool or None"
+    return isinstance(x,(bool,NoneType)) or isinstance_str(x, 'bool_')
+
 # Cell
 def mask2idxs(mask):
     "Convert bool mask or index list to index `L`"
@@ -224,7 +233,7 @@ def mask2idxs(mask):
     if len(mask)==0: return []
     it = mask[0]
     if hasattr(it,'item'): it = it.item()
-    if isinstance(it,(bool,NoneType,np.bool_)): return [i for i,m in enumerate(mask) if m]
+    if is_bool(it): return [i for i,m in enumerate(mask) if m]
     return [int(i) for i in mask]
 
 # Cell
@@ -349,11 +358,15 @@ def __setitem__(self, idx, o):
             if not is_iter(o): o = [o]*len(idx)
             for i,o_ in zip(idx,o): self.items[i] = o_
 
+    def __eq__(self,b):
+        if isinstance_str(b, 'ndarray'): return array_equal(b, self)
+        if isinstance(b, (str,dict)): return False
+        return all_equal(b,self)
+
     def __iter__(self): return iter(self.items.itertuples() if hasattr(self.items,'iloc') else self.items)
     def __contains__(self,b): return b in self.items
     def __reversed__(self): return self._new(reversed(self.items))
     def __invert__(self): return self._new(not i for i in self)
-    def __eq__(self,b): return False if isinstance(b, (str,dict,set)) else all_equal(b,self)
     def __repr__(self): return repr(self.items) if _is_array(self.items) else coll_repr(self)
     def __mul__ (a,b): return a._new(a.items*b)
     def __add__ (a,b): return a._new(a.items+_listify(b))
@@ -443,7 +456,7 @@ def product(self): return self.reduce(operator.mul)
          map_dict="Like `map`, but creates a dict from `items` to function results",
          starmap="Like `map`, but use `itertools.starmap`",
          itemgot="Create new `L` with item `idx` of all `items`",
-         attrgot="Create new `L` with attr `k` of all `items`, if `items` contains dicts, then `L` will contain corresponding values for key `k` for each dict.",
+         attrgot="Create new `L` with attr `k` (or value `k` for dicts) of all `items`.",
          cycle="Same as `itertools.cycle`",
          enumerate="Same as `enumerate`",
          zip="Create new `L` with `zip(*items)`",

fastcore/imports.py

@@ -1,38 +1,18 @@
-import numpy as np
-import io,operator,sys,os,re,mimetypes,itertools,shutil,pickle,tempfile,subprocess
-import itertools,random,inspect,functools,math,bz2,typing,numbers,warnings,threading
-import json,urllib.request
+import sys,os,re,shutil,typing,itertools,operator,functools,math,warnings,functools,inspect,io
 
+from operator import itemgetter,attrgetter
 from warnings import warn
-from dataclasses import dataclass
+from typing import Iterable,Generator,Sequence,Iterator
 from functools import partial,reduce
-from threading import Thread
-from time import sleep
-from copy import copy
-from contextlib import redirect_stdout,contextmanager
-from collections.abc import Iterable,Iterator,Generator,Collection,Sequence
-from types import SimpleNamespace
 from pathlib import Path
-from collections import defaultdict,Counter
-from operator import itemgetter,attrgetter
-from uuid import uuid4
-from urllib.request import HTTPError
-
-# External modules
-from numpy import array,ndarray
-from pdb import set_trace
-
-#Optional modules
-try: import matplotlib.pyplot as plt
-except: pass
 
 try:
     from types import WrapperDescriptorType,MethodWrapperType,MethodDescriptorType
 except ImportError:
     WrapperDescriptorType = type(object.__init__)
     MethodWrapperType = type(object().__str__)
     MethodDescriptorType = type(str.join)
-from types import BuiltinFunctionType,BuiltinMethodType,MethodType,FunctionType
+from types import BuiltinFunctionType,BuiltinMethodType,MethodType,FunctionType,SimpleNamespace
 
 NoneType = type(None)
 string_classes = (str,bytes)
@@ -60,17 +40,49 @@ def noops(self, x=None, *args, **kwargs):
     "Do nothing (method)"
     return x
 
-def one_is_instance(a, b, t): return isinstance(a,t) or isinstance(b,t)
+def any_is_instance(t, *args): return any(isinstance(a,t) for a in args)
+
+def isinstance_str(x, cls_name):
+    "Like `isinstance`, except takes a type name instead of a type"
+    return cls_name in [t.__name__ for t in type(x).__mro__]
+
+def array_equal(a,b):
+    if hasattr(a, '__array__'): a = a.__array__()
+    if hasattr(b, '__array__'): b = b.__array__()
+    return (a==b).all()
 
 def equals(a,b):
     "Compares `a` and `b` for equality; supports sublists, tensors and arrays too"
     if (a is None) ^ (b is None): return False
-    if one_is_instance(a,b,type): return a==b
+    if any_is_instance(type,a,b): return a==b
     if hasattr(a, '__array_eq__'): return a.__array_eq__(b)
     if hasattr(b, '__array_eq__'): return b.__array_eq__(a)
-    cmp = (np.array_equal if one_is_instance(a, b, ndarray       ) else
-           operator.eq    if one_is_instance(a, b, (str,dict,set)) else
-           all_equal      if is_iter(a) or is_iter(b) else
+    cmp = (array_equal   if isinstance_str(a, 'ndarray') or isinstance_str(b, 'ndarray') else
+           operator.eq   if any_is_instance((str,dict,set), a, b) else
+           all_equal     if is_iter(a) or is_iter(b) else
            operator.eq)
     return cmp(a,b)
 
+def ipython_shell():
+    "Same as `get_ipython` but returns `False` if not in IPython"
+    try: return get_ipython()
+    except NameError: return False
+
+def in_ipython():
+    "Check if code is running in some kind of IPython environment"
+    return bool(ipython_shell())
+
+def in_colab():
+    "Check if the code is running in Google Colaboratory"
+    return 'google.colab' in sys.modules
+
+def in_jupyter():
+    "Check if the code is running in a jupyter notebook"
+    if not in_ipython(): return False
+    return ipython_shell().__class__.__name__ == 'ZMQInteractiveShell'
+
+def in_notebook():
+    "Check if the code is running in a jupyter notebook"
+    return in_colab() or in_jupyter()
+
+IN_IPYTHON,IN_JUPYTER,IN_COLAB,IN_NOTEBOOK = in_ipython(),in_jupyter(),in_colab(),in_notebook()

fastcore/nb_imports.py

@@ -0,0 +1,8 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import numbers,tempfile,pickle,random
+
+from PIL import Image
+from numpy import array,ndarray
+from copy import copy
+from time import sleep

fastcore/test.py

@@ -5,6 +5,8 @@
 
 # Cell
 from .imports import *
+from collections import Counter
+from contextlib import redirect_stdout
 
 # Cell
 def test_fail(f, msg='', contains=''):
@@ -49,7 +51,7 @@ def is_close(a,b,eps=1e-5):
     if hasattr(a, '__array__') or hasattr(b,'__array__'):
         return (abs(a-b)<eps).all()
     if isinstance(a, (Iterable,Generator)) or isinstance(b, (Iterable,Generator)):
-        return is_close(np.array(a), np.array(b), eps=eps)
+        return all(abs(a_-b_)<eps for a_,b_ in zip(a,b))
     return abs(a-b)<eps
 
 # Cell
@@ -93,7 +95,7 @@ def test_warns(f, show=False):
 # Cell
 def test_fig_exists(ax):
     "Test there is a figure displayed in `ax`"
-    assert ax and len(np.frombuffer(ax.figure.canvas.tostring_argb(), dtype=np.uint8))
+    assert ax and len(ax.figure.canvas.tostring_argb())
 
 # Cell
 def test_sig(f, b):

fastcore/utils.py

@@ -9,13 +9,14 @@
            'partialler', 'mapped', 'instantiate', 'using_attr', 'log_args', 'Self', 'Self', 'remove_patches_path',
            'bunzip', 'join_path_file', 'urlread', 'urljson', 'sort_by_run', 'PrettyString', 'round_multiple',
            'even_mults', 'num_cpus', 'add_props', 'ContextManagers', 'set_num_threads', 'ProcessPoolExecutor',
-           'parallel', 'parallel_chunks', 'run_procs', 'parallel_gen', 'ipython_shell', 'in_ipython', 'in_colab',
-           'in_jupyter', 'in_notebook', 'IN_NOTEBOOK', 'IN_JUPYTER', 'IN_COLAB', 'IN_IPYTHON']
+           'parallel', 'parallel_chunks', 'run_procs', 'parallel_gen']
 
 # Cell
 from .imports import *
 from .foundation import *
 from functools import wraps
+import mimetypes,bz2,pickle,random
+from contextlib import contextmanager
 
 # Cell
 def ifnone(a, b):
@@ -321,13 +322,13 @@ class Inf(metaclass=_InfMeta):
     pass
 
 # Cell
-def _oper(op,a,b=np.nan): return (lambda o:op(o,a)) if b!=b else op(a,b)
+def _oper(op,a,b=float('nan')): return (lambda o:op(o,a)) if b!=b else op(a,b)
 
 def _mk_op(nm, mod=None):
     "Create an operator using `oper` and add to the caller's module"
     if mod is None: mod = inspect.currentframe().f_back.f_locals
     op = getattr(operator,nm)
-    def _inner(a,b=np.nan): return _oper(op, a,b)
+    def _inner(a,b=float('nan')): return _oper(op, a,b)
     _inner.__name__ = _inner.__qualname__ = nm
     _inner.__doc__ = f'Same as `operator.{nm}`, or returns partial if 1 arg'
     mod[nm] = _inner
@@ -647,7 +648,7 @@ def even_mults(start, stop, n):
     if n==1: return stop
     mult = stop/start
     step = mult**(1/(n-1))
-    return np.array([start*(step**i) for i in range(n)])
+    return [start*(step**i) for i in range(n)]
 
 # Cell
 def num_cpus():
@@ -763,43 +764,10 @@ def parallel_gen(cls, items, n_workers=defaults.cpus, **kwargs):
     if n_workers==0:
         yield from enumerate(list(cls(**kwargs)(items)))
         return
-    batches = np.array_split(items, n_workers)
-    idx = np.cumsum(0 + L(batches).map(len))
+    batches = L(chunked(items, n_chunks=n_workers))
+    idx = L(itertools.accumulate(0 + batches.map(len)))
     queue = Queue()
     if progress_bar: items = progress_bar(items, leave=False)
     f=partial(_f_pg, cls(**kwargs), queue)
     done=partial(_done_pg, queue, items)
-    yield from run_procs(f, done, L(batches,idx).zip())
-
-# Cell
-def ipython_shell():
-    "Same as `get_ipython` but returns `False` if not in IPython"
-    try: return get_ipython()
-    except NameError: return False
-
-# Cell
-def in_ipython():
-    "Check if code is running in some kind of IPython environment"
-    return bool(ipython_shell())
-
-# Cell
-def in_colab():
-    "Check if the code is running in Google Colaboratory"
-    return 'google.colab' in sys.modules
-
-# Cell
-def in_jupyter():
-    "Check if the code is running in a jupyter notebook"
-    if not in_ipython(): return False
-    return ipython_shell().__class__.__name__ == 'ZMQInteractiveShell'
-
-# Cell
-def in_notebook():
-    "Check if the code is running in a jupyter notebook"
-    return in_colab() or in_jupyter()
-
-# Cell
-IN_IPYTHON,IN_JUPYTER,IN_COLAB,IN_NOTEBOOK = in_ipython(),in_jupyter(),in_colab(),in_notebook()
-
-# Cell
-#nbdev_comment _all_ = ['IN_NOTEBOOK', 'IN_JUPYTER', 'IN_COLAB', 'IN_IPYTHON']
+    yield from run_procs(f, done, L(batches,idx).zip())