code: def with_cache(function):
          
          @wraps(function)
          def wrapped(cls, _cache_key, _cache_ignore, _cache_timeout, **kwargs):
              def clear_timeouts():
                  """Clear the cache of timed out results."""
                  for key in list(cls.timeouts):
                      if timer() - cls.timeouts[key] > _cache_timeout:
                          del cls.timeouts[key]
                          del cls.cache[key]
  
              if _cache_ignore:
                  return function(cls, **kwargs)
              with cls.ca_lock:
                  clear_timeouts()
                  if _cache_key in cls.cache:
                      if cls.cache_hit_callback:
                          cls.cache_hit_callback(_cache_key)
                      return cls.cache[_cache_key]
              # Releasing the lock before actually making the request allows for
              # the possibility of more than one thread making the same request
              # to get through. Without having domain-specific caching (under the
              # assumption only one request to a domain can be made at a
              # time), there isn't a better way to handle this.
              result = function(cls, **kwargs)
              # The handlers don't call `raise_for_status` so we need to ignore
              # status codes that will result in an exception that should not be
              # cached.
              if result.status_code not in (200, 302):
                  return result
              with cls.ca_lock:
                  cls.timeouts[_cache_key] = timer()
                  cls.cache[_cache_key] = result
                  return result
          return wrapped
docs: Return a decorator that interacts with a handler's cache.
  
          This decorator must be applied to a DefaultHandler class method or
          instance method as it assumes `cache`, `ca_lock` and `timeouts` are
          available.