docs: def lru_cache(maxsize=128, maxtime=60):
      '''Least-recently-used cache decorator.
  
      Arguments to the cached function must be hashable.
      Cache performance statistics stored in f.hits and f.misses.
      Clear the cache with f.clear().
      http://en.wikipedia.org/wiki/Cache_algorithms#Least_Recently_Used
  
      '''
      maxqueue = maxsize * 10
  
      # @ReservedAssignment
      def decorating_function(
              user_function,
              len=len,
              iter=iter,
              tuple=tuple,
              sorted=sorted,
              KeyError=KeyError):
  
          cache = {}  # mapping of args to results
          queue = deque()  # order that keys have been used
          refcount = Counter()  # times each key is in the queue
          sentinel = object()  # marker for looping around the queue
          kwd_mark = object()  # separate positional and keyword args
  
          # lookup optimizations (ugly but fast)
          queue_append, queue_popleft = queue.append, queue.popleft
          queue_appendleft, queue_pop = queue.appendleft, queue.pop
  
          @wraps(user_function)
          def wrapper(*args, **kwds):
              # cache key records both positional and keyword args
              key = args
              if kwds:
                  key += (kwd_mark,) + tuple(sorted(kwds.items()))
  
              # record recent use of this key
              queue_append(key)
              refcount[key] += 1
  
              # get cache entry or compute if not found
              try:
                  result, expire_time = cache[key]
  
                  if expire_time and time() > expire_time:
                      raise KeyError('Expired')
  
                  wrapper.hits += 1
              except KeyError:
                  result = user_function(*args, **kwds)
                  if maxtime:
                      expire_time = time() + maxtime
                  else:
                      expire_time = None
  
                  cache[key] = result, expire_time
                  wrapper.misses += 1
  
                  # purge least recently used cache entry
                  if len(cache) > maxsize:
                      key = queue_popleft()
                      refcount[key] -= 1
                      while refcount[key]:
                          key = queue_popleft()
                          refcount[key] -= 1
                      del cache[key], refcount[key]
  
              # periodically compact the queue by eliminating duplicate keys
              # while preserving order of most recent access
              if len(queue) > maxqueue:
                  refcount.clear()
                  queue_appendleft(sentinel)
                  for key in filterfalse(refcount.__contains__, iter(queue_pop, sentinel)):
                      queue_appendleft(key)
                      refcount[key] = 1
  
              return result
  
          def clear():
              cache.clear()
              queue.clear()
              refcount.clear()
              wrapper.hits = wrapper.misses = 0
  
          wrapper.hits = wrapper.misses = 0
          wrapper.clear = clear
          return wrapper
  
      return decorating_function