def null_if_excepts(exc_type: Type[BaseException], fn: Callable[..., TReturn]) -> Callable[..., TReturn]: return excepts( exc_type, fn, static_return(None), )
def _deserialize_kv_pairs( cls, serialized_enr: Sequence[bytes]) -> Iterable[Tuple[bytes, Any]]: serialized_keys = serialized_enr[1::2] serialized_values = serialized_enr[2::2] keys = tuple( binary.deserialize(serialized_key) for serialized_key in serialized_keys) cls._validate_key_uniqueness(keys, serialized_enr) cls._validate_key_order(keys, serialized_enr) value_deserializers = tuple( ENR_KEY_SEDES_MAPPING.get(key, FALLBACK_ENR_VALUE_SEDES) for key in keys) values = tuple( excepts( DeserializationError, value_deserializer.deserialize, lambda v: FALLBACK_ENR_VALUE_SEDES.deserialize(serialized_value ), )(serialized_value) for value_deserializer, serialized_value in zip( value_deserializers, serialized_values)) return dict(zip(keys, values))
def middleware(method: RPCEndpoint, params: Any) -> RPCResponse: if method in method_handlers: exc_type, handler = method_handlers[method] return excepts( exc_type, make_request, handler, )(method, params) else: return make_request(method, params)
def middleware(method, params): if method in method_handlers: exc_type, handler = method_handlers[method] return excepts( exc_type, make_request, handler, )(method, params) else: return make_request(method, params)
def highest_td_peer(self) -> BaseChainPeer: peers = tuple(self.connected_nodes.values()) if not peers: raise NoConnectedPeers("No connected peers") td_getter = excepts(UnknownAPI, operator.attrgetter('head_info.head_td'), lambda _: 0) peers_by_td = groupby(td_getter, peers) max_td = max(peers_by_td.keys()) return random.choice(peers_by_td[max_td])
def _revert_pending_transaction_filter(self, filter): is_valid_transaction_hash = excepts( (TransactionNotFound,), compose( bool, self.get_transaction_by_hash, self.normalizer.normalize_outbound_transaction_hash, ), lambda v: False, ) values_to_remove = remove(is_valid_transaction_hash, filter.get_all()) filter.remove(*values_to_remove)
def _revert_block_filter(self, filter): is_valid_block_hash = excepts( (BlockNotFound,), compose( bool, self.get_block_by_hash, self.normalizer.normalize_outbound_block_hash, ), lambda v: False, ) values_to_remove = tuple(remove(is_valid_block_hash, filter.get_all())) filter.remove(*values_to_remove)
def serialize(cls, enr: ENRAPI) -> Tuple[bytes, ...]: serialized_sequence_number = big_endian_int.serialize( enr.sequence_number) sorted_key_value_pairs = sorted(enr.items(), key=operator.itemgetter(0)) serialized_keys = tuple( binary.serialize(key) for key, _ in sorted_key_value_pairs) values_and_serializers = tuple( (value, ENR_KEY_SEDES_MAPPING.get(key, FALLBACK_ENR_VALUE_SEDES)) for key, value in sorted_key_value_pairs) serialized_values = tuple( excepts( (EncodingError, SerializationError), value_serializer.serialize, lambda v: FALLBACK_ENR_VALUE_SEDES.serialize(value), )(value) for value, value_serializer in values_and_serializers) return tuple( cons( serialized_sequence_number, interleave((serialized_keys, serialized_values)), ))
not_implemented, 'compileSolidity': not_implemented, 'compileSerpent': not_implemented, 'newFilter': create_log_filter, 'newBlockFilter': call_eth_tester('create_block_filter'), 'newPendingTransactionFilter': call_eth_tester('create_pending_transaction_filter'), 'uninstallFilter': excepts( FilterNotFound, compose( is_null, call_eth_tester('delete_filter'), ), static_return(False), ), 'getFilterChanges': null_if_filter_not_found(call_eth_tester('get_only_filter_changes')), 'getFilterLogs': null_if_filter_not_found(call_eth_tester('get_all_filter_logs')), 'getLogs': get_logs, 'getWork': not_implemented, 'submitWork': not_implemented, 'submitHashrate': not_implemented,
def null_if_excepts(exc_type, fn): return excepts( exc_type, fn, static_return(None), )