def cache_class(): return { generate_cache_key(('fake_endpoint', [1])): ( time.time() - 10, {'result': 'value-a'}, ), }
def cache_class(): return { generate_cache_key(('fake_endpoint', [1])): ( time.time() - 10, {'result': 'value-a'}, ), }
def middleware(method: RPCEndpoint, params: Any) -> RPCResponse: lock_acquired = lock.acquire(blocking=False) try: should_try_cache = ( lock_acquired and method in rpc_whitelist and not _is_latest_block_number_request(method, params) ) if should_try_cache: _update_block_info_cache() latest_block_hash = block_info['latest_block']['hash'] cache_key = generate_cache_key((latest_block_hash, method, params)) if cache_key in cache: return cache[cache_key] response = make_request(method, params) if should_cache_fn(method, params, response): cache[cache_key] = response return response else: return make_request(method, params) finally: if lock_acquired: lock.release()
async def cache_async_session(endpoint_uri: URI, session: ClientSession) -> None: cache_key = generate_cache_key(endpoint_uri) with _async_session_cache_lock: evicted_items = _async_session_cache.cache(cache_key, session) if evicted_items is not None: for key, session in evicted_items.items(): await session.close()
def middleware(method: RPCEndpoint, params: Any) -> RPCResponse: lock_acquired = lock.acquire(blocking=False) try: if lock_acquired and method in rpc_whitelist: cache_key = generate_cache_key((method, params)) if cache_key in cache: # check that the cached response is not expired. cached_at, cached_response = cache[cache_key] cached_for = time.time() - cached_at if cached_for <= cache_expire_seconds: return cached_response else: del cache[cache_key] # cache either missed or expired so make the request. response = make_request(method, params) if should_cache_fn(method, params, response): cache[cache_key] = (time.time(), response) return response else: return make_request(method, params) finally: if lock_acquired: lock.release()
def cache_class(): return { generate_cache_key((current_block_hash, 'eth_getBlockByNumber', [ 'latest' ])): { 'result': 'value-a' }, }
def _get_session(*args, **kwargs): cache_key = generate_cache_key((args, kwargs)) if cache_key not in _session_cache: s = requests.Session() a = HTTPAdapter(max_retries=Retry(connect=5, read=3), pool_connections=64, pool_maxsize=128) s.mount('https://', a) s.mount('http://', a) _session_cache[cache_key] = s return _session_cache[cache_key]
def _get_session(*args, **kwargs): cache_key = generate_cache_key((args, kwargs)) if cache_key not in _session_cache: # This is the main change from original Web3 `_get_session` session = requests.sessions.Session() session.mount('http://', HTTPAdapter(pool_connections=25, pool_maxsize=25, pool_block=True)) session.mount('https://', HTTPAdapter(pool_connections=25, pool_maxsize=25, pool_block=True)) _session_cache[cache_key] = session return _session_cache[cache_key]
def _get_session_new(*args, **kwargs): cache_key = generate_cache_key((args, kwargs)) if cache_key not in _session_cache: _session_cache[cache_key] = requests.Session() #TODO: Adjust these parameters retry = Retry(connect=10, backoff_factor=0.3) adapter = HTTPAdapter(max_retries=retry) _session_cache[cache_key].mount('http://', adapter) _session_cache[cache_key].mount('https://', adapter) return _session_cache[cache_key]
def middleware(method: RPCEndpoint, params: Any) -> RPCResponse: lock_acquired = lock.acquire(blocking=False) try: if lock_acquired and method in rpc_whitelist: cache_key = generate_cache_key((method, params)) if cache_key not in cache: response = make_request(method, params) if should_cache_fn(method, params, response): cache[cache_key] = response return response return cache[cache_key] else: return make_request(method, params) finally: if lock_acquired: lock.release()
async def get_async_session(endpoint_uri: URI) -> ClientSession: cache_key = generate_cache_key(endpoint_uri) if cache_key not in _async_session_cache: await cache_async_session(endpoint_uri, ClientSession(raise_for_status=True)) return _async_session_cache.get_cache_entry(cache_key)
def _get_session(*args, **kwargs): cache_key = generate_cache_key((args, kwargs)) if cache_key not in _session_cache: _session_cache[cache_key] = requests.Session() return _session_cache[cache_key]
def cache_class(): return { generate_cache_key(('fake_endpoint', [1])): { 'result': 'value-a' }, }
def cache_class(): return { generate_cache_key((current_block_hash, 'fake_endpoint', [1])): { 'result': 'value-a' }, }
def cache_class(): return { generate_cache_key(('fake_endpoint', [1])): {'result': 'value-a'}, }
def get_session(endpoint_uri: URI) -> requests.Session: cache_key = generate_cache_key(endpoint_uri) if cache_key not in _session_cache: _session_cache[cache_key] = requests.Session() return _session_cache[cache_key]
def cache_session(endpoint_uri: URI, session: requests.Session) -> None: cache_key = generate_cache_key(endpoint_uri) _session_cache[cache_key] = session
def test_key_generation_is_deterministic(value): left = recursive_shuffle_dict(value) right = recursive_shuffle_dict(value) left_key = generate_cache_key(left) right_key = generate_cache_key(right) assert left_key == right_key
def cache_class(): return { generate_cache_key( (current_block_hash, 'fake_endpoint', [1]) ): {'result': 'value-a'}, }