def profiling(name_list): hv = Hive() set_shared_hive_instance(hv) del hv print("start") for name in name_list: print("account: %s" % (name)) acc = Account(name) max_index = acc.virtual_op_count() print(max_index) stopTime = datetime(2018, 4, 22, 0, 0, 0) hist_elem = None for h in acc.history_reverse(stop=stopTime): hist_elem = h print(hist_elem) print("blockchain") blockchain_object = Blockchain() current_num = blockchain_object.get_current_block_num() startBlockNumber = current_num - 20 endBlockNumber = current_num block_elem = None for o in blockchain_object.stream(start=startBlockNumber, stop=endBlockNumber): print("block %d" % (o["block_num"])) block_elem = o print(block_elem)
def setup(self): self.prefix = u"HIVE" self.default_prefix = u"STM" self.wif = "5KQwrPbwdL6PhXujxW37FSSQZ1JiwsST4cqQzDeyXtP79zkvFD3" self.ref_block_num = 34294 self.ref_block_prefix = 3707022213 self.expiration = "2016-04-06T08:29:27" self.hv = Hive(offline=True)
def profiling(node, name_list, shared_instance=True, clear_acc_cache=False, clear_all_cache=True): print("shared_instance %d clear_acc_cache %d clear_all_cache %d" % (shared_instance, clear_acc_cache, clear_all_cache)) if not shared_instance: hv = Hive(node=node) print(str(hv)) else: hv = None acc_dict = {} for name in name_list: acc = Account(name, hive_instance=hv) acc_dict[name] = acc if clear_acc_cache: acc.clear_cache() acc_dict = {} if clear_all_cache: clear_cache() if not shared_instance: del hv.rpc
if __name__ == "__main__": how_many_minutes = 10 how_many_virtual_op = 10000 max_batch_size = None threading = False thread_num = 16 nodelist = NodeList() nodes = nodelist.get_nodes(normal=True, appbase=True, dev=True) t = PrettyTable([ "node", "10 blockchain minutes", "10000 virtual account op", "version" ]) t.align = "l" for node in nodes: print("Current node:", node) try: hv = Hive(node=node, num_retries=3) blockchain = Blockchain(hive_instance=hv) account = Account("gtg", hive_instance=hv) virtual_op_count = account.virtual_op_count() blockchain_version = hv.get_blockchain_version() last_block_id = 19273700 last_block = Block(last_block_id, hive_instance=hv) startTime = datetime.now() stopTime = last_block.time() + timedelta(seconds=how_many_minutes * 60) ltime = time.time() cnt = 0 total_transaction = 0
from __future__ import division from __future__ import print_function from __future__ import unicode_literals from builtins import int, str import sys from datetime import timedelta import time import io from bhive.hive import Hive import logging from prettytable import PrettyTable log = logging.getLogger(__name__) logging.basicConfig(level=logging.INFO) if __name__ == "__main__": hv = Hive(node="https://api.hive.blog") # hv = Hive(node="https://testnet.hiveitdev.com") # hv = Hive(node="wss://appbasetest.timcliff.com") # hv = Hive(node="https://api.hiveitstage.com") # hv = Hive(node="https://api.hiveitdev.com") all_calls = hv.rpc.get_methods(api="jsonrpc") t = PrettyTable(["method", "args", "ret"]) t.align = "l" t_condenser = PrettyTable(["method", "args", "ret"]) t_condenser.align = "l" for call in all_calls: if "condenser" not in call: ret = hv.rpc.get_signature({'method': call}, api="jsonrpc") t.add_row([call, ret['args'], ret['ret']]) else: ret = hv.rpc.get_signature({'method': call}, api="jsonrpc")
return opcount, total_duration if __name__ == "__main__": node_setup = 1 threading = True thread_num = 8 timeout = 10 nodes = NodeList() nodes.update_nodes(weights={"block": 1}) node_list_wss = nodes.get_nodes(https=False)[:5] node_list_https = nodes.get_nodes(wss=False)[:5] vote_result = [] duration = [] hv_wss = Hive(node=node_list_wss, timeout=timeout) hv_https = Hive(node=node_list_https, timeout=timeout) print("Without threading wss") opcount_wot_wss, total_duration_wot_wss = stream_votes(hv_wss, False, 8) print("Without threading https") opcount_wot_https, total_duration_wot_https = stream_votes( hv_https, False, 8) if threading: print("\n Threading with %d threads is activated now." % thread_num) hv = Hive(node=node_list_wss, timeout=timeout) opcount_wss, total_duration_wss = stream_votes(hv, threading, thread_num) opcount_https, total_duration_https = stream_votes(hv, threading, thread_num) print("Finished!")
import logging from bhive.blockchain import Blockchain from bhive.block import Block from bhive.hive import Hive from bhive.utils import parse_time, formatTimedelta from bhive.nodelist import NodeList log = logging.getLogger(__name__) logging.basicConfig(level=logging.INFO) if __name__ == "__main__": node_setup = 1 how_many_hours = 1 nodes = NodeList() if node_setup == 0: hv = Hive(node=nodes.get_nodes(normal=True, wss=True), num_retries=10) max_batch_size = None threading = False thread_num = 8 elif node_setup == 1: hv = Hive(node=nodes.get_nodes(normal=True, wss=True), num_retries=10) max_batch_size = None threading = True thread_num = 16 elif node_setup == 2: hv = Hive(node=nodes.get_nodes(appbase=False, https=False), num_retries=10) max_batch_size = None threading = True thread_num = 16 blockchain = Blockchain(hive_instance=hv)
bhive_test.setup() hive_times = [] bhive_times = [] loops = 50 for i in range(0, loops): print(i) opHive = hiveOperations.Transfer(**{ "from": "foo", "to": "baar", "amount": "111.110 HIVE", "memo": "Fooo" }) opBhive = operations.Transfer(**{ "from": "foo", "to": "baar", "amount": Amount("111.110 HIVE", hive_instance=Hive(offline=True)), "memo": "Fooo" }) t_s, t_v = hive_test.doit(ops=opHive) hive_times.append([t_s, t_v]) t_s, t_v = bhive_test.doit(ops=opBhive) bhive_times.append([t_s, t_v]) hive_dt = [0, 0] bhive_dt = [0, 0] for i in range(0, loops): hive_dt[0] += hive_times[i][0] hive_dt[1] += hive_times[i][1] bhive_dt[0] += bhive_times[i][0]
quit_thread = True print("benchmark aborted.") else: for node in nodes: print("Current node:", node) result = benchmark_node(node, how_many_minutes, how_many_seconds) results.append(result) for result in results: t2.add_row([result["node"], result["version"]]) print(t2) print("\n") sortedList = sorted(results, key=lambda self: self["history_count"], reverse=True) for result in sortedList: if result["successful"]: t.add_row([ result["node"], result["block_count"], result["history_count"], ("%.2f" % (result["access_time"])) ]) working_nodes.append(result["node"]) print(t) print("\n") print("Total benchmark time: %.2f s\n" % (timer() - benchmark_time)) if set_default_nodes: hv = Hive(offline=True) hv.set_default_nodes(working_nodes) else: print("bhivepy set nodes " + str(working_nodes))
from bhivebase import operations from bhive.transactionbuilder import TransactionBuilder from bhivegraphenebase.account import PasswordKey, PrivateKey, PublicKey from bhive.hive import Hive from bhive.utils import parse_time, formatTimedelta from bhiveapi.exceptions import NumRetriesReached from bhive.nodelist import NodeList from bhivebase.transactions import getBlockParams log = logging.getLogger(__name__) logging.basicConfig(level=logging.INFO) # example wif wif = "5KQwrPbwdL6PhXujxW37FSSQZ1JiwsST4cqQzDeyXtP79zkvFD3" if __name__ == "__main__": hv_online = Hive() ref_block_num, ref_block_prefix = getBlockParams(hv_online) print("ref_block_num %d - ref_block_prefix %d" % (ref_block_num, ref_block_prefix)) hv = Hive(offline=True) op = operations.Transfer({ 'from': 'bhive.app', 'to': 'thecrazygm', 'amount': "0.001 HBD", 'memo': "" }) tb = TransactionBuilder(hive_instance=hv) tb.appendOps([op])
"account": "guest123", "social_action_comment_update": { "permlink": 'just-a-test-post', "title": "just a test post", "body": "test post body", } }) op3 = operations.Vote( **{ 'voter': 'guest123', 'author': 'wlsuser', 'permlink': 'another-test-post', 'weight': 10000, }) privateWif = "5K..." tx = TransactionBuilder(use_condenser_api=True, hive_instance=wls) tx.appendOps(op1) tx.appendWif(privateWif) tx.sign() tx.broadcast() if __name__ == "__main__": # `blocking=True` forces use of broadcast_transaction_synchronous wls = Hive(node=["https://pubrpc.whaleshares.io"], blocking=True) print(wls.get_blockchain_version()) print(wls.get_config()) test_post(wls)
hv = None acc_dict = {} for name in name_list: acc = Account(name, hive_instance=hv) acc_dict[name] = acc if clear_acc_cache: acc.clear_cache() acc_dict = {} if clear_all_cache: clear_cache() if not shared_instance: del hv.rpc if __name__ == "__main__": hv = Hive() print("Shared instance: " + str(hv)) set_shared_hive_instance(hv) b = Blockchain() account_list = [] for a in b.get_all_accounts(limit=500): account_list.append(a) shared_instance = False clear_acc_cache = False clear_all_cache = False node = "https://api.hive.blog" n = 3 for i in range(1, n + 1): print("%d of %d" % (i, n)) profiling(node, account_list, shared_instance=shared_instance, clear_acc_cache=clear_acc_cache, clear_all_cache=clear_all_cache)
bsteem_times = [] loops = 50 for i in range(0, loops): print(i) opHive = hiveOperations.Transfer(**{ "from": "foo", "to": "baar", "amount": "111.110 HIVE", "memo": "Fooo" }) opBhive = operations.Transfer( **{ "from": "foo", "to": "baar", "amount": Amount("111.110 HIVE", hive_instance=Hive(offline=True)), "memo": "Fooo" }) t_s, t_v = steem_test.doit(ops=opHive) steem_times.append([t_s, t_v]) t_s, t_v = bsteem_test.doit(ops=opBhive) bsteem_times.append([t_s, t_v]) steem_dt = [0, 0] bsteem_dt = [0, 0] for i in range(0, loops): steem_dt[0] += steem_times[i][0] steem_dt[1] += steem_times[i][1] bsteem_dt[0] += bsteem_times[i][0]
def benchmark_node(node, how_many_minutes=10, how_many_seconds=30): block_count = 0 history_count = 0 access_time = 0 follow_time = 0 blockchain_version = u'0.0.0' successful = True error_msg = None start_total = timer() max_batch_size = None threading = False thread_num = 16 authorpermvoter = u"@gtg/hive-pressure-4-need-for-speed|gandalf" [author, permlink, voter] = resolve_authorpermvoter(authorpermvoter) authorperm = construct_authorperm(author, permlink) last_block_id = 19273700 try: hv = Hive(node=node, num_retries=3, num_retries_call=3, timeout=30) blockchain = Blockchain(hive_instance=hv) blockchain_version = hv.get_blockchain_version() last_block = Block(last_block_id, hive_instance=hv) stopTime = last_block.time() + timedelta(seconds=how_many_minutes * 60) total_transaction = 0 start = timer() for entry in blockchain.blocks(start=last_block_id, max_batch_size=max_batch_size, threading=threading, thread_num=thread_num): block_no = entry.identifier block_count += 1 if "block" in entry: trxs = entry["block"]["transactions"] else: trxs = entry["transactions"] for tx in trxs: for op in tx["operations"]: total_transaction += 1 if "block" in entry: block_time = parse_time(entry["block"]["timestamp"]) else: block_time = parse_time(entry["timestamp"]) if block_time > stopTime: last_block_id = block_no break if timer() - start > how_many_seconds or quit_thread: break except NumRetriesReached: error_msg = 'NumRetriesReached' block_count = -1 except KeyboardInterrupt: error_msg = 'KeyboardInterrupt' # quit = True except Exception as e: error_msg = str(e) block_count = -1 try: hv = Hive(node=node, num_retries=3, num_retries_call=3, timeout=30) account = Account("gtg", hive_instance=hv) blockchain_version = hv.get_blockchain_version() start = timer() for acc_op in account.history_reverse(batch_size=100): history_count += 1 if timer() - start > how_many_seconds or quit_thread: break except NumRetriesReached: error_msg = 'NumRetriesReached' history_count = -1 successful = False except KeyboardInterrupt: error_msg = 'KeyboardInterrupt' history_count = -1 successful = False # quit = True except Exception as e: error_msg = str(e) history_count = -1 successful = False try: hv = Hive(node=node, num_retries=3, num_retries_call=3, timeout=30) account = Account("gtg", hive_instance=hv) blockchain_version = hv.get_blockchain_version() start = timer() Vote(authorpermvoter, hive_instance=hv) stop = timer() vote_time = stop - start start = timer() Comment(authorperm, hive_instance=hv) stop = timer() comment_time = stop - start start = timer() Account(author, hive_instance=hv) stop = timer() account_time = stop - start start = timer() account.get_followers() stop = timer() follow_time = stop - start access_time = (vote_time + comment_time + account_time + follow_time) / 4.0 except NumRetriesReached: error_msg = 'NumRetriesReached' access_time = -1 except KeyboardInterrupt: error_msg = 'KeyboardInterrupt' # quit = True except Exception as e: error_msg = str(e) access_time = -1 return {'successful': successful, 'node': node, 'error': error_msg, 'total_duration': timer() - start_total, 'block_count': block_count, 'history_count': history_count, 'access_time': access_time, 'follow_time': follow_time, 'version': blockchain_version}
return opcount, total_duration if __name__ == "__main__": node_setup = 1 threading = True thread_num = 8 timeout = 10 nodes = NodeList() nodes.update_nodes(weights={"block": 1}) node_list = nodes.get_nodes()[:5] vote_result = [] duration = [] hv = Hive(node=node_list, timeout=timeout) b = Blockchain(hive_instance=hv) block = b.get_current_block() block.set_cache_auto_clean(False) opcount, total_duration = stream_votes(hv, threading, thread_num) print("Finished!") block.set_cache_auto_clean(True) cache_len = len(list(block._cache)) start_time = time.time() block.clear_cache_from_expired_items() clear_duration = time.time() - start_time time.sleep(5) cache_len_after = len(list(block._cache)) start_time = time.time() print(str(block._cache)) clear_duration2 = time.time() - start_time
if __name__ == "__main__": hv = Hive( node=["https://testnet.hiveitdev.com"], custom_chains={ "TESTNETHF20": { 'chain_assets': [{ "asset": "@@000000013", "symbol": "HBD", "precision": 3, "id": 0 }, { "asset": "@@000000021", "symbol": "HIVE", "precision": 3, "id": 1 }, { "asset": "@@000000037", "symbol": "VESTS", "precision": 6, "id": 2 }], 'chain_id': '46d82ab7d8db682eb1959aed0ada039a6d49afa1602491f93dde9cac3e8e6c32', 'min_version': '0.20.0', 'prefix': 'TST' } }) print(hv.get_blockchain_version()) print(hv.get_config()["HIVE_CHAIN_ID"])
from bhivegraphenebase.account import PasswordKey, PrivateKey, PublicKey from bhive.hive import Hive from bhive.utils import parse_time, formatTimedelta from bhiveapi.exceptions import NumRetriesReached from bhive.nodelist import NodeList log = logging.getLogger(__name__) logging.basicConfig(level=logging.INFO) password = "******" username = "******" useWallet = False walletpassword = "******" if __name__ == "__main__": testnet_node = "https://testnet.hive.vc" hv = Hive(node=testnet_node) prefix = hv.prefix # curl --data "username=username&password=secretPassword" https://testnet.hive.vc/create if useWallet: hv.wallet.wipe(True) hv.wallet.create(walletpassword) hv.wallet.unlock(walletpassword) active_key = PasswordKey(username, password, role="active", prefix=prefix) owner_key = PasswordKey(username, password, role="owner", prefix=prefix) posting_key = PasswordKey(username, password, role="posting", prefix=prefix) memo_key = PasswordKey(username, password, role="memo", prefix=prefix) active_pubkey = active_key.get_public_key() owner_pubkey = owner_key.get_public_key()