docs: def check(self, req):
          """Determine if ``req`` is in this instances cache.
  
          Determine if there are cache hits for the request in this aggregator
          instance.
  
          Not in the cache
  
          If req is not in the cache, it returns ``None`` to indicate that the
          caller should send the request.
  
          Cache Hit; response has errors
  
          When a cached CheckResponse has errors, it's assumed that ``req`` would
          fail as well, so the cached CheckResponse is returned.  However, the
          first CheckRequest after the flush interval has elapsed should be sent
          to the server to refresh the CheckResponse, though until it's received,
          subsequent CheckRequests should fail with the cached CheckResponse.
  
          Cache behaviour - response passed
  
          If the cached CheckResponse has no errors, it's assumed that ``req``
          will succeed as well, so the CheckResponse is returned, with the quota
          info updated to the same as requested.  The requested tokens are
          aggregated until flushed.
  
          Args:
            req (``ServicecontrolServicesCheckRequest``): to be sent to
              the service control service
  
          Raises:
             ValueError: if the ``req`` service_name is not the same as
               this instances
  
          Returns:
             ``CheckResponse``: if an applicable response is cached by this
               instance is available for use or None, if there is no applicable
               response
  
          """
          if self._cache is None:
              return None  # no cache, send request now
          if not isinstance(req, sc_messages.ServicecontrolServicesCheckRequest):
              raise ValueError(u'Invalid request')
          if req.serviceName != self.service_name:
              _logger.error(u'bad check(): service_name %s does not match ours %s',
                            req.serviceName, self.service_name)
              raise ValueError(u'Service name mismatch')
          check_request = req.checkRequest
          if check_request is None:
              _logger.error(u'bad check(): no check_request in %s', req)
              raise ValueError(u'Expected operation not set')
          op = check_request.operation
          if op is None:
              _logger.error(u'bad check(): no operation in %s', req)
              raise ValueError(u'Expected operation not set')
          if op.importance != sc_messages.Operation.ImportanceValueValuesEnum.LOW:
              return None  # op is important, send request now
  
          signature = sign(check_request)
          with self._cache as cache:
              _logger.debug(u'checking the cache for %r\n%s', signature, cache)
              item = cache.get(signature)
              if item is None:
                  return None  # signal to caller to send req
              else:
                  return self._handle_cached_response(req, item)