cnt2 += 1
try:
c = Comment(authorperm, steem_instance=stm)
except:
continue
cnt3 = 0
for vote in c["active_votes"]:
cnt3 += 1
if int(vote["rshares"]) == 0:
continue
if (addTzInfo(datetime.utcnow()) - (vote["time"])
).total_seconds() / 60 / 60 / 24 <= 7:
continue
if vote["voter"] not in member_data:
continue
if authorperm in comments_transfer and stm.rshares_to_sbd(
int(vote["rshares"])) >= 0.05:
try:
if cnt3 % 10 == 0:
print("%d/%d votes" %
(cnt3, len(c["active_votes"])))
block_num = b.get_estimated_block_num(
vote["time"])
current_block_num = b.get_current_block_num()
transaction = None
block_search_list = [
0, 1, -1, 2, -2, 3, -3, 4, -4, 5, -5
]
block_cnt = 0
while transaction is None and block_cnt < len(
block_search_list):
if block_num + block_search_list[
def outgoing_from_account(self):
nodes = NodeList().get_nodes()
stm = Steem(node=nodes)
set_shared_steem_instance(stm)
#list to store dictionary variables
self.vote_list = []
account = (self.account or input("Downvoter User Account? "))
try:
downvoter_account = Account(account)
except AccountDoesNotExistsException:
print(
'The specified account does not exist on the Steem blockchain.'
)
sys.exit(1)
#prompts to be used for datetime variable in format.
if (self.stop_date == None):
#input option to enable input of self.start_date
stop_option = input("Would you like to specify stop date? y/n ")
if (stop_option == 'y'):
self.stop_date = prompt_start_stop_time()
else:
self.stop_date = None
if (self.start_date == None):
#input option to enable input of self.start_date
start_option = input("Would you like to specify start date? y/n ")
#start date prompts
if (start_option == 'y'):
self.start_date = prompt_start_stop_time()
else:
self.start_date = None
try:
if type(self.start_date
) is not datetime.datetime and self.start_date != None:
raise TypeError("Improper start_date format!")
except TypeError as e:
print(e)
sys.exit(1)
try:
if type(self.stop_date
) is not datetime.datetime and self.stop_date != None:
raise TypeError("Improper stop_date format!")
except TypeError as e:
print(e)
sys.exit(1)
start_v_ops = downvoter_account.estimate_virtual_op_num(
self.start_date or datetime.datetime.utcnow())
stop_v_ops = downvoter_account.estimate_virtual_op_num(
self.stop_date or datetime.datetime(1969, 12, 31, 23, 59, 59))
start_stop_op_dif = start_v_ops - stop_v_ops
if (start_stop_op_dif > 10000):
print(
"Operations Scope exceeds Get_Account_History limit. Splitting into multiple calls with index."
)
hist_index = 10000
while hist_index <= start_stop_op_dif:
for vote in (downvoter_account.get_account_history(
hist_index,
10000,
start=self.start_date,
stop=self.stop_date,
only_ops=['vote'])):
if vote['voter'] == downvoter_account.name and vote[
'weight'] < 0:
try:
downvote = downvoter_account.get_vote(
vote['author'] + '/' + vote['permlink'])
downvoted_post = Comment(vote['author'] + '/' +
vote['permlink'])
except ContentDoesNotExistsException:
print(vote['permlink'] +
"Does Not Exist! Skipping.")
continue
pending_payout_value = downvoted_post[
'pending_payout_value']
downvote_sbd_amount = round(
stm.rshares_to_sbd(downvote['rshares']), 3)
link = '[Comment](https://steemit.com/@' + downvoted_post.identifier + ')'
report_dict = {
'Downvoter': '@' + vote['voter'],
'Comment': link,
'SBD amount': str(downvote_sbd_amount),
'rshares': downvote['rshares'],
'Remaining Rewards': str(pending_payout_value),
'Timestamp': vote['timestamp'],
'ID': vote['_id']
}
self.vote_list.append(report_dict)
hist_index += 1000
else:
for vote in (downvoter_account.get_account_history(
-1,
10000,
start=self.start_date,
stop=self.stop_date,
only_ops=['vote'])):
if vote['voter'] == downvoter_account.name and vote[
'weight'] < 0:
try:
downvote = downvoter_account.get_vote(vote['author'] +
'/' +
vote['permlink'])
downvoted_post = Comment(vote['author'] + '/' +
vote['permlink'])
except ContentDoesNotExistsException:
print(vote['permlink'] + "Does Not Exist! Skipping.")
continue
pending_payout_value = downvoted_post[
'pending_payout_value']
downvote_sbd_amount = round(
stm.rshares_to_sbd(downvote['rshares']), 3)
link = '[Comment](https://steemit.com/@' + downvoted_post.identifier + ')'
report_dict = {
'Downvoter': '@' + vote['voter'],
'Comment': link,
'SBD amount': str(downvote_sbd_amount),
'rshares': downvote['rshares'],
'Remaining Rewards': str(pending_payout_value),
'Timestamp': vote['timestamp'],
'ID': vote['_id']
}
self.vote_list.append(report_dict)
#remove duplicates
self.vote_list = [
dict(t) for t in {tuple(d.items())
for d in self.vote_list}
]
export_csv('outgoing_downvote_report', self.vote_list)
return self.vote_list
member_data[ops["author"]]["last_comment"] = c["created"]
status_command = c.body.find("!sbi status")
if status_command > -1 and abs(
(ops["timestamp"] - c["created"]).total_seconds()) <= 10:
rshares_denom = member_data[
ops["author"]]["rewarded_rshares"] + member_data[
ops["author"]]["balance_rshares"]
reply_body = "Hi @%s!\n\n" % ops["author"]
reply_body += "* you have %d units and %d bonus units\n" % (
member_data[ops["author"]]["shares"],
member_data[ops["author"]]["bonus_shares"])
reply_body += "* your rshares balance is %d or %.3f $\n" % (
member_data[ops["author"]]["balance_rshares"],
stm.rshares_to_sbd(
member_data[ops["author"]]["balance_rshares"]))
if member_data[ops["author"]]["comment_upvote"] == 0:
rshares = member_data[ops["author"]][
"balance_rshares"] / comment_vote_divider
if rshares > minimum_vote_threshold:
reply_body += "* your next SBI upvote is predicted to be %.3f $\n" % (
stm.rshares_to_sbd(rshares))
else:
reply_body += "* you need to wait until your upvote value (current value: %.3f $) is above %.3f $\n" % (
stm.rshares_to_sbd(rshares),
stm.rshares_to_sbd(minimum_vote_threshold))
else:
# rshares = member_data[ops["author"]]["balance_rshares"] / (comment_vote_divider ** 2)
# reply_body += "* as you did not wrote a post within the last 7 days, your comments will be upvoted.\n"
if rshares > minimum_vote_threshold * 20:
class Beem:
def __init__(self, bot, settings):
self.bot = bot
self.settings = settings
self.stm = Steem()
def _is_admin(self, member, channel, guild):
# Check for admin/bot-admin
isAdmin = member.permissions_in(channel).administrator
if not isAdmin:
checkAdmin = self.settings.getServerStat(guild, "AdminArray")
for role in member.roles:
for aRole in checkAdmin:
# Get the role that corresponds to the id
if str(aRole['ID']) == str(role.id):
isAdmin = True
return isAdmin
@commands.command(pass_context=True)
async def account(self, ctx, *, account: str = None):
"""Retuns information about an account"""
if account is None:
regAccount = self.settings.getUserStat(ctx.message.author,
ctx.message.guild,
"SteemAccount")
if regAccount is not None and regAccount != "":
account = regAccount
else:
account = ctx.message.author
account = str(account).split('#')[0]
a = Account(account, steem_instance=self.stm)
response = a.print_info(return_str=True)
await ctx.channel.send("```" + response + "```")
@commands.command(pass_context=True)
async def register(self, ctx, *, account: str = None):
"""Register your steemit name"""
if account is None:
await ctx.channel.send("I do nothing!")
return
try:
Account(account, steem_instance=self.stm)
except:
await ctx.channel.send("Could not register %s!" % account)
return
self.settings.setUserStat(ctx.message.author, ctx.message.guild,
"SteemAccount", account)
await ctx.channel.send("Registered!")
@commands.command(pass_context=True)
async def updatenodes(self, ctx):
"""Retuns information about the current node"""
t = PrettyTable(["node", "Version", "score"])
t.align = "l"
nodelist = NodeList()
nodelist.update_nodes(steem_instance=self.stm)
nodes = nodelist.get_nodes()
sorted_nodes = sorted(nodelist,
key=lambda node: node["score"],
reverse=True)
for node in sorted_nodes:
if node["url"] in nodes:
score = float("{0:.1f}".format(node["score"]))
t.add_row([node["url"], node["version"], score])
response = t.get_string()
self.stm.set_default_nodes(nodes)
await ctx.channel.send("```" + response + "```")
@commands.command(pass_context=True)
async def pricehistory(self, ctx, width: int = 75):
"""Retuns information about the current steem price"""
feed_history = self.stm.get_feed_history()
current_base = Amount(feed_history['current_median_history']["base"],
steem_instance=self.stm)
current_quote = Amount(feed_history['current_median_history']["quote"],
steem_instance=self.stm)
price_history = feed_history["price_history"]
price = []
for h in price_history:
base = Amount(h["base"], steem_instance=self.stm)
quote = Amount(h["quote"], steem_instance=self.stm)
price.append(base.amount / quote.amount)
# charset = u'ascii'
charset = u'utf8'
chart = AsciiChart(height=10,
width=width,
offset=4,
placeholder='{:6.2f} $',
charset=charset)
response = "Price history for STEEM (median price %4.2f $)\n" % (
float(current_base) / float(current_quote))
chart.adapt_on_series(price)
chart.new_chart()
chart.add_axis()
chart._draw_h_line(chart._map_y(
float(current_base) / float(current_quote)),
1,
int(chart.n / chart.skip),
line=chart.char_set["curve_hl_dot"])
chart.add_curve(price)
response += str(chart)
await ctx.channel.send("```" + response + "```")
@commands.command(pass_context=True)
async def curation(self, ctx, *, authorperm: str):
show_all_voter = False
all_posts = False
t = PrettyTable([
"Voter", "Voting time", "Vote", "Early vote loss", "Curation",
"Performance"
])
t.align = "l"
index = 0
index += 1
comment = Comment(authorperm, steem_instance=self.stm)
payout = None
curation_rewards_SBD = comment.get_curation_rewards(
pending_payout_SBD=True, pending_payout_value=payout)
curation_rewards_SP = comment.get_curation_rewards(
pending_payout_SBD=False, pending_payout_value=payout)
rows = []
sum_curation = [0, 0, 0, 0]
max_curation = [0, 0, 0, 0, 0, 0]
highest_vote = [0, 0, 0, 0, 0, 0]
for vote in comment["active_votes"]:
vote_SBD = self.stm.rshares_to_sbd(int(vote["rshares"]))
curation_SBD = curation_rewards_SBD["active_votes"][vote["voter"]]
curation_SP = curation_rewards_SP["active_votes"][vote["voter"]]
if vote_SBD > 0:
penalty = (
(comment.get_curation_penalty(vote_time=vote["time"])) *
vote_SBD)
performance = (float(curation_SBD) / vote_SBD * 100)
else:
performance = 0
penalty = 0
vote_befor_min = ((
(vote["time"]) - comment["created"]).total_seconds() / 60)
sum_curation[0] += vote_SBD
sum_curation[1] += penalty
sum_curation[2] += float(curation_SP)
sum_curation[3] += float(curation_SBD)
row = [
vote["voter"], vote_befor_min, vote_SBD, penalty,
float(curation_SP), performance
]
if row[-1] > max_curation[-1]:
max_curation = row
if row[2] > highest_vote[2]:
highest_vote = row
rows.append(row)
sortedList = sorted(rows, key=lambda row: (row[1]), reverse=False)
new_row = []
new_row2 = []
voter = []
voter2 = []
voter = [""]
voter2 = [""]
for row in sortedList:
if show_all_voter:
if not all_posts:
voter = [row[0]]
if all_posts:
new_row[0] = "%d. %s" % (index, comment.author)
t.add_row(new_row + voter + [
"%.1f min" % row[1],
"%.3f SBD" % float(row[2]),
"%.3f SBD" % float(row[3]),
"%.3f SP" % (row[4]),
"%.1f %%" % (row[5])
])
new_row = new_row2
t.add_row(new_row2 + voter2 + ["", "", "", "", ""])
if sum_curation[0] > 0:
curation_sum_percentage = sum_curation[3] / sum_curation[0] * 100
else:
curation_sum_percentage = 0
sum_line = new_row2 + voter2
sum_line[-1] = "High. vote"
t.add_row(sum_line + [
"%.1f min" % highest_vote[1],
"%.3f SBD" % float(highest_vote[2]),
"%.3f SBD" % float(highest_vote[3]),
"%.3f SP" % (highest_vote[4]),
"%.1f %%" % (highest_vote[5])
])
sum_line[-1] = "High. Cur."
t.add_row(sum_line + [
"%.1f min" % max_curation[1],
"%.3f SBD" % float(max_curation[2]),
"%.3f SBD" % float(max_curation[3]),
"%.3f SP" % (max_curation[4]),
"%.1f %%" % (max_curation[5])
])
sum_line[-1] = "Sum"
t.add_row(sum_line + [
"-",
"%.3f SBD" % (sum_curation[0]),
"%.3f SBD" % (sum_curation[1]),
"%.3f SP" % (sum_curation[2]),
"%.2f %%" % curation_sum_percentage
])
response = "curation for %s\n" % (authorperm)
response += t.get_string()
await ctx.channel.send("```" + response + "```")
print("%d/%d scanned" % ())
try:
acc = Account(m, steem_instance=stm)
except KeyboardInterrupt:
aborted = True
except:
print("%s is not a valid account" % m)
missing_accounts.append(m)
shares = 0
bonus_shares = 0
balance_rshares = 0
for m in member_data:
shares += member_data[m]["shares"]
bonus_shares += member_data[m]["bonus_shares"]
balance_rshares += member_data[m]["balance_rshares"]
print("units: %d" % shares)
print("bonus units: %d" % bonus_shares)
print("total units: %d" % (shares + bonus_shares))
print("----------")
print("balance_rshares: %d" % balance_rshares)
print("balance_rshares: %.3f $" % stm.rshares_to_sbd(balance_rshares))
if len(missing_accounts) > 0:
print("%d not existing accounts: " % len(missing_accounts))
print(missing_accounts)
c = Comment(authorperm, steem_instance=stm)
try:
curation_rewards_SBD = c.get_curation_rewards(pending_payout_SBD=True)
curation_SBD = curation_rewards_SBD["active_votes"][vote["voter"]]
if vote_SBD > 0:
performance = (float(curation_SBD) / vote_SBD * 100)
else:
performance = 0
except:
performance = 0
curation_rewards_SBD = None
rshares = int(vote["rshares"])
vote_SBD = stm.rshares_to_sbd(int(vote["rshares"]))
best_performance = 0
best_time_delay = 0
for v in c.get_votes():
v_SBD = stm.rshares_to_sbd(int(v["rshares"]))
if v_SBD > 0 and int(v["rshares"]) > rshares * 0.5 and curation_rewards_SBD is not None:
p = float(curation_rewards_SBD["active_votes"][v["voter"]]) / v_SBD * 100
if p > best_performance:
best_performance = p
if "time" in v:
best_time_delay = ((v["time"]) - c["created"]).total_seconds()
elif "last_update" in v:
best_time_delay = ((v["last_update"]) - c["created"]).total_seconds()
else:
best_time_delay = upvote_delay
best_vote_delay_min = 0
performance = 0
rshares = 0
voter_rshares = 0
if c.is_pending():
for vote in c["active_votes"]:
if vote["voter"] == vote_log["voter"]:
rshares = int(vote["rshares"])
for vote in c["active_votes"]:
voter_rshares = int(vote["rshares"])
curation_SBD = curation_rewards_SBD["active_votes"][vote["voter"]]
if voter_rshares > 0 and vote["voter"] == vote_log["voter"]:
vote_SBD = stm.rshares_to_sbd(voter_rshares)
performance = (float(curation_SBD) / vote_SBD * 100)
if voter_rshares > 0 and voter_rshares > rshares / rshares_divider:
vote_SBD = stm.rshares_to_sbd(voter_rshares)
p = float(curation_rewards_SBD["active_votes"][vote["voter"]]) / vote_SBD * 100
if p > best_performance:
best_performance = p
best_vote_delay_min = ((vote["time"]) - c["created"]).total_seconds() / 60
else:
rshares_sum = 0
rshares_before = 0
rshares_after = 0
try:
activeVotes = ActiveVotes(authorperm, steem_instance=stm2).get_sorted_list()
except:
continue
