def upvote_post(msg, user):
link = str(msg.content).split(' ')[0]
p = Post(link.split('@')[1])
try:
p.upvote(float(voting_power[msg.channel.id]), voter=user)
except KeyError:
p.upvote(float(voting_power['base']), voter=user)
def upvote(self, op):
try:
post = Post(op['memo'])
except ValueError:
logger.info('Invalid identifier: %s', op['memo'])
self.refund(op, message='invalid url')
return
try:
weight = self.upvote_weight
post.upvote(weight=weight, voter=self.watch_account)
except VotingInvalidOnArchivedPost as e:
logger.info('Archived post. Cannot upvote. %s', op['memo'])
self.refund(op,
message='Couldnt vote. Archived post. %s' % op['memo'])
return
except Exception as e:
if 'already voted' in e.args[0]:
self.refund(op, message='Already upvoted. %s' % op['memo'])
logger.info('Already voted: %s. Skipping.', op['memo'])
return
if 'Read timed' in e.args[0]:
logger.info('Node is not responding. Trying again to upvote.')
return self.upvote(op)
logger.info('Upvoted %s with weight: %s', op['memo'], weight)
class User:
def __init__(self, username, password, steem):
self._username = username
self._passwd = password
self._steem = steem
self._ipfsapi = get_ipfsapi()
self._cur_post = None
@staticmethod
def get_videos_list(query):
return get_chain_master().get_videos_list(query)
@staticmethod
def get_video_unauthorized(name, path):
video_metadata = get_chain_master().get_video_metadata(name)
multihash = video_metadata['multihash']
get_ipfsapi().get_video(multihash, path)
return video_metadata
def get_video(self, name, path):
video_metadata = User.get_video_unauthorized(name, path)
self._cur_post = Post(
{
'author': video_metadata['author'],
'permlink': video_metadata['name'],
}, self._steem)
return self._cur_post
def add_video(self, name, path, description=None, miniature_url=None):
description = description or 'No description'
miniature_url = miniature_url or self.get_miniature_url(path)
result = self._ipfsapi.add_video(path)
get_chain_master().add_video(name, self._username, description,
result['Hash'])
self._steem.commit.post(title=name,
body=description + '\n' + miniature_url,
author=self._username,
permlink=name,
default_parent_permlink='video')
def vote_video(self, type):
if not self._cur_post:
raise RuntimeError('There is no post to vote')
if type == VoteType.UP_VOTE:
return self._cur_post.upvote(self._username)
return self._cur_post.downvote(self._username)
def get_miniature_url(self, path):
return 'https://static.tumblr.com/5cc5658c2c9cd06cfc68747c9059bd6f/i9ytv5i/szXn6nvfq/tumblr_static_tumblr_static__640.jpg'
# go through list of beneficiaries and upvote them
for idx, votinglist in enumerate(rewardees):
for acc in votinglist:
account = Account(acc, s)
posts = getUpvoteCandidate(account)
# confirm number of comments made
if len(posts) >= min_limit:
selection = random.shuffle(posts)
voted = 0
votingon = 0
# vote on comments
while voted < num_upvotes:
things = posts[votingon]
votingon += 1
P = Post(things, upvoter)
# make sure not already voted on
if not accountname in P['active_votes']:
try:
print('upvote: ' + str(things) + ' / ' +
str(Vote_Power[idx]) + '%... ',
end='',
flush=True)
P.upvote(Vote_Power[idx], accountname)
voted += 1
print('Success')
# sleep for 5 seconds, make sure we can vote again
time.sleep(5)
except Exception as e:
print("Error Voting: " + str(e))
class Testcases(unittest.TestCase):
def __init__(self, *args, **kwargs):
super(Testcases, self).__init__(*args, **kwargs)
self.post = Post(identifier, steem_instance=steem)
def test_getOpeningPost(self):
self.post._getOpeningPost()
def test_reply(self):
try:
self.post.reply(body="foobar",
title="",
author=testaccount,
meta=None)
except InsufficientAuthorityError:
pass
except MissingKeyError:
pass
def test_upvote(self):
try:
self.post.upvote(voter=testaccount)
except VotingInvalidOnArchivedPost:
pass
except InsufficientAuthorityError:
pass
except MissingKeyError:
pass
def test_downvote(self, weight=-100, voter=testaccount):
try:
self.post.downvote(voter=testaccount)
except VotingInvalidOnArchivedPost:
pass
except InsufficientAuthorityError:
pass
except MissingKeyError:
pass
def test_edit(self):
try:
steem.edit(identifier, "Foobar")
except InsufficientAuthorityError:
pass
except MissingKeyError:
pass
def test_post(self):
try:
steem.post("title",
"body",
meta={"foo": "bar"},
author=testaccount)
except InsufficientAuthorityError:
pass
except MissingKeyError:
pass
def test_create_account(self):
try:
steem.create_account("xeroc-create",
creator=testaccount,
password="******",
storekeys=False)
except InsufficientAuthorityError:
pass
except MissingKeyError:
pass
def test_transfer(self):
try:
steem.transfer("fabian", 10, "STEEM", account=testaccount)
except InsufficientAuthorityError:
pass
except MissingKeyError:
pass
def test_withdraw_vesting(self):
try:
steem.withdraw_vesting(10, account=testaccount)
except InsufficientAuthorityError:
pass
except MissingKeyError:
pass
def test_transfer_to_vesting(self):
try:
steem.transfer_to_vesting(10, to=testaccount, account=testaccount)
except InsufficientAuthorityError:
pass
except MissingKeyError:
pass
def test_get_replies(self):
steem.get_replies(author=testaccount)
def test_get_posts(self):
steem.get_posts()
def test_get_categories(self):
steem.get_categories(sort="trending")
def test_get_balances(self):
steem.get_balances(testaccount)
def test_getPost(self):
self.assertEqual(
Post("@xeroc/piston", steem_instance=steem).url,
"/piston/@xeroc/piston")
self.assertEqual(
Post({
"author": "@xeroc",
"permlink": "piston"
},
steem_instance=steem).url, "/piston/@xeroc/piston")
class Mechanism(Interface):
"""This class covers the internal features of SteemiTAG.
In particular, it connects Interface to the Steem libraries."""
def __init__(self, authorsLiked, who, mainWin):
self.authorsLiked = authorsLiked
self.tagsLiked = ['polish']
self.who = who
self.b = Blockchain()
self.stream = self.b.stream()
self.mainWin = mainWin
def localBool(self, x):
if x is False:
return x
else:
return True
def machine(self, tagDefined=False, authorDefined=False):
self.tagDefined = tagDefined
self.authorDefined = authorDefined
if not self.tagDefined and not self.authorDefined:
pass
else:
next(self.yieldBlock())
self.setTagFound = False
if self.tagDefined:
self.tagMachine()
if self.block['type'] == 'comment' and self.block['parent_author'] == '' and (self.setTagFound == self.localBool(self.tagDefined)):
if self.authorDefined:
self.authorMachine('suppressed')
else:
self.suppressedVote()
self.mainWin.after(100, lambda: self.machine(self.tagDefined, self.authorDefined))
def yieldBlock(self):
for self.block in self.stream:
yield self.block
def suppressedVote(self):
with suppress(steembase.exceptions.PostDoesNotExist, steembase.exceptions.RPCError):
self.unsuppressedVote()
def unsuppressedVote(self):
self.post = Post('@{}/{}'.format(self.block['author'], self.block['permlink']))
self.up = self.post.upvote(voter=self.who)
def authorMachine(self, mode):
self.mode = mode
self.atAuthor = '@{}'.format(self.block['author'])
if self.atAuthor in self.authorsLiked:
if self.mode == 'suppressed':
self.suppressedVote()
elif self.mode == 'unsuppressed':
self.unsuppressedVote()
def tagMachine(self):
if 'json_metadata' in self.block and self.block['json_metadata'] != '':
self.fullMeta = self.block['json_metadata']
self.fullMeta = ast.literal_eval(self.fullMeta)
if 'tags' in self.fullMeta:
for one in self.tagsLiked:
if one in self.fullMeta['tags']:
self.setTagFound = True
return self.setTagFound
def tracedUsers(self):
self.block = {}
self.block['author'] = 'haiyangdeperci'
self.block['permlink'] = 're-haiyangdeperci-oryginalna-sobota-1-lut-czarnego-prawa-besztany-20171006t210844114z'
self.suppressedVote()
print "- Posts pendentes de voto: "
for post_unit in post_stack:
url = post_unit[0]
tempo = time.ctime(int(post_unit[1]))
count += 1
print "[%i] [%s] %s \n" % (count, tempo, url)
for post_unit in post_stack:
post_url = post_unit[0]
post_timestamp = post_unit[1]
if now >= post_timestamp:
print "\nVotando no post %s" % post_url
try:
upvote = Post(post_url)
upvote.upvote(weight=+5, voter=username)
print "Enviando comentario no post..."
upvote.reply(
body=
"Obrigado por postar! Esse comentário é o novo bot que dará upvote 5% para todos os posts que usam a tag #pt. [Ainda não votou em mim como witness? Clique aqui e dê o seu voto! É rápido!](https://app.steemconnect.com/sign/account-witness-vote?witness=tiagoferezin&approve=true)",
title="",
author=username)
print "OK! Proximo...\n"
post_stack.remove(post_unit)
except:
print "Esse post ja foi votado! Proximo...\n"
post_stack.remove(post_unit)
# Verifica se ha post diferente do anterior na query
try:
novo_post = s.get_discussions_by_created(query)
reply_post = None
# 대댓글 달기
try:
reply_post = Post('@' + reply[1]['op'][1]['author'] + '/' +
reply[1]['op'][1]['permlink'])
except Exception as e:
pass
while (True):
try:
reply_post.reply(body="금손봇", author=acc_name)
break
except Exception as e:
print(e)
time.sleep(17)
# 보팅하기
reply_post.upvote(10, acc_name)
# 대댓글과 보팅한 댓글을 저장
voted_permlink.insert(0, reply[1]['op'][1]['permlink'])
# 확인 기록(past_seq_num) 갱신
past_seq_num = recent_seq_num
print(voted_permlink)
# 적절한 휴식
print(recent_seq_num, past_seq_num)
time.sleep(3)
query = {
'author': 'steem-bot'
}
df_banned_posts = pd.DataFrame([x for x in raw_posts_col.find(query)])
print(df_banned_posts.shape)
# Refresh all posts, if hr1 in voters, unvote
counter = 0
for i in range(df_banned_posts.shape[0]):
try:
target = Post(df_banned_posts.iloc[i]['_id'], steemd_instance=steemd)
except PostDoesNotExist:
print('Doesnt exist:', df_banned_posts.iloc[i]['_id'])
continue
diff = datetime.utcnow() - target['created']
voters = set()
hr1_strength = [x['percent'] for x in target.active_votes if x['voter'] == 'hr1']
if hr1_strength and hr1_strength[0] > 0 and diff < timedelta(days=7):
target.upvote(-1, 'hr1')
time.sleep(3)
print(target['url'])
counter += 1
print(counter)
