Merge pull request #446 from seeM/only-nested-setdefault

Author: hamelsmu

fastcore/_modidx.py

@@ -118,10 +118,12 @@
                                  'fastcore.basics.nested_attr': 'https://fastcore.fast.ai/basics.html#nested_attr',
                                  'fastcore.basics.nested_callable': 'https://fastcore.fast.ai/basics.html#nested_callable',
                                  'fastcore.basics.nested_idx': 'https://fastcore.fast.ai/basics.html#nested_idx',
+                                 'fastcore.basics.nested_setdefault': 'https://fastcore.fast.ai/basics.html#nested_setdefault',
                                  'fastcore.basics.not_': 'https://fastcore.fast.ai/basics.html#not_',
                                  'fastcore.basics.null': 'https://fastcore.fast.ai/basics.html#null',
                                  'fastcore.basics.num_cpus': 'https://fastcore.fast.ai/basics.html#num_cpus',
                                  'fastcore.basics.num_methods': 'https://fastcore.fast.ai/basics.html#num_methods',
+                                 'fastcore.basics.only': 'https://fastcore.fast.ai/basics.html#only',
                                  'fastcore.basics.otherwise': 'https://fastcore.fast.ai/basics.html#otherwise',
                                  'fastcore.basics.partialler': 'https://fastcore.fast.ai/basics.html#partialler',
                                  'fastcore.basics.patch': 'https://fastcore.fast.ai/basics.html#patch',

fastcore/basics.py

@@ -10,13 +10,13 @@
            'getcallable', 'getattrs', 'hasattrs', 'setattrs', 'try_attrs', 'GetAttrBase', 'GetAttr', 'delegate_attr',
            'ShowPrint', 'Int', 'Str', 'Float', 'flatten', 'concat', 'strcat', 'detuplify', 'replicate', 'setify',
            'merge', 'range_of', 'groupby', 'last_index', 'filter_dict', 'filter_keys', 'filter_values', 'cycle',
-           'zip_cycle', 'sorted_ex', 'not_', 'argwhere', 'filter_ex', 'renumerate', 'first', 'nested_attr',
-           'nested_callable', 'nested_idx', 'set_nested_idx', 'val2idx', 'uniqueify', 'loop_first_last', 'loop_first',
-           'loop_last', 'fastuple', 'bind', 'mapt', 'map_ex', 'compose', 'maps', 'partialler', 'instantiate',
-           'using_attr', 'copy_func', 'patch_to', 'patch', 'patch_property', 'compile_re', 'ImportEnum', 'StrEnum',
-           'str_enum', 'Stateful', 'PrettyString', 'even_mults', 'num_cpus', 'add_props', 'typed', 'exec_new',
-           'exec_import', 'str2bool', 'lt', 'gt', 'le', 'ge', 'eq', 'ne', 'add', 'sub', 'mul', 'truediv', 'is_',
-           'is_not']
+           'zip_cycle', 'sorted_ex', 'not_', 'argwhere', 'filter_ex', 'renumerate', 'first', 'only', 'nested_attr',
+           'nested_setdefault', 'nested_callable', 'nested_idx', 'set_nested_idx', 'val2idx', 'uniqueify',
+           'loop_first_last', 'loop_first', 'loop_last', 'fastuple', 'bind', 'mapt', 'map_ex', 'compose', 'maps',
+           'partialler', 'instantiate', 'using_attr', 'copy_func', 'patch_to', 'patch', 'patch_property', 'compile_re',
+           'ImportEnum', 'StrEnum', 'str_enum', 'Stateful', 'PrettyString', 'even_mults', 'num_cpus', 'add_props',
+           'typed', 'exec_new', 'exec_import', 'str2bool', 'lt', 'gt', 'le', 'ge', 'eq', 'ne', 'add', 'sub', 'mul',
+           'truediv', 'is_', 'is_not']
 
 # %% ../nbs/01_basics.ipynb 1
 from .imports import *
@@ -651,19 +651,36 @@ def first(x, f=None, negate=False, **kwargs):
     return next(x, None)
 
 # %% ../nbs/01_basics.ipynb 263
+def only(o):
+    "Return the only item of `o`, raise if `o` doesn't have exactly one item"
+    it = iter(o)
+    try: res = next(it)
+    except StopIteration: raise ValueError('iterable has 0 items') from None
+    try: next(it)
+    except StopIteration: return res
+    raise ValueError(f'iterable has more than 1 item')
+
+# %% ../nbs/01_basics.ipynb 265
 def nested_attr(o, attr, default=None):
     "Same as `getattr`, but if `attr` includes a `.`, then looks inside nested objects"
     try:
         for a in attr.split("."): o = getattr(o, a)
     except AttributeError: return default
     return o
 
-# %% ../nbs/01_basics.ipynb 265
+# %% ../nbs/01_basics.ipynb 267
+def nested_setdefault(o, attr, default):
+    "Same as `setdefault`, but if `attr` includes a `.`, then looks inside nested objects"
+    attrs = attr.split('.')
+    for a in attrs[:-1]: o = o.setdefault(a, type(o)())
+    return o.setdefault(attrs[-1], default)
+
+# %% ../nbs/01_basics.ipynb 271
 def nested_callable(o, attr):
     "Same as `nested_attr` but if not found will return `noop`"
     return nested_attr(o, attr, noop)
 
-# %% ../nbs/01_basics.ipynb 267
+# %% ../nbs/01_basics.ipynb 273
 def _access(coll, idx): return coll.get(idx, None) if hasattr(coll, 'get') else coll[idx] if idx<len(coll) else None
 
 def _nested_idx(coll, *idxs):
@@ -673,34 +690,34 @@ def _nested_idx(coll, *idxs):
         coll = coll.get(idx, None) if hasattr(coll, 'get') else coll[idx] if idx<len(coll) else None
     return coll,last_idx
 
-# %% ../nbs/01_basics.ipynb 268
+# %% ../nbs/01_basics.ipynb 274
 def nested_idx(coll, *idxs):
     "Index into nested collections, dicts, etc, with `idxs`"
     if not coll or not idxs: return coll
     coll,idx = _nested_idx(coll, *idxs)
     if not coll or not idxs: return coll
     return _access(coll, idx)
 
-# %% ../nbs/01_basics.ipynb 270
+# %% ../nbs/01_basics.ipynb 276
 def set_nested_idx(coll, value, *idxs):
     "Set value indexed like `nested_idx"
     coll,idx = _nested_idx(coll, *idxs)
     coll[idx] = value
 
-# %% ../nbs/01_basics.ipynb 272
+# %% ../nbs/01_basics.ipynb 278
 def val2idx(x):
     "Dict from value to index"
     return {v:k for k,v in enumerate(x)}
 
-# %% ../nbs/01_basics.ipynb 274
+# %% ../nbs/01_basics.ipynb 280
 def uniqueify(x, sort=False, bidir=False, start=None):
     "Unique elements in `x`, optional `sort`, optional return reverse correspondence, optional prepend with elements."
     res = list(dict.fromkeys(x))
     if start is not None: res = listify(start)+res
     if sort: res.sort()
     return (res,val2idx(res)) if bidir else res
 
-# %% ../nbs/01_basics.ipynb 276
+# %% ../nbs/01_basics.ipynb 282
 # looping functions from https://github.com/willmcgugan/rich/blob/master/rich/_loop.py
 def loop_first_last(values):
     "Iterate and generate a tuple with a flag for first and last value."
@@ -713,17 +730,17 @@ def loop_first_last(values):
         first,previous_value = False,value
     yield first,True,previous_value
 
-# %% ../nbs/01_basics.ipynb 278
+# %% ../nbs/01_basics.ipynb 284
 def loop_first(values):
     "Iterate and generate a tuple with a flag for first value."
     return ((b,o) for b,_,o in loop_first_last(values))
 
-# %% ../nbs/01_basics.ipynb 280
+# %% ../nbs/01_basics.ipynb 286
 def loop_last(values):
     "Iterate and generate a tuple with a flag for last value."
     return ((b,o) for _,b,o in loop_first_last(values))
 
-# %% ../nbs/01_basics.ipynb 283
+# %% ../nbs/01_basics.ipynb 289
 num_methods = """
     __add__ __sub__ __mul__ __matmul__ __truediv__ __floordiv__ __mod__ __divmod__ __pow__
     __lshift__ __rshift__ __and__ __xor__ __or__ __neg__ __pos__ __abs__
@@ -737,7 +754,7 @@ def loop_last(values):
     __ifloordiv__ __imod__ __ipow__ __ilshift__ __irshift__ __iand__ __ixor__ __ior__
 """.split()
 
-# %% ../nbs/01_basics.ipynb 284
+# %% ../nbs/01_basics.ipynb 290
 class fastuple(tuple):
     "A `tuple` with elementwise ops and more friendly __init__ behavior"
     def __new__(cls, x=None, *rest):
@@ -774,7 +791,7 @@ def _f(self,*args): return self._op(op,*args)
 setattr(fastuple,'max',_get_op(max))
 setattr(fastuple,'min',_get_op(min))
 
-# %% ../nbs/01_basics.ipynb 302
+# %% ../nbs/01_basics.ipynb 308
 class _Arg:
     def __init__(self,i): self.i = i
 arg0 = _Arg(0)
@@ -783,7 +800,7 @@ def __init__(self,i): self.i = i
 arg3 = _Arg(3)
 arg4 = _Arg(4)
 
-# %% ../nbs/01_basics.ipynb 303
+# %% ../nbs/01_basics.ipynb 309
 class bind:
     "Same as `partial`, except you can use `arg0` `arg1` etc param placeholders"
     def __init__(self, func, *pargs, **pkwargs):
@@ -798,12 +815,12 @@ def __call__(self, *args, **kwargs):
         fargs = [args[x.i] if isinstance(x, _Arg) else x for x in self.pargs] + args[self.maxi+1:]
         return self.func(*fargs, **kwargs)
 
-# %% ../nbs/01_basics.ipynb 315
+# %% ../nbs/01_basics.ipynb 321
 def mapt(func, *iterables):
     "Tuplified `map`"
     return tuple(map(func, *iterables))
 
-# %% ../nbs/01_basics.ipynb 317
+# %% ../nbs/01_basics.ipynb 323
 def map_ex(iterable, f, *args, gen=False, **kwargs):
     "Like `map`, but use `bind`, and supports `str` and indexing"
     g = (bind(f,*args,**kwargs) if callable(f)
@@ -813,7 +830,7 @@ def map_ex(iterable, f, *args, gen=False, **kwargs):
     if gen: return res
     return list(res)
 
-# %% ../nbs/01_basics.ipynb 325
+# %% ../nbs/01_basics.ipynb 331
 def compose(*funcs, order=None):
     "Create a function that composes all functions in `funcs`, passing along remaining `*args` and `**kwargs` to all"
     funcs = listify(funcs)
@@ -825,14 +842,14 @@ def _inner(x, *args, **kwargs):
         return x
     return _inner
 
-# %% ../nbs/01_basics.ipynb 327
+# %% ../nbs/01_basics.ipynb 333
 def maps(*args, retain=noop):
     "Like `map`, except funcs are composed first"
     f = compose(*args[:-1])
     def _f(b): return retain(f(b), b)
     return map(_f, args[-1])
 
-# %% ../nbs/01_basics.ipynb 329
+# %% ../nbs/01_basics.ipynb 335
 def partialler(f, *args, order=None, **kwargs):
     "Like `functools.partial` but also copies over docstring"
     fnew = partial(f,*args,**kwargs)
@@ -841,20 +858,20 @@ def partialler(f, *args, order=None, **kwargs):
     elif hasattr(f,'order'): fnew.order=f.order
     return fnew
 
-# %% ../nbs/01_basics.ipynb 333
+# %% ../nbs/01_basics.ipynb 339
 def instantiate(t):
     "Instantiate `t` if it's a type, otherwise do nothing"
     return t() if isinstance(t, type) else t
 
-# %% ../nbs/01_basics.ipynb 335
+# %% ../nbs/01_basics.ipynb 341
 def _using_attr(f, attr, x): return f(getattr(x,attr))
 
-# %% ../nbs/01_basics.ipynb 336
+# %% ../nbs/01_basics.ipynb 342
 def using_attr(f, attr):
     "Construct a function which applies `f` to the argument's attribute `attr`"
     return partial(_using_attr, f, attr)
 
-# %% ../nbs/01_basics.ipynb 340
+# %% ../nbs/01_basics.ipynb 346
 class _Self:
     "An alternative to `lambda` for calling methods on passed object."
     def __init__(self): self.nms,self.args,self.kwargs,self.ready = [],[],[],True
@@ -886,18 +903,18 @@ def _call(self, *args, **kwargs):
         self.ready = True
         return self
 
-# %% ../nbs/01_basics.ipynb 341
+# %% ../nbs/01_basics.ipynb 347
 class _SelfCls:
     def __getattr__(self,k): return getattr(_Self(),k)
     def __getitem__(self,i): return self.__getattr__('__getitem__')(i)
     def __call__(self,*args,**kwargs): return self.__getattr__('_call')(*args,**kwargs)
 
 Self = _SelfCls()
 
-# %% ../nbs/01_basics.ipynb 342
+# %% ../nbs/01_basics.ipynb 348
 _all_ = ['Self']
 
-# %% ../nbs/01_basics.ipynb 348
+# %% ../nbs/01_basics.ipynb 354
 def copy_func(f):
     "Copy a non-builtin function (NB `copy.copy` does not work for this)"
     if not isinstance(f,FunctionType): return copy(f)
@@ -908,7 +925,7 @@ def copy_func(f):
     fn.__qualname__ = f.__qualname__
     return fn
 
-# %% ../nbs/01_basics.ipynb 354
+# %% ../nbs/01_basics.ipynb 360
 def patch_to(cls, as_prop=False, cls_method=False):
     "Decorator: add `f` to `cls`"
     if not isinstance(cls, (tuple,list)): cls=(cls,)
@@ -927,45 +944,45 @@ def _inner(f):
         return globals().get(nm, builtins.__dict__.get(nm, None))
     return _inner
 
-# %% ../nbs/01_basics.ipynb 365
+# %% ../nbs/01_basics.ipynb 371
 def patch(f=None, *, as_prop=False, cls_method=False):
     "Decorator: add `f` to the first parameter's class (based on f's type annotations)"
     if f is None: return partial(patch, as_prop=as_prop, cls_method=cls_method)
     ann,glb,loc = get_annotations_ex(f)
     cls = union2tuple(eval_type(ann.pop('cls') if cls_method else next(iter(ann.values())), glb, loc))
     return patch_to(cls, as_prop=as_prop, cls_method=cls_method)(f)
 
-# %% ../nbs/01_basics.ipynb 373
+# %% ../nbs/01_basics.ipynb 379
 def patch_property(f):
     "Deprecated; use `patch(as_prop=True)` instead"
     warnings.warn("`patch_property` is deprecated and will be removed; use `patch(as_prop=True)` instead")
     cls = next(iter(f.__annotations__.values()))
     return patch_to(cls, as_prop=True)(f)
 
-# %% ../nbs/01_basics.ipynb 375
+# %% ../nbs/01_basics.ipynb 381
 def compile_re(pat):
     "Compile `pat` if it's not None"
     return None if pat is None else re.compile(pat)
 
-# %% ../nbs/01_basics.ipynb 377
+# %% ../nbs/01_basics.ipynb 383
 class ImportEnum(enum.Enum):
     "An `Enum` that can have its values imported"
     @classmethod
     def imports(cls):
         g = sys._getframe(1).f_locals
         for o in cls: g[o.name]=o
 
-# %% ../nbs/01_basics.ipynb 380
+# %% ../nbs/01_basics.ipynb 386
 class StrEnum(str,ImportEnum):
     "An `ImportEnum` that behaves like a `str`"
     def __str__(self): return self.name
 
-# %% ../nbs/01_basics.ipynb 382
+# %% ../nbs/01_basics.ipynb 388
 def str_enum(name, *vals):
     "Simplified creation of `StrEnum` types"
     return StrEnum(name, {o:o for o in vals})
 
-# %% ../nbs/01_basics.ipynb 384
+# %% ../nbs/01_basics.ipynb 390
 class Stateful:
     "A base class/mixin for objects that should not serialize all their state"
     _stateattrs=()
@@ -985,37 +1002,37 @@ def _init_state(self):
         "Override for custom init and deserialization logic"
         self._state = {}
 
-# %% ../nbs/01_basics.ipynb 390
+# %% ../nbs/01_basics.ipynb 396
 class PrettyString(str):
     "Little hack to get strings to show properly in Jupyter."
     def __repr__(self): return self
 
-# %% ../nbs/01_basics.ipynb 396
+# %% ../nbs/01_basics.ipynb 402
 def even_mults(start, stop, n):
     "Build log-stepped array from `start` to `stop` in `n` steps."
     if n==1: return stop
     mult = stop/start
     step = mult**(1/(n-1))
     return [start*(step**i) for i in range(n)]
 
-# %% ../nbs/01_basics.ipynb 398
+# %% ../nbs/01_basics.ipynb 404
 def num_cpus():
     "Get number of cpus"
     try:                   return len(os.sched_getaffinity(0))
     except AttributeError: return os.cpu_count()
 
 defaults.cpus = num_cpus()
 
-# %% ../nbs/01_basics.ipynb 400
+# %% ../nbs/01_basics.ipynb 406
 def add_props(f, g=None, n=2):
     "Create properties passing each of `range(n)` to f"
     if g is None: return (property(partial(f,i)) for i in range(n))
     return (property(partial(f,i), partial(g,i)) for i in range(n))
 
-# %% ../nbs/01_basics.ipynb 403
+# %% ../nbs/01_basics.ipynb 409
 def _typeerr(arg, val, typ): return TypeError(f"{arg}=={val} not {typ}")
 
-# %% ../nbs/01_basics.ipynb 404
+# %% ../nbs/01_basics.ipynb 410
 def typed(f):
     "Decorator to check param and return types at runtime"
     names = f.__code__.co_varnames
@@ -1032,21 +1049,21 @@ def _f(*args,**kwargs):
         return res
     return functools.update_wrapper(_f, f)
 
-# %% ../nbs/01_basics.ipynb 412
+# %% ../nbs/01_basics.ipynb 418
 def exec_new(code):
     "Execute `code` in a new environment and return it"
     pkg = None if __name__=='__main__' else Path().cwd().name
     g = {'__name__': __name__, '__package__': pkg}
     exec(code, g)
     return g
 
-# %% ../nbs/01_basics.ipynb 414
+# %% ../nbs/01_basics.ipynb 420
 def exec_import(mod, sym):
     "Import `sym` from `mod` in a new environment"
 #     pref = '' if __name__=='__main__' or mod[0]=='.' else '.'
     return exec_new(f'from {mod} import {sym}')
 
-# %% ../nbs/01_basics.ipynb 415
+# %% ../nbs/01_basics.ipynb 421
 def str2bool(s):
     "Case-insensitive convert string `s` too a bool (`y`,`yes`,`t`,`true`,`on`,`1`->`True`)"
     if not isinstance(s,str): return bool(s)

nbs/.gitattributes

@@ -1,2 +1,3 @@
 **/*.ipynb filter=clean-nbs
 **/*.ipynb diff=ipynb
+*.ipynb merge=nbdev-merge