def clear_cache(scope=None):
    """
    Clear all cached data.

    Parameters
    ----------
    scope : {None, 'step', 'iteration', 'forever'}, optional
        Clear cached values with a given scope.
        By default all cached values are removed.

    """
    if not scope:
        _TABLE_CACHE.clear()
        _COLUMN_CACHE.clear()
        _INJECTABLE_CACHE.clear()
        for m in _MEMOIZED.values():
            m.value.clear_cached()
        logger.debug('simulation cache cleared')
    else:
        for d in (_TABLE_CACHE, _COLUMN_CACHE, _INJECTABLE_CACHE):
            items = toolz.valfilter(lambda x: x.scope == scope, d)
            for k in items:
                del d[k]
        for m in toolz.filter(lambda x: x.scope == scope, _MEMOIZED.values()):
            m.value.clear_cached()
        logger.debug('cleared cached values with scope {!r}'.format(scope))

def entrypoint(dockerfile):
    "Return the entrypoint, if declared"
    f = dockerfile.split("\n")[::-1]  # reverse the lines
    try:
        entry_line = first(filter(lambda x: "ENTRYPOINT" in x, f))
    except StopIteration as e:
        # No ENTRYPOINT line was found
        return None
    else:
        res = last(entry_line.partition("ENTRYPOINT")).strip()
        try:
            return json.loads(res)
        except:
            return res.split()
        return None

def compute_up(t, seq, **kwargs):
    predicate = optimize(t.predicate, seq)
    predicate = rrowfunc(predicate, child(t))
    return filter(predicate, seq)

 def all_block(self) -> List[Block]:
   return t.filter(lambda x: isinstance(x, Block), self.values())

 def all_inline(self) -> List[Inline]:
   return t.filter(lambda x: isinstance(x, Inline), self.values())

def compute_up(t, seq, **kwargs):
    predicate = rrowfunc(t.predicate, t._child)
    return filter(predicate, seq)

def filter_stopwords(tokenset):
    """
    Filters out stopwords.
    """
    return tlz.filter(lambda tkn: tkn not in STOPWORDS, tokenset)

def filter_longer_than(n, tokenset):
    """
    Filters out tokens that have 'n' characters or more.
    """
    return tlz.filter(lambda tkn: len(tkn) < n, tokenset)

def filter_stopwords(tokenset):
    """
    Filters out tokens that are stopwords.
    """
    return tlz.filter(not_stopword, tokenset)

def filter_whitespace(tokenset):
    """
    Filters out tokens that are only whitespace.
    """
    return tlz.filter(tlz.compose(bool, str.strip), tokenset)

def compute_up(expr, seq, predicate, **kwargs):
    preds = iter(predicate)
    return filter(lambda _: next(preds), seq)

    
deps.number_of_edges()
deps.number_of_nodes()
deps.node['skimage']
deps.in_edges('skimage')
nodes = nx.katz_centrality(deps)
central = sorted(deps.nodes(), key=nodes.__getitem__, reverse=True)
central[:10]
central[:20]
central[:40]
central[40:80]
central.index('skimage')
central.index('scipy')
import pickle
stdlib = pickle.load(open('/Users/jni/projects/depsy/data/python_standard_libs.pickle', 'rb'))
central_nonstd = list(tz.filter(lambda x: x not in stdlib, central))
len(central_nonstd)
central_nonstd.index('scipy')
len(central)
central[:5]
nx.is_connected(deps.to_undirected())
len(packages)
deps_sym = deps.to_undirected()
import numpy as np
conncomps = list(nx.connected_component_subgraphs(deps_sym))
giant = conncomps[0]
giant_d = deps.subgraph(giant.nodes())
gpackages = giant_d.nodes()
A = nx.to_scipy_sparse_matrix(giant_d)
A.shape
A.dtype

def sfilter(pred, fn, x):
    """ Yield only those results which satisfy the predicate """
    for x in filter(pred, fn(x)):
        yield x

def compute_up_1d(t, seq, **kwargs):
    return toolz.count(filter(None, seq))

def filter_shorter_than(n, tokenset):
    """
    Filters out tokens that have less than 'n' characters.
    """
    return tlz.filter(lambda tkn: len(tkn) >= n, tokenset)

def filter_whitespace(tokenset):
    """
    Filters out tokens that are only whitespace.
    """
    return tlz.filter(tlz.compose(bool, lambda string: string.strip()), tokenset)