def test_vote_proposal(node, account, wif, subject):
logger.info("Testing: vote_proposal")
s = Hive(node=[node], no_broadcast=False, keys=[wif])
# first we will find our special proposal and get its proposal_id
proposals = s.rpc.list_proposals([account], 1000, "by_creator",
"ascending", "inactive")
found = None
for proposal in proposals:
if proposal["subject"] == subject:
found = proposal
assert found is not None
proposal_id = int(found["proposal_id"])
# now lets vote
from beembase.operations import Update_proposal_votes
op = Update_proposal_votes(**{
"voter": account,
"proposal_ids": [proposal_id],
"approve": True
})
ret = None
try:
ret = s.finalizeOp(op, account, "active")
except Exception as ex:
logger.exception("Exception: {}".format(ex))
raise ex
assert ret["operations"][0][1]["voter"] == account
assert ret["operations"][0][1]["proposal_ids"][0] == proposal_id
assert ret["operations"][0][1]["approve"] == True
hive_utils.common.wait_n_blocks(s.rpc.url, 2)
class ProposalsCreatorThread(threading.Thread):
def __init__(self, node_url, proposals, private_key, delay):
threading.Thread.__init__(self)
self.node_url = node_url
self.proposals = proposals
self.private_key = private_key
self.delay = delay
self.log = logging.getLogger(MODULE_NAME + ".ProposalsCreatorThread." +
self.node_url)
self.node_client = Hive(node=[self.node_url], keys=[self.private_key])
def run(self):
self.log.info("Sending proposals to node at: {} with delay {}".format(
self.node_url, self.delay))
sleep(self.delay)
from beembase.operations import Create_proposal
for proposal in self.proposals:
self.log.info("New proposal ==> ({},{},{},{},{},{},{})".format(
proposal['creator'], proposal['receiver'],
proposal['start_date'], proposal['end_date'],
proposal['daily_pay'], proposal['subject'],
proposal['permlink']))
op = Create_proposal(
**{
'creator': proposal['creator'],
'receiver': proposal['receiver'],
'start_date': proposal['start_date'],
'end_date': proposal['end_date'],
'daily_pay': proposal['daily_pay'],
'subject': proposal['subject'],
'permlink': proposal['permlink']
})
self.node_client.finalizeOp(op, proposal['creator'], "active")
def test_update_proposal(node, creator, wif):
logger.info("Testing: update_proposal")
s = Hive(node=[node], no_broadcast=False, keys=[wif])
proposals = s.rpc.list_proposals([creator], 1000, "by_creator",
"ascending", "all")
print(proposals[0])
from beembase.operations import Update_proposal
subject = "Some new proposal subject"
op = Update_proposal(
**{
'proposal_id': proposals[0]["proposal_id"],
'creator': proposals[0]["creator"],
'daily_pay': "16.000 TBD",
'subject': subject,
'permlink': proposals[0]["permlink"]
})
try:
s.finalizeOp(op, creator, "active")
except Exception as ex:
logger.exception("Exception: {}".format(ex))
raise ex
hive_utils.common.wait_n_blocks(node, 3)
proposals = s.rpc.list_proposals([creator], 1000, "by_creator",
"ascending", "all")
print(proposals[0])
assert proposals[0]["subject"] == subject, "Subjects dont match"
def send_notification(custom_json, server_account='', wif=''):
""" Sends a custom_json to Hive
Expects two env variables, Hive account name and posting key
HIVE_SERVER_ACCOUNT
HIVE_POSTING_KEY
"""
operation_id = 'hive-hydra'
try:
if server_account == '':
server_account = os.getenv('HIVE_SERVER_ACCOUNT')
pass
if wif == '':
wif = [os.getenv('HIVE_POSTING_KEY')]
pass
if USE_TEST_NODE:
h = Hive(keys=wif,node=TEST_NODE)
else:
h = Hive(keys=wif)
tx = h.custom_json(id=operation_id, json_data= custom_json,
required_posting_auths=[server_account])
trx_id = tx['trx_id']
logging.info(f'Transaction sent: {trx_id}')
return trx_id, True
except Exception as ex:
error_message = f'{ex} occurred {ex.__class__}'
logging.error(error_message)
trx_id = error_message
return trx_id, False
def test_create_account_password(self):
bts = Hive(node=get_hive_nodes(),
nobroadcast=True,
unsigned=True,
data_refresh_time_seconds=900,
keys={"active": wif, "owner": wif2, "memo": wif3},
num_retries=10)
core_unit = "STM"
name = ''.join(random.choice(string.ascii_lowercase) for _ in range(12))
key5 = PrivateKey()
bts.txbuffer.clear()
tx = bts.create_account(
name,
creator="test", # 1.2.7
password="******",
additional_owner_keys=[format(key5.pubkey, core_unit)],
additional_active_keys=[format(key5.pubkey, core_unit)],
additional_posting_keys=[format(key5.pubkey, core_unit)],
additional_owner_accounts=["test1"], # 1.2.0
additional_active_accounts=["test1"],
storekeys=False,
)
if isinstance(tx["operations"][0], list):
self.assertEqual(
tx["operations"][0][0],
"account_create"
)
op = tx["operations"][0][1]
else:
self.assertEqual(
tx["operations"][0]["type"],
"account_create_operation"
)
op = tx["operations"][0]["value"]
role = "active"
self.assertIn(
format(key5.pubkey, core_unit),
[x[0] for x in op[role]["key_auths"]])
self.assertIn(
format(key5.pubkey, core_unit),
[x[0] for x in op[role]["key_auths"]])
self.assertIn(
"test1",
[x[0] for x in op[role]["account_auths"]])
role = "owner"
self.assertIn(
format(key5.pubkey, core_unit),
[x[0] for x in op[role]["key_auths"]])
self.assertIn(
format(key5.pubkey, core_unit),
[x[0] for x in op[role]["key_auths"]])
self.assertIn(
"test1",
[x[0] for x in op[role]["account_auths"]])
self.assertEqual(
op["creator"],
"test")
def __init__(self, node_url, proposals, private_key, delay):
threading.Thread.__init__(self)
self.node_url = node_url
self.proposals = proposals
self.private_key = private_key
self.delay = delay
self.log = logging.getLogger(MODULE_NAME + ".ProposalsCreatorThread." +
self.node_url)
self.node_client = Hive(node=[self.node_url], keys=[self.private_key])
def test_create_account(self):
bts = Hive(node=self.nodelist.get_hive_nodes(),
nobroadcast=True,
unsigned=True,
data_refresh_time_seconds=900,
keys={
"active": wif,
"owner": wif,
"memo": wif
},
num_retries=10)
core_unit = "STM"
name = ''.join(
random.choice(string.ascii_lowercase) for _ in range(12))
key1 = PrivateKey()
key2 = PrivateKey()
key3 = PrivateKey()
key4 = PrivateKey()
key5 = PrivateKey()
bts.txbuffer.clear()
tx = bts.create_account(
name,
creator="test", # 1.2.7
owner_key=format(key1.pubkey, core_unit),
active_key=format(key2.pubkey, core_unit),
posting_key=format(key3.pubkey, core_unit),
memo_key=format(key4.pubkey, core_unit),
additional_owner_keys=[format(key5.pubkey, core_unit)],
additional_active_keys=[format(key5.pubkey, core_unit)],
additional_posting_keys=[format(key5.pubkey, core_unit)],
additional_owner_accounts=["test1"], # 1.2.0
additional_active_accounts=["test2"],
additional_posting_accounts=["test3"],
storekeys=False,
)
self.assertEqual(tx["operations"][0][0], "account_create")
op = tx["operations"][0][1]
role = "active"
self.assertIn(format(key5.pubkey, core_unit),
[x[0] for x in op[role]["key_auths"]])
self.assertIn(format(key5.pubkey, core_unit),
[x[0] for x in op[role]["key_auths"]])
self.assertIn("test2", [x[0] for x in op[role]["account_auths"]])
role = "posting"
self.assertIn(format(key5.pubkey, core_unit),
[x[0] for x in op[role]["key_auths"]])
self.assertIn(format(key5.pubkey, core_unit),
[x[0] for x in op[role]["key_auths"]])
self.assertIn("test3", [x[0] for x in op[role]["account_auths"]])
role = "owner"
self.assertIn(format(key5.pubkey, core_unit),
[x[0] for x in op[role]["key_auths"]])
self.assertIn(format(key5.pubkey, core_unit),
[x[0] for x in op[role]["key_auths"]])
self.assertIn("test1", [x[0] for x in op[role]["account_auths"]])
self.assertEqual(op["creator"], "test")
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):
cls.nodelist = NodeList()
cls.nodelist.update_nodes(steem_instance=Hive(node=cls.nodelist.get_hive_nodes(), num_retries=10))
cls.bts = Hive(
node=cls.nodelist.get_hive_nodes(),
nobroadcast=True,
unsigned=True,
data_refresh_time_seconds=900,
keys={"active": wif, "owner": wif2, "memo": wif3},
num_retries=10)
cls.account = Account("test", full=True, steem_instance=cls.bts)
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_create_proposal(node, creator_account, receiver_account, wif,
subject):
logger.info("Testing: create_proposal")
s = Hive(node=[node], no_broadcast=False, keys=[wif])
import datetime
now = datetime.datetime.now()
start_date, end_date = test_utils.get_start_and_end_date(now, 10, 2)
from beem.account import Account
try:
creator = Account(creator_account, hive_instance=s)
except Exception as ex:
logger.error("Account: {} not found. {}".format(creator_account, ex))
raise ex
try:
receiver = Account(receiver_account, hive_instance=s)
except Exception as ex:
logger.error("Account: {} not found. {}".format(receiver_account, ex))
raise ex
ret = s.post("Hivepy proposal title",
"Hivepy proposal body",
creator["name"],
permlink="hivepy-proposal-title",
tags="proposals")
from beembase.operations import Create_proposal
op = Create_proposal(
**{
"creator": creator["name"],
"receiver": receiver["name"],
"start_date": start_date,
"end_date": end_date,
"daily_pay": "16.000 TBD",
"subject": subject,
"permlink": "hivepy-proposal-title"
})
ret = None
try:
ret = s.finalizeOp(op, creator["name"], "active")
except Exception as ex:
logger.exception("Exception: {}".format(ex))
raise ex
assert ret["operations"][0][1]["creator"] == creator["name"]
assert ret["operations"][0][1]["receiver"] == receiver["name"]
assert ret["operations"][0][1]["start_date"] == start_date
assert ret["operations"][0][1]["end_date"] == end_date
assert ret["operations"][0][1]["daily_pay"] == "16.000 TBD"
assert ret["operations"][0][1]["subject"] == subject
assert ret["operations"][0][1]["permlink"] == "hivepy-proposal-title"
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_list_proposals(node, account, wif, subject):
logger.info("Testing: list_proposals")
s = Hive(node=[node], no_broadcast=False, keys=[wif])
# list inactive proposals, our proposal shoud be here
proposals = s.rpc.list_proposals([account], 1000, "by_creator",
"ascending", "inactive")
found = None
for proposal in proposals:
if proposal["subject"] == subject:
found = proposal
assert found is not None
# list active proposals, our proposal shouldnt be here
proposals = s.rpc.list_proposals([account], 1000, "by_creator",
"ascending", "active")
found = None
for proposal in proposals:
if proposal["subject"] == subject:
found = proposal
assert found is None
# list all proposals, our proposal should be here
proposals = s.rpc.list_proposals([account], 1000, "by_creator",
"ascending", "all")
found = None
for proposal in proposals:
if proposal["subject"] == subject:
found = proposal
assert found is not None
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 setUpClass(cls):
cls.bts = Hive(node=get_hive_nodes(),
nobroadcast=True,
keys={"active": wif},
num_retries=10)
# from getpass import getpass
# self.bts.wallet.unlock(getpass())
set_shared_blockchain_instance(cls.bts)
cls.bts.set_default_account("test")
acc = Account("fullnodeupdate", blockchain_instance=cls.bts)
n_votes = 0
index = 0
entries = acc.get_blog(limit=20)[::-1]
while n_votes == 0:
comment = Comment(entries[index], blockchain_instance=cls.bts)
votes = comment.get_votes()
n_votes = len(votes)
index += 1
last_vote = votes[0]
cls.authorpermvoter = construct_authorpermvoter(
last_vote['author'], last_vote['permlink'], last_vote["voter"])
[author, permlink,
voter] = resolve_authorpermvoter(cls.authorpermvoter)
cls.author = author
cls.permlink = permlink
cls.voter = voter
cls.authorperm = construct_authorperm(author, permlink)
def setUpClass(cls):
stm = Hive(node=get_hive_nodes())
stm.config.refreshBackup()
stm.set_default_nodes(["xyz"])
del stm
cls.urls = get_hive_nodes()
cls.bts = Hive(node=cls.urls, nobroadcast=True, num_retries=10)
set_shared_steem_instance(cls.bts)
acc = Account("fullnodeupdate", steem_instance=cls.bts)
comment = Comment(acc.get_blog_entries(limit=5)[1],
steem_instance=cls.bts)
cls.authorperm = comment.authorperm
votes = comment.get_votes(raw_data=True)
last_vote = votes[-1]
cls.authorpermvoter = comment['authorperm'] + '|' + last_vote["voter"]
def test_history_op_filter2(self):
stm = Hive("https://api.hive.blog")
batch_size = 100
account = Account("beembot", blockchain_instance=stm)
votes_list = list(
account.history(only_ops=["vote"], batch_size=batch_size))
other_list = list(
account.history(exclude_ops=["vote"], batch_size=batch_size))
all_list = list(account.history(batch_size=batch_size))
self.assertEqual(len(all_list), len(votes_list) + len(other_list))
index = 0
for h in sorted((votes_list + other_list), key=lambda h: h["index"]):
self.assertEqual(index, h["index"])
index += 1
votes_list = list(
account.history_reverse(only_ops=["vote"], batch_size=batch_size))
other_list = list(
account.history_reverse(exclude_ops=["vote"],
batch_size=batch_size))
all_list = list(account.history_reverse(batch_size=batch_size))
self.assertEqual(len(all_list), len(votes_list) + len(other_list))
index = 0
for h in sorted((votes_list + other_list), key=lambda h: h["index"]):
self.assertEqual(index, h["index"])
index += 1
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):
node_list = get_hive_nodes()
cls.stm = Hive(node=node_list,
keys={
"active": wif,
"owner": wif2,
"memo": wif3
},
nobroadcast=True,
num_retries=10)
cls.steemit = Hive(node="https://api.steemit.com",
nobroadcast=True,
keys={
"active": wif,
"owner": wif2,
"memo": wif3
},
num_retries=10)
set_shared_blockchain_instance(cls.stm)
cls.stm.set_default_account("test")
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):
cls.bts = Hive(
node=get_hive_nodes(),
nobroadcast=True,
bundle=False,
unsigned=True,
# Overwrite wallet to use this list of wifs only
keys={"active": wif},
num_retries=10)
cls.account = Account("beembot", steem_instance=cls.bts)
set_shared_blockchain_instance(cls.bts)
def test_remove_proposal(node, account, wif, subject):
logger.info("Testing: remove_proposal")
s = Hive(node=[node], no_broadcast=False, keys=[wif])
# first we will find our special proposal and get its proposal_id
proposals = s.rpc.list_proposals([account], 1000, "by_creator",
"ascending", "inactive")
found = None
for proposal in proposals:
if proposal["subject"] == subject:
found = proposal
assert found is not None, "Not found"
proposal_id = int(found["proposal_id"])
# remove proposal
print(account)
from beembase.operations import Remove_proposal
op = Remove_proposal(**{
'voter': account,
'proposal_owner': account,
'proposal_ids': [proposal_id]
})
try:
s.finalizeOp(op, account, "active")
except Exception as ex:
logger.exception("Exception: {}".format(ex))
raise ex
# try to find our special proposal
proposals = s.rpc.list_proposals([account], 1000, "by_creator",
"ascending", "inactive")
found = None
for proposal in proposals:
if proposal["subject"] == subject:
found = proposal
assert found is None, "Not found"
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 test_list_voter_proposals(node, account, wif, subject):
logger.info("Testing: list_voter_proposals")
s = Hive(node=[node], no_broadcast=False, keys=[wif])
voter_proposals = s.rpc.list_proposal_votes([account], 1000,
"by_voter_proposal",
"ascending", "inactive")
found = None
for proposals in voter_proposals:
if proposals["proposal"]["subject"] == subject:
found = proposals
assert found is not None
def test_update_proposal(node, creator, wif):
from beembase.operations import Update_proposal
from datetime import timedelta
import dateutil.parser
s = Hive(node=[node], no_broadcast=False, keys=[wif])
logger.info("Testing: update_proposal without updating the end date")
proposals = s.rpc.list_proposals([creator], 1000, "by_creator",
"ascending", "all")
print(proposals[0])
new_subject = "Some new proposal subject"
new_daily_pay = "15.000 TBD"
op = Update_proposal(
**{
'proposal_id': proposals[0]["proposal_id"],
'creator': proposals[0]["creator"],
'daily_pay': new_daily_pay,
'subject': new_subject,
'permlink': proposals[0]["permlink"]
})
try:
s.finalizeOp(op, creator, "active")
except Exception as ex:
logger.exception("Exception: {}".format(ex))
raise ex
hive_utils.common.wait_n_blocks(node, 3)
proposals = s.rpc.list_proposals([creator], 1000, "by_creator",
"ascending", "all")
print(proposals[0])
assert proposals[0]["subject"] == new_subject, "Subjects dont match"
assert proposals[0]["daily_pay"] == new_daily_pay, "daily pay dont match"
logger.info("Testing: update_proposal and updating the end date")
end_date = test_utils.date_to_iso(
dateutil.parser.parse(proposals[0]['end_date']) - timedelta(days=1))
op = Update_proposal(
**{
'proposal_id': proposals[0]["proposal_id"],
'creator': proposals[0]["creator"],
'daily_pay': "15.000 TBD",
'subject': new_subject,
'prefix': "TST",
'permlink': proposals[0]["permlink"],
'end_date': end_date
})
try:
s.finalizeOp(op, creator, "active")
except Exception as ex:
logger.exception("Exception: {}".format(ex))
raise ex
hive_utils.common.wait_n_blocks(node, 3)
proposals = s.rpc.list_proposals([creator], 1000, "by_creator",
"ascending", "all")
print(proposals[0])
assert proposals[0]["end_date"] == end_date, "End date doesn't match"
def analyze_activity(self):
for comment in self.account.history_reverse(
only_ops=['comment', 'vote']):
if comment['type'] == 'vote':
# Votes by himself
if comment['voter'] == self.username and comment[
'voter'] != comment['author']:
# If I am the voter and it is not my post
c = Comment(f"@{comment['author']}/{comment['permlink']}",
blockchain_instance=Hive())
# vectorize
_input = WordEmbedding.vectorize_text(
model=config.statics.Word2Vec,
html=c.body,
text=c.title + ". ")
if _input is None:
continue
_output = config.statics.TextCNN(_input).cpu()
self.add_categories(_output)
else:
# Goto start --> No wait
continue
if comment['type'] == 'comment':
# Post or comment
if comment['author'] != self.username:
# Activity, he does not (Someone else commented at his blog...)
continue
_input = WordEmbedding.vectorize_text(
model=config.statics.Word2Vec,
html=comment['body'],
text=comment['title'] + ". ")
if _input is None:
# To less words or Error
continue
_output = config.statics.TextCNN(_input).cpu()
self.add_categories(_output)
if self.data_length >= config.PROFILER_MIN_DATA:
# make brake
time.sleep(0.75)
if self.data_length >= config.PROFILER_MAX_DATA:
break
self.finished = True
self.update()
def __init__(self, username: str, start_get_post_thread=True):
self.username = username
self.account = Account(username, blockchain_instance=Hive())
mysql_con = config.get_connection()
if mysql_con is None:
print(
"[INFO] Can't start Latest Post Manager because of an mysql database error!"
)
return
result = database.read_query(
"SELECT * FROM profiler WHERE username=%s;", (username, ),
con=mysql_con,
close_con=False)
if len(result) == 0:
# No profiler exists, create one
self.category = [0 for i in config.CATEGORIES]
self.data_length = 0
self.finished = False
result = database.commit_query(
"INSERT INTO profiler(username, category, length, timestamp, finished) VALUES (%s, %s, %s, %s, %s);",
(username, ' '.join(map(str, self.category)), self.data_length,
datetime.utcnow().strftime("%d.%m.%YT%H:%M:%S"), False),
con=mysql_con,
close_con=False)
if result <= 0:
# Error
print("[WARNING] Can't add Profiler for " + username)
else:
# Start analyze Thread, if the profiler existed bevor, this thread already run!
self.analyze_thread = Thread(target=self.analyze_activity)
self.analyze_thread.name = "Analyze Activities from " + username
self.analyze_thread.daemon = True
self.analyze_thread.start()
else:
# Load existent Profiler
self.update_timestamp()
self.category = [float(x) for x in result[0][1].split(' ')]
self.data_length = result[0][2]
self.finished = "1" in result[0][4]
mysql_con.close()
# Start finder thread
self.find_posts_thread = Thread(target=self.find_interestings)
self.find_posts_thread.name = "Find interesting Posts for " + username
self.find_posts_thread.daemon = True
if start_get_post_thread:
self.find_posts_thread.start()
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)
def list_proposals_by_node(creator, private_key, nodes, subjects):
for idx in range(0, len(nodes)):
node = nodes[idx]
logger.info("Listing proposals using node at {}".format(node))
s = Hive(node=[node], keys=[private_key])
proposals = s.rpc.list_proposals([creator], 1000, "by_creator",
"ascending", "all")
for subject in subjects:
msg = "Looking for id of proposal with subject {}".format(subject)
for proposal in proposals:
if proposal['subject'] == subject:
msg = msg + " - FOUND ID = {}".format(proposal['id'])
#assert proposal['id'] == results[subject], "ID do not match expected {} got {}".format(results[subject], proposal['id'])
break
logger.info(msg)
