# # Copyright (c) nexB Inc. and others. All rights reserved. # SPDX-License-Identifier: Apache-2.0 # See http://www.apache.org/licenses/LICENSE-2.0 for the license text. # See https://github.com/nexB/commoncode for support or download. # See https://aboutcode.org for more information about nexB OSS projects. # import functools from types import GeneratorType from array import array def flatten(seq): """ Flatten recursively a sequence and all its sub-sequences that can be tuples, lists or generators (generators will be consumed): all are converted to a flat list of elements. For example:: >>> flatten([7, (6, [5, [4, ['a'], 3]], 3), 2, 1]) [7, 6, 5, 4, 'a', 3, 3, 2, 1] >>> def gen(): ... for i in range(2): ... yield range(5) ... >>> flatten(gen()) [0, 1, 2, 3, 4, 0, 1, 2, 3, 4] Originally derived from http://www.andreasen.org/misc/util.py 2002-2005 by Erwin S. Andreasen -- http://www.andreasen.org/misc.shtml This file is in the Public Domain Version: Id: util.py,v 1.22 2005/12/16 00:08:21 erwin Exp erwin """ r = [] generators = GeneratorType, range for x in seq: if isinstance(x, (list, tuple)): r.extend(flatten(x)) elif isinstance(x, generators): r.extend(flatten(list(x))) else: r.append(x) return r def memoize(fun): """ Decorate `fun` function and cache return values. Arguments must be hashable. Only args are supported, kwargs are not handled. Used to speed up some often executed functions. For example:: >>> @memoize ... def expensive(*args, **kwargs): ... print('Calling expensive with', args, kwargs) ... return 'value expensive to compute' + repr(args) >>> expensive(1, 2) Calling expensive with (1, 2) {} 'value expensive to compute(1, 2)' >>> expensive(1, 2) 'value expensive to compute(1, 2)' >>> expensive(1, 2, a=0) Calling expensive with (1, 2) {'a': 0} 'value expensive to compute(1, 2)' >>> expensive(1, 2, a=0) Calling expensive with (1, 2) {'a': 0} 'value expensive to compute(1, 2)' >>> expensive(1, 2) 'value expensive to compute(1, 2)' >>> expensive(1, 2, 5) Calling expensive with (1, 2, 5) {} 'value expensive to compute(1, 2, 5)' The expensive function returned value will be cached based for each args values and computed only once in its life. Call with kwargs are not cached """ memos = {} @functools.wraps(fun) def memoized(*args, **kwargs): # calls with kwargs are not handled and not cached if kwargs: return fun(*args, **kwargs) # convert any list args to a tuple args = tuple(tuple(arg) if isinstance(arg, (list, tuple, array)) else arg for arg in args) try: return memos[args] except KeyError: memos[args] = fun(*args) return memos[args] return functools.update_wrapper(memoized, fun) def partial(func, *args, **kwargs): """ Return a partial function. Same as functools.partial but keeping the __doc__ and __name__ of the warpper function. """ return functools.update_wrapper(functools.partial(func, *args, **kwargs), func)