human
Give me a the Python code you requested given the following:
Complete the below
def lru_cache(maxsize=100):

    ''''Least-recently-used cache decorator.
    This function duplicates (more-or-less) the protocol of the
    ``functools.lru_cache`` decorator in the Python 3.2 standard library, but
    uses the clock face LRU algorithm instead of an ordered dictionary.
    If *maxsize* is set to None, the LRU features are disabled and the cache
    can grow without bound.
    Arguments to the cached function must be hashable.
    View the cache statistics named tuple (hits, misses, maxsize, currsize)
    with f.cache_info().  Clear the cache and statistics with f.cache_clear().
    Access the underlying function with f.__wrapped__.'
    '''
assistant
#Here is the Python code you requested.
    def decorating_function(user_function):
        stats = [0, 0, 0]
        data = {}
        if maxsize:
            clock_keys = ([None] * maxsize)
            clock_refs = array('B', (0 for _ in xrange(maxsize)))
            lock = Lock()
            @wraps(user_function)
            def wrapper(*args):
                key = args
                try:
                    with lock:
                        (pos, result) = data[key]
                        clock_refs[pos] = 1
                        stats[0] += 1
                except KeyError:
                    result = user_function(*args)
                    with lock:
                        hand = stats[2]
                        end = hand
                        while True:
                            hand = ((hand + 1) % maxsize)
                            current_ref = clock_refs[hand]
                            if current_ref:
                                clock_refs[hand] = 0
                            elif ((not current_ref) or (hand == end)):
                                current_key = clock_keys[hand]
                                if (current_key in data):
                                    del data[current_key]
                                clock_keys[hand] = key
                                clock_refs[hand] = 1
                                break
                        data[key] = (hand, result)
                        stats[2] = hand
                        stats[1] += 1
                return result
        else:
            @wraps(user_function)
            def wrapper(*args):
                key = args
                try:
                    result = data[key]
                    stats[0] += 1
                except KeyError:
                    result = user_function(*args)
                    data[key] = result
                    stats[1] += 1
                return result
        def cache_info():
            'Report    cache    statistics'
            return (stats[0], stats[1], maxsize, len(data))
        def...