def test_nodes_update(self): nodelist = NodeList() all_nodes = nodelist.get_hive_nodes() nodelist.update_nodes(blockchain_instance=self.bts) nodes = nodelist.get_hive_nodes() self.assertIn(nodes[0], all_nodes) all_nodes = nodelist.get_steem_nodes() nodelist.update_nodes(blockchain_instance=self.bts) nodes = nodelist.get_steem_nodes() self.assertIn(nodes[0], all_nodes)
def test_default_connection(self): nodelist = NodeList() nodelist.update_nodes(steem_instance=Hive(node=nodelist.get_hive_nodes(), num_retries=10)) b2 = Hive( node=nodelist.get_hive_nodes(), nobroadcast=True, ) set_shared_steem_instance(b2) bts = Account("beem") self.assertEqual(bts.blockchain.prefix, "STM")
def test_stm1stm2(self): nodelist = NodeList() nodelist.update_nodes(steem_instance=Hive( node=nodelist.get_hive_nodes(), num_retries=10)) b1 = Steem(node="https://api.steemit.com", nobroadcast=True, num_retries=10) node_list = nodelist.get_hive_nodes() b2 = Hive(node=node_list, nobroadcast=True, num_retries=10) self.assertNotEqual(b1.rpc.url, b2.rpc.url)
def test_hive_nodes(self): nodelist = NodeList() nodelist.update_nodes() hive_nodes = nodelist.get_hive_nodes() for node in hive_nodes: blockchainobject = Hive(node=node) assert blockchainobject.is_hive
def getHiveNodes(): """ Return a list of hive node URLS """ from beem.nodelist import NodeList nodelist = NodeList() nodelist.update_nodes() nodes = nodelist.get_hive_nodes() return nodes
def setUpClass(cls): nodelist = NodeList() cls.bts = Hive( node=nodelist.get_hive_nodes(), nobroadcast=True, num_retries=10 ) set_shared_blockchain_instance(cls.bts)
def setUpClass(cls): nodelist = NodeList() nodelist.update_nodes(steem_instance=Hive(node=nodelist.get_hive_nodes(), num_retries=10)) cls.bts = Hive( node=nodelist.get_nodes(exclude_limited=True), nobroadcast=True, keys=[wif], num_retries=10 ) set_shared_steem_instance(cls.bts)
def setUpClass(cls): nodelist = NodeList() nodelist.update_nodes(steem_instance=Steem(node=nodelist.get_hive_nodes(), num_retries=10)) cls.bts = Steem( node=nodelist.get_hive_nodes(), nobroadcast=True, timeout=30, num_retries=30, ) # from getpass import getpass # self.bts.wallet.unlock(getpass()) set_shared_steem_instance(cls.bts) cls.bts.set_default_account("test") b = Blockchain(steem_instance=cls.bts) num = b.get_current_block_num() # num = 23346630 cls.start = num - 25 cls.stop = num
def main(): load_config() load_users() nodelist = NodeList() nodelist.update_nodes() nodes = nodelist.get_hive_nodes() hive = Hive(wif=config['wif']) set_shared_hive_instance(hive) do_airdrop(hive)
def start(self, authorperm=None, file=None): self.main_window = Tk() self.main_window.title('HiveDiff') self.__main_window_ui = MainWindowUI(self.main_window) self.leftFile = '' self.rightFile = '' self.authorperm = '' self.__main_window_ui.center_window() self.__main_window_ui.create_file_path_labels() self.__main_window_ui.create_text_areas() self.__main_window_ui.create_search_text_entry(self.__findNext) self.__main_window_ui.create_line_numbers() self.__main_window_ui.create_scroll_bars() self.__main_window_ui.create_file_treeview() path_to_my_project = os.getcwd() self.__main_window_ui.add_menu('File', [ {'name': 'Compare Markdown file', 'command': self.__browse_files}, {'name': 'View Post history', 'command': self.__enter_post}, {'name': 'Compare Markdown files in Directory', 'command': self.__browse_directories}, {'name': 'Reload', 'command': self.__reload, 'accelerator': 'Ctrl+R'}, {'separator'}, {'name': 'Exit', 'command': self.__exit, 'accelerator': 'Alt+F4'} ]) self.__main_window_ui.add_menu('Edit', [ {'name': 'Find', 'command': self.__startFindText, 'accelerator': 'Ctrl+F'}, {'separator'}, {'name': 'Cut', 'command': self.__cut, 'accelerator': 'Ctrl+X'}, {'name': 'Copy', 'command': self.__copy, 'accelerator': 'Ctrl+C'}, {'name': 'Paste', 'command': self.__paste, 'accelerator': 'Ctrl+P'}, {'separator'}, {'name': 'Go To Line', 'command': self.__goToLine, 'accelerator': 'Ctrl+G'} ]) self.__main_window_ui.add_menu('Help', [ {'name': 'About', 'command': self.__about}, ]) self.__main_window_ui.fileTreeView.bind('<<TreeviewSelect>>', lambda *x:self.treeViewItemSelected()) nodelist = NodeList() nodelist.update_nodes() hive = Hive(node=nodelist.get_hive_nodes()) set_shared_blockchain_instance(hive) self.leftFile = '' self.rightFile = file if file else '' self.filesChanged() if authorperm != '' and authorperm is not None: self.authorperm = authorperm self.__resolve_authorperm() self.__bind_key_shortcuts() self.main_window.mainloop()
def setUpClass(cls): nodelist = NodeList() nodelist.update_nodes(blockchain_instance=Hive( node=nodelist.get_hive_nodes(), num_retries=10)) node_list = nodelist.get_hive_nodes() cls.bts = Hive(node=node_list, use_condenser=True, nobroadcast=True, unsigned=True, keys={"active": wif}, num_retries=10) acc = Account("fullnodeupdate", blockchain_instance=cls.bts) comment = Comment(acc.get_blog_entries(limit=5)[0], blockchain_instance=cls.bts) cls.authorperm = comment.authorperm [author, permlink] = resolve_authorperm(cls.authorperm) cls.author = author cls.permlink = permlink cls.category = comment.category cls.title = comment.title
def hour_active(chain): nodelist = NodeList() nodelist.update_nodes() if chain=='steem': s = Steem(node=nodelist.get_steem_nodes()) else: s = Steem(node=nodelist.get_hive_nodes()) b=Blockchain(s) bl_=[] bl_num=int(b.get_current_block_num()) bl_num_=bl_num-1250 bl=b.blocks(bl_num_,bl_num) for i in bl: bl_.append(i['transactions']) x=('follower','account','voter','from','author') account=[] new=[] for i in x: acc=re.findall('"'+i+'":"(.+?)"',str(bl_)) for l in acc: if l not in account: account.append(l) if chain=='steem': file=open('active_acc_steem.txt','r') old=file.readlines() file.close() file=open('active_acc_steem.txt','a') for i in account: if i+'\n' not in old: file.write(str(i)+'\n') new.append(i) file.close() else: file=open('active_acc_hive.txt','r') old=file.readlines() file.close() file=open('active_acc_hive.txt','a') for i in account: if i+'\n' not in old: file.write(str(i)+'\n') new.append(i) file.close() print ('one hour accounts '+chain,len(account)) print ('one hour brand new '+chain,len(new)) print ('total ACTIVE accounts '+chain,len(old))
def set_node_list(chain_type=None): nodelist = NodeList() nodelist.update_nodes() chain = None if chain_type == 'steemit': steem_nodes = nodelist.get_steem_nodes() chain = Steem(node=steem_nodes) chain.set_default_nodes(steem_nodes) elif chain_type == 'hive': nodelist = NodeList() nodelist.update_nodes() hive_nodes = nodelist.get_hive_nodes() chain = Hive(node=hive_nodes) chain.set_default_nodes(hive_nodes) set_shared_blockchain_instance(chain) return chain
def get_friends_data(username, follow_type): # Setup node list nodelist = NodeList() nodelist.update_nodes() nodes = nodelist.get_hive_nodes() hive = Hive(node=nodes) hive.set_default_nodes(nodes) # logging.warning(hive.config.items()) # Create account object try: account = Account(username) logging.warning(account) except Exception as e: logging.warning(e) return {} followers = account.get_followers() following = account.get_following() if follow_type == 'followers': return make_dict(followers, following) else: return make_dict(following, followers)
self.setLevel(logging.DEBUG) elif level == "WARNING": self.setLevel(logging.WARNING) elif level == "ERROR": self.setLevel(logging.ERROR) elif level == "CRITICAL": self.setLevel(logging.CRITICAL) logger = Logger(name=name_logger) ### SETUP BEEM LIB STUFF UTC_TIMEZONE = tz.UTC NODELIST_INSTANCE = NodeList() NODELIST_INSTANCE.update_nodes() HIVE_INSTANCE = Hive(node=NODELIST_INSTANCE.get_hive_nodes()) BLOCKCHAIN_INSTANCE = Blockchain(blockchain_instance=HIVE_INSTANCE) not_today = datetime.datetime.now(UTC_TIMEZONE) - datetime.timedelta(days=days, hours=1) start = datetime.datetime(not_today.year, not_today.month, not_today.day) today = datetime.datetime.now(UTC_TIMEZONE) stop = datetime.datetime(today.year, today.month, today.day) start_block_id = BLOCKCHAIN_INSTANCE.get_estimated_block_num(start, accurate=True) stop_block_id = BLOCKCHAIN_INSTANCE.get_estimated_block_num(stop, accurate=True) logger.info(f"start time: {start}")
def main(): parser = argparse.ArgumentParser() parser.add_argument("config", help="Config file in JSON format") parser.add_argument("--logconfig", help="Logger Config file in JSON format", default='logger.json') parser.add_argument("--datadir", help="Data storage dir", default='.') parser.add_argument('--list-accounts', action='store_true') args = parser.parse_args() setup_logging(default_path=args.logconfig) logger.info("Loading config: %s" % str(args.config)) config = json.loads(open(os.path.abspath(args.config)).read()) datadir = args.datadir nodelist = NodeList() nodelist.update_nodes() hive = Hive(node=nodelist.get_hive_nodes(), num_retries=5, call_num_retries=3, timeout=15) blockchain = Blockchain(blockchain_instance=hive) logger.info(str(hive)) data_file = os.path.join(datadir, 'data.db') bot = DelegationOnboardBot(config, data_file, hive) data_db = read_data(data_file) if "last_block_num" in data_db: last_block_num = data_db["last_block_num"] else: last_block_num = 0 if "last_block_num" in data_db: start_block = data_db["last_block_num"] + 1 if start_block == 35922615: start_block += 1 logger.info("Start block_num: %d" % start_block) stop_block = start_block + 100 if stop_block > blockchain.get_current_block_num(): stop_block = blockchain.get_current_block_num() else: start_block = None stop_block = None if args.list_accounts: t = PrettyTable([ "account", "timestamp", "muted", "hp", "del. hp", "del. timestamp", "rc_comments", "del revoked" ]) t.align = "l" for acc_name in data_db["accounts"]: acc = data_db["accounts"][acc_name] if acc["timestamp"] is None: timestamp = "" else: timestamp = formatTimeString(acc["timestamp"]) if acc["delegation_timestamp"] is None: del_timestamp = "" else: del_timestamp = formatTimeString(acc["delegation_timestamp"]) t.add_row([ acc_name, timestamp, acc["muted"], acc["hp"], acc["delegated_hp"], del_timestamp, round(acc["rc_comments"], 3), acc["delegation_revoked"] ]) print(t) return logger.info("starting delegation manager for onboarding..") block_counter = None last_print_stop_block = stop_block while True: if start_block is not None and stop_block is not None: if last_print_stop_block is not None and stop_block - last_print_stop_block > 1: last_print_stop_block = stop_block last_block_num = bot.run(start_block, stop_block) # Update nodes once a day if block_counter is None: block_counter = last_block_num elif last_block_num - block_counter > 20 * 60 * 24: nodelist.update_nodes() hive = Hive(node=nodelist.get_hive_nodes(), num_retries=5, call_num_retries=3, timeout=15) bot.hive = hive start_block = last_block_num + 1 stop_block = start_block + 100 if stop_block > blockchain.get_current_block_num(): stop_block = blockchain.get_current_block_num() store_data(data_file, "last_block_num", last_block_num) time.sleep(3)
def main(args=None): args = parse_args(args) blockchain = args.blockchain nodelist = NodeList() nodelist.update_nodes(weights={"block": 1}) if blockchain == "hive" or blockchain is None: max_batch_size = 50 threading = False thread_num = 16 block_debug = 1000 nodes = nodelist.get_hive_nodes() blk_inst = Hive(node=nodes, num_retries=3, num_retries_call=3, timeout=30) elif blockchain == "blurt": max_batch_size = None threading = False thread_num = 8 block_debug = 20 nodes = [ "https://api.blurt.blog", "https://rpc.blurtworld.com", "https://rpc.blurtworld.com" ] blk_inst = Blurt(node=nodes, num_retries=3, num_retries_call=3, timeout=30) elif blockchain == "steem": max_batch_size = 50 threading = False thread_num = 16 block_debug = 1000 nodes = nodelist.get_steem_nodes() blk_inst = Steem(node=nodes, num_retries=3, num_retries_call=3, timeout=30) else: raise Exception("Wrong parameter, can be hive, blurt or steem") print(blk_inst) block_count = 0 total_ops = 0 total_virtual_ops = 0 total_trx = 0 blocksperday = 20 * 60 * 24 blockchain = Blockchain(blockchain_instance=blk_inst, ) current_block_num = blockchain.get_current_block_num() last_block_id = current_block_num - blocksperday last_block = Block(last_block_id, blockchain_instance=blk_inst) stopTime = last_block.time() + timedelta(seconds=60 * 60 * 24) start = timer() for entry in blockchain.blocks(start=last_block_id, max_batch_size=max_batch_size, threading=threading, thread_num=thread_num): if "block" in entry: block_time = parse_time(entry["block"]["timestamp"]) else: block_time = entry["timestamp"] if block_time > stopTime: break block_count += 1 if "block" in entry: trxs = entry["block"]["transactions"] else: trxs = entry["transactions"] for tx in trxs: total_trx += 1 for op in tx["operations"]: total_ops += 1 ops_per_day = total_ops / block_count * blocksperday if block_count % (block_debug) == 0: print("%d blocks remaining... estimated ops per day: %.1f" % (blocksperday - block_count, ops_per_day)) duration = timer() - start stopTime = last_block.time() + timedelta(seconds=60 * 60 * 24) start = timer() for entry in blockchain.blocks(start=last_block_id, max_batch_size=max_batch_size, threading=threading, thread_num=thread_num, only_virtual_ops=True): block_time = entry["timestamp"] if block_time > stopTime: break for tx in entry["operations"]: for op in tx["op"]: total_virtual_ops += 1 duration = timer() - start print("Received %.2f blocks/s." % (block_count / duration)) print("Bocks: %d, duration %.3f s" % (block_count, duration)) print("Operations per day: %d" % total_ops) print("Trx per day: %d" % total_trx) print("Virtual Operations per day: %d" % total_virtual_ops)
from beem.hive import Hive from beem.nodelist import NodeList nodelist = NodeList() nodelist.update_nodes() hive_instance = Hive(node=nodelist.get_hive_nodes())
elif self.db_type == "pickle": return os.path.isfile(filename) elif self.db_type == "deepdish": return os.path.isfile(filename) elif self.db_type == "sqlite": db = dataset.connect('sqlite:///%s' % (filename)) if self.account in db: return True else: return False if __name__ == "__main__": nodes = NodeList() nodes.update_nodes() stm = Steem(node=nodes.get_hive_nodes()) set_shared_steem_instance(stm) account_name = "holger80" account = Account(account_name, steem_instance=stm) path = QStandardPaths.writableLocation(QStandardPaths.CacheLocation) print(path) db_type = "shelve" db = Database(db_type, path, account_name) if not db.has_account_hist(): print("new account") ops = db.get_acc_hist() db.store_account_hist(ops) else: print("loading db") ops = db.load_account_hist()
def get_hive_nodes(): nodelist = NodeList() nodes = nodelist.get_hive_nodes() nodelist.update_nodes(blockchain_instance=Hive(node=nodes, num_retries=10)) return nodelist.get_hive_nodes()
def main(args=None): args = parse_args(args) blockchain = args.blockchain nodelist = NodeList() nodelist.update_nodes(weights={"block": 1}) if blockchain == "hive" or blockchain is None: max_batch_size = 50 threading = False thread_num = 16 block_debug = 1000 nodes = nodelist.get_hive_nodes() blk_inst = Hive(node=nodes, num_retries=3, num_retries_call=3, timeout=30) elif blockchain == "blurt": max_batch_size = None threading = False thread_num = 8 block_debug = 20 nodes = ["https://rpc.blurt.buzz/", "https://api.blurt.blog", "https://rpc.blurtworld.com", "https://rpc.blurtworld.com"] blk_inst = Blurt(node=nodes, num_retries=3, num_retries_call=3, timeout=30) elif blockchain == "steem": max_batch_size = 50 threading = False thread_num = 16 block_debug = 1000 nodes = nodelist.get_steem_nodes() blk_inst = Steem(node=nodes, num_retries=3, num_retries_call=3, timeout=30) else: raise Exception("Wrong parameter, can be hive, blurt or steem") print(blk_inst) block_count = 0 total_ops = 0 total_trx = 0 duration_s = 60 * 60 * 1 blocksperday = int(duration_s / 3) blockchain = Blockchain(blockchain_instance=blk_inst, ) current_block_num = blockchain.get_current_block_num() last_block_id = current_block_num - blocksperday last_block = Block(last_block_id, blockchain_instance=blk_inst) stopTime = last_block.time() + timedelta(seconds=duration_s) start = timer() op_stats = {} for entry in blockchain.blocks(start=last_block_id, max_batch_size=max_batch_size, threading=threading, thread_num=thread_num): if "block" in entry: block_time = parse_time(entry["block"]["timestamp"]) else: block_time = entry["timestamp"] if block_time > stopTime: break block_count += 1 if "block" in entry: trxs = entry["block"]["transactions"] else: trxs = entry["transactions"] for tx in trxs: total_trx += 1 for op in tx["operations"]: if "_operation" in op["type"]: op_type = op["type"][:-10] else: op_type = op["type"] if op_type in op_stats: op_stats[op_type] += 1 else: op_stats[op_type] = 1 total_ops += 1 ops_per_day = total_ops / block_count * blocksperday if block_count % (block_debug) == 0: print("%d blocks remaining... estimated ops per day: %.1f" % (blocksperday - block_count, ops_per_day)) duration = timer() - start t = PrettyTable(["Type", "Count", "percentage"]) t.align = "l" op_list = [] for o in op_stats: op_list.append({"type": o, "n": op_stats[o], "perc": op_stats[o] / total_ops * 100}) op_list_sorted = sorted(op_list, key=lambda x: x['n'], reverse=True) for op in op_list_sorted: t.add_row([op["type"], op["n"], "%.2f %%" % op["perc"]]) print(t)
def run(self, start_block, stop_block): self.hive.wallet.unlock(self.config["wallet_password"]) self.blockchain = Blockchain(mode='head', blockchain_instance=self.hive) current_block = self.blockchain.get_current_block_num() if stop_block is None or stop_block > current_block: stop_block = current_block if start_block is None: start_block = current_block last_block_num = current_block - 1 else: last_block_num = start_block - 1 self.log_data["start_block_num"] = start_block for op in self.blockchain.stream(start=start_block, stop=stop_block, opNames=["comment"]): self.log_data = print_block_log(self.log_data, op, self.config["print_log_at_block"]) last_block_num = op["block_num"] if op["type"] == "comment": token = None for key in self.token_config: if op["body"].find( self.token_config[key]["comment_command"]) >= 0: token = key if token is None: continue if op["author"] == self.token_config[token]["token_account"]: continue cnt = 0 c_comment = None c_parent = None authorperm = construct_authorperm(op) use_tags_api = True while c_comment is None and cnt < 10: cnt += 1 try: c_comment = Comment(authorperm, use_tags_api=use_tags_api, blockchain_instance=self.hive) c_comment.refresh() except: if cnt > 5: use_tags_api = False nodelist = NodeList() nodelist.update_nodes() self.hive = Hive(node=nodelist.get_hive_nodes(), num_retries=5, call_num_retries=3, timeout=15) time.sleep(3) if cnt == 10 or c_comment is None: logger.warn("Could not read %s/%s" % (op["author"], op["permlink"])) continue if 'depth' in c_comment: if c_comment['depth'] == 0: continue else: if c_comment["parent_author"] == '': continue if abs((c_comment["created"] - op['timestamp']).total_seconds()) > 9.0: logger.warn("Skip %s, as edited" % c_comment["authorperm"]) continue already_voted = False if self.token_config[token]["upvote_token_receiver"]: parent_identifier = construct_authorperm( c_comment["parent_author"], c_comment["parent_permlink"]) c_parent = Comment(parent_identifier, blockchain_instance=self.hive) for v in c_parent.get_votes(raw_data=True): if self.token_config[token]["token_account"] == v[ "voter"]: already_voted = True else: for v in c_comment.get_votes(raw_data=True): if self.token_config[token]["token_account"] == v[ "voter"]: already_voted = True if already_voted: continue already_replied = None cnt = 0 if self.token_config[token]["usage_upvote_percentage"] == 0: while already_replied is None and cnt < 5: cnt += 1 try: already_replied = False for r in c_comment.get_all_replies(): if r["author"] == self.token_config[token][ "token_account"]: already_replied = True except: already_replied = None self.hive.rpc.next() if already_replied is None: already_replied = False for r in c_comment.get_all_replies(): if r["author"] == self.token_config[token][ "token_account"]: already_replied = True if already_replied: continue muting_acc = Account(self.token_config[token]["token_account"], blockchain_instance=self.hive) blocked_accounts = muting_acc.get_mutings() if c_comment["author"] in blocked_accounts: logger.info("%s is blocked" % c_comment["author"]) continue # Load bot token balance bot_wallet = Wallet(self.token_config[token]["token_account"], blockchain_instance=self.hive) symbol = bot_wallet.get_token( self.token_config[token]["symbol"]) # parse amount when user_can_specify_amount is true amount = self.token_config[token]["default_amount"] if self.token_config[token]["user_can_specify_amount"]: start_index = c_comment["body"].find( self.token_config[token]["comment_command"]) stop_index = c_comment["body"][start_index:].find("\n") if stop_index >= 0: command = c_comment["body"][start_index + 1:start_index + stop_index] else: command = c_comment["body"][start_index + 1:] command_args = command.replace(' ', ' ').split(" ")[1:] if len(command_args) > 0: try: amount = float(command_args[0]) except Exception as e: exc_type, exc_obj, exc_tb = sys.exc_info() fname = os.path.split( exc_tb.tb_frame.f_code.co_filename)[1] logger.warn("%s - %s - %s" % (str(exc_type), str(fname), str(exc_tb.tb_lineno))) logger.info("Could not parse amount") if self.token_config[token][ "maximum_amount_per_comment"] and amount > self.token_config[ token]["maximum_amount_per_comment"]: amount = self.token_config[token][ "maximum_amount_per_comment"] if not self.config["no_broadcast"] and self.hive.wallet.locked( ): self.hive.wallet.unlock(self.config["wallet_password"]) self.log_data["new_commands"] += 1 wallet = Wallet(c_comment["author"], blockchain_instance=self.hive) token_in_wallet = wallet.get_token( self.token_config[token]["symbol"]) balance = 0 if token_in_wallet is not None: logger.info(token_in_wallet) if self.token_config[token]["count_only_staked_token"]: balance = 0 else: balance = float(token_in_wallet["balance"]) if "stake" in token_in_wallet: balance += float(token_in_wallet['stake']) if 'delegationsIn' in token_in_wallet and float( token_in_wallet['delegationsIn']) > 0: balance += float(token_in_wallet['delegationsIn']) if 'pendingUnstake' in token_in_wallet and float( token_in_wallet['pendingUnstake']) > 0: balance += float(token_in_wallet['pendingUnstake']) if balance > self.token_config[token][ "min_token_in_wallet"]: if self.token_config[token][ "token_in_wallet_for_each_outgoing_token"] > 0: max_token_to_give = int( balance / self.token_config[token] ["token_in_wallet_for_each_outgoing_token"]) else: max_token_to_give = self.token_config[token][ "maximum_amount_per_comment"] else: max_token_to_give = 0 else: max_token_to_give = 0 logger.info("token to give for %s: %f" % (c_comment["author"], max_token_to_give)) db_data = read_data(self.data_file) if "accounts" in db_data and c_comment["author"] in db_data[ "accounts"] and token in db_data["accounts"][ c_comment["author"]]: if db_data["accounts"][c_comment["author"]][token][ "last_date"] == date.today( ) and self.token_config[token][ "token_in_wallet_for_each_outgoing_token"] > 0: max_token_to_give = max_token_to_give - db_data[ "accounts"][c_comment["author"]][token]["amount"] if amount > max_token_to_give: amount = max_token_to_give if amount > self.token_config[token][ "maximum_amount_per_comment"]: amount = self.token_config[token][ "maximum_amount_per_comment"] if token_in_wallet is None or balance < self.token_config[ token]["min_token_in_wallet"]: reply_body = self.token_config[token]["fail_reply_body"] elif max_token_to_give < 1: reply_body = self.token_config[token][ "no_token_left_for_today"] elif c_comment["parent_author"] == c_comment["author"]: reply_body = "You cannot sent token to yourself." elif float(symbol["balance"]) < amount: reply_body = self.token_config[token]["no_token_left_body"] else: if "{}" in self.token_config[token]["sucess_reply_body"]: reply_body = (self.token_config[token] ["sucess_reply_body"]).format( c_comment["parent_author"]) else: reply_body = self.token_config[token][ "sucess_reply_body"] if "{}" in self.token_config[token]["token_memo"]: token_memo = ( self.token_config[token]["token_memo"]).format( c_comment["author"]) else: token_memo = self.token_config[token]["token_memo"] sendwallet = Wallet( self.token_config[token]["token_account"], blockchain_instance=self.hive) try: logger.info( "Sending %.2f %s to %s" % (amount, self.token_config[token]["symbol"], c_comment["parent_author"])) sendwallet.transfer(c_comment["parent_author"], amount, self.token_config[token]["symbol"], token_memo) if "accounts" in db_data: accounts = db_data["accounts"] else: accounts = {} if c_comment["author"] not in accounts: accounts[c_comment["author"]] = {} accounts[c_comment["author"]][token] = { "last_date": date.today(), "n_comments": 1, "amount": amount } elif token not in accounts[c_comment["author"]]: accounts[c_comment["author"]][token] = { "last_date": date.today(), "n_comments": 1, "amount": amount } else: if accounts[c_comment["author"]][token][ "last_date"] < date.today(): accounts[c_comment["author"]][token] = { "last_date": date.today(), "n_comments": 1, "amount": amount } else: accounts[c_comment["author"]][token][ "n_comments"] += 1 accounts[c_comment["author"]][token][ "amount"] += amount store_data(self.data_file, "accounts", accounts) logger.info( "%s - %s" % (c_comment["author"], str(accounts[c_comment["author"]][token]))) except Exception as e: exc_type, exc_obj, exc_tb = sys.exc_info() fname = os.path.split( exc_tb.tb_frame.f_code.co_filename)[1] logger.warn( "%s - %s - %s" % (str(exc_type), str(fname), str(exc_tb.tb_lineno))) logger.warn("Could not send %s token" % self.token_config[token]["symbol"]) continue reply_identifier = construct_authorperm( c_comment["parent_author"], c_comment["parent_permlink"]) if self.config["no_broadcast"]: logger.info("%s" % reply_body) else: try: self.hive.post( "", reply_body, author=self.token_config[token]["token_account"], reply_identifier=reply_identifier) if self.token_config[token][ "usage_upvote_percentage"] <= 0: time.sleep(5) self.hive.post( "", "Command accepted!", author=self.token_config[token] ["token_account"], reply_identifier=c_comment["authorperm"]) except Exception as e: exc_type, exc_obj, exc_tb = sys.exc_info() fname = os.path.split( exc_tb.tb_frame.f_code.co_filename)[1] logger.warn( "%s - %s - %s" % (str(exc_type), str(fname), str(exc_tb.tb_lineno))) logger.warn("Could not reply to post") continue if self.token_config[token]["usage_upvote_percentage"] > 0: time.sleep(5) upvote_percentge = self.token_config[token][ "usage_upvote_percentage"] if self.token_config[token]["scale_upvote_weight"]: upvote_percentge = upvote_percentge * amount / self.token_config[ token]["maximum_amount_per_comment"] print("Upvote with %.2f %%" % upvote_percentge) if self.token_config[token]["upvote_token_receiver"]: if c_parent is None: c_parent = Comment( parent_identifier, blockchain_instance=self.hive) try: c_parent.upvote(upvote_percentge, voter=self.token_config[token] ["token_account"]) except Exception as e: exc_type, exc_obj, exc_tb = sys.exc_info() fname = os.path.split( exc_tb.tb_frame.f_code.co_filename)[1] logger.warn("%s - %s - %s" % (str(exc_type), str(fname), str(exc_tb.tb_lineno))) logger.warn("Could not upvote comment") else: try: c_comment.upvote(upvote_percentge, voter=self.token_config[token] ["token_account"]) except Exception as e: exc_type, exc_obj, exc_tb = sys.exc_info() fname = os.path.split( exc_tb.tb_frame.f_code.co_filename)[1] logger.warn("%s - %s - %s" % (str(exc_type), str(fname), str(exc_tb.tb_lineno))) logger.warn("Could not upvote comment") time.sleep(4) return last_block_num
def main(): parser = argparse.ArgumentParser() parser.add_argument("config", help="Config file in JSON format") parser.add_argument("--logconfig", help="Logger Config file in JSON format", default='logger.json') parser.add_argument("--datadir", help="Data storage dir", default='.') args = parser.parse_args() setup_logging(default_path=args.logconfig) logger.info("Loading config: %s" % str(args.config)) config = json.loads(open(args.config).read()) datadir = args.datadir nodelist = NodeList() nodelist.update_nodes() hive = Hive(node=nodelist.get_hive_nodes(), num_retries=5, call_num_retries=3, timeout=15) logger.info(str(hive)) data_file = os.path.join(datadir, 'data.db') bot = Distribubot(config, data_file, hive) data_file = os.path.join(datadir, 'data.db') data_db = read_data(data_file) if "last_block_num" in data_db: last_block_num = data_db["last_block_num"] else: last_block_num = 0 if "comment_queue" in data_db: comment_queue = data_db["comment_queue"] else: comment_queue = {} if "last_block_num" in data_db: start_block = data_db["last_block_num"] + 1 if start_block == 35922615: start_block += 1 logger.info("Start block_num: %d" % start_block) stop_block = start_block + 100 else: start_block = None stop_block = None logger.info("starting token distributor..") block_counter = None last_print_stop_block = stop_block while True: if start_block is not None and stop_block is not None: if stop_block - last_print_stop_block > 1: logger.info("%d - %d" % (start_block, stop_block)) last_print_stop_block = stop_block last_block_num = bot.run(start_block, stop_block) # Update nodes once a day if block_counter is None: block_counter = last_block_num elif last_block_num - block_counter > 20 * 60 * 24: nodelist.update_nodes() hive = Hive(node=nodelist.get_hive_nodes(), num_retries=5, call_num_retries=3, timeout=15) bot.hive = hive start_block = last_block_num + 1 stop_block = start_block + 100 store_data(data_file, "last_block_num", last_block_num) time.sleep(3)
# This Python file uses the following encoding: utf-8 # (c) holger80 from __future__ import absolute_import from __future__ import division from __future__ import print_function from __future__ import unicode_literals from beem import Steem from beem.comment import Comment from beem.nodelist import NodeList from hiveengine.wallet import Wallet import time if __name__ == "__main__": nodelist = NodeList() nodelist.update_nodes() stm = Steem(node=nodelist.get_hive_nodes()) # edit here upvote_account = "beembot" upvote_token = "DRAGON" token_weight_factor = 100 # multiply token amount to get weight min_token_amount = 0.01 max_post_age_days = 3 whitelist = [] # When empty, the whitelist is disabled blacklist_tags = [] # When empty, the tag blacklist is disabled reply_comment = "" # When empty, no reply comment is created only_main_posts = True stm.wallet.unlock("wallet-passwd") wallet = Wallet(upvote_account, steem_instance=stm)
data["sell_asset"] = sell_asset2 df = pd.DataFrame(data) writer = pd.ExcelWriter(filename, engine='xlsxwriter') df.to_excel(writer, sheet_name=sheet_name, startrow=0, header=True, index=False) writer.save() if __name__ == "__main__": nodelist = NodeList() nodelist.update_nodes() # stm = Steem(node=nodelist.get_steem_nodes()) stm = Hive(node=nodelist.get_hive_nodes()) print(stm) account_name = "holger80" data_account_name = "hive_holger80_powered_up" symbol = "HIVE" hive_fork_block = 41818753 has_fork = True limit_to_year = True current_year = 2020 xls_filename = "%s_%d.xlsx" % (data_account_name, current_year) account = Account(account_name, blockchain_instance=stm) ops_dict = {} _ids = {} for ops in account.history():
from beem import Hive from beem import Steem from beem.nodelist import NodeList nodelist = NodeList() nodelist.update_nodes() HIVE_INSTANCE = Hive(node=nodelist.get_hive_nodes()) STEEM_INSTANCE = Steem(node=nodelist.get_steem_nodes())