def test_process_comment_timezone(database, reddit):
user = database.get_or_add_user(user_name="Watchful1")
user.timezone = "America/Los_Angeles"
username = "******"
comment_id = utils.random_id()
thread_id = utils.random_id()
created = utils.datetime_now()
comment = reddit_test.RedditObject(
body=f"{static.TRIGGER}! 1 day",
author=username,
created=created,
id=comment_id,
link_id="t3_" + thread_id,
permalink=f"/r/test/{thread_id}/_/{comment_id}/",
subreddit="test")
reddit.add_comment(comment)
comments.process_comment(comment.get_pushshift_dict(), reddit, database)
result = comment.get_first_child().body
assert "default time zone" in result
assert "`America/Los_Angeles`" in result
reminders = database.get_all_user_reminders(username)
assert reminders[0].target_date == created + timedelta(hours=24)
def test_process_comment(database, reddit):
created = utils.datetime_now()
username = "******"
comment_id = utils.random_id()
thread_id = utils.random_id()
comment = reddit_test.RedditObject(
body=f"{static.TRIGGER}! 1 day",
author=username,
created=created,
id=comment_id,
link_id="t3_" + thread_id,
permalink=f"/r/test/{thread_id}/_/{comment_id}/",
subreddit="test")
reddit.add_comment(comment)
comments.process_comment(comment.get_pushshift_dict(), reddit, database)
result = comment.get_first_child().body
assert "CLICK THIS LINK" in result
reminders = database.get_all_user_reminders(username)
assert len(reminders) == 1
assert reminders[0].user.name == username
assert reminders[0].message is None
assert reminders[0].source == utils.reddit_link(comment.permalink)
assert reminders[0].requested_date == created
assert reminders[0].target_date == created + timedelta(hours=24)
assert reminders[0].id is not None
assert reminders[0].recurrence is None
def test_comment_in_thread(database, reddit):
comment_id = utils.random_id()
thread_id = utils.random_id()
comment = reddit_test.RedditObject(
body=f"{static.TRIGGER}! 1 day",
author="Watchful1",
created=utils.datetime_now(),
id=comment_id,
link_id="t3_" + thread_id,
permalink=f"/r/test/{thread_id}/_/{comment_id}/",
subreddit="test")
reddit.add_comment(comment)
comments.process_comment(comment.get_pushshift_dict(), reddit, database)
comment_id_2 = utils.random_id()
comment_2 = reddit_test.RedditObject(
body=f"{static.TRIGGER}! 1 day",
author="Watchful1",
created=utils.datetime_now(),
id=comment_id_2,
link_id="t3_" + thread_id,
permalink=f"/r/test/{thread_id}/_/{comment_id_2}/")
reddit.add_comment(comment_2)
comments.process_comment(comment_2.get_pushshift_dict(), reddit, database)
assert len(comment_2.children) == 0
assert len(reddit.sent_messages) == 1
assert reddit.sent_messages[0].author.name == static.ACCOUNT_NAME
assert "I've already replied to another comment in this thread" in reddit.sent_messages[
0].body
def create_job(self):
table = self.dynamo_connector.Table(self.db_table)
try:
lambdaArn = self.body['lambdaArn']
time = self.body['time']
except KeyError as exc:
raise HTTPError(status=400,
message='Missing required body fields: %s' % exc)
try:
parse(time)
except ValueError as exc:
raise HTTPError(status=400,
message='Invalid date format: %s' % exc)
db_item = {
'jobid': utils.random_id(),
'lambdaArn': lambdaArn,
'time': time,
'created_at': str(datetime.now()),
'modified_at': str(datetime.now())
}
try:
table.put_item(
Item=db_item
)
except Exception as exc:
warning_string = "Error creating new At Job DB entry {}"
LOG.warning(warning_string.format(lambdaArn), exc_info=exc)
raise
return db_item
def __init__(self,
body=None,
author=None,
created=None,
id=None,
permalink=None,
link_id=None,
prefix="t4",
subreddit=None):
self.body = body
if isinstance(author, User):
self.author = author
else:
self.author = User(author)
if id is None:
self.id = utils.random_id()
else:
self.id = id
self.fullname = f"{prefix}_{self.id}"
if created is None:
self.created_utc = utils.datetime_now().timestamp()
else:
self.created_utc = created.timestamp()
self.permalink = permalink
self.link_id = link_id
self.subreddit = subreddit
self.parent = None
self.children = []
def _add_random_state(self):
"""
Creates a random new state
"""
new_id = utils.random_id()
state_ids = self.states.keys() + [new_id]
look = random.choice([True, False])
if look:
look_high_action = random.choice(['cooperate', 'defect'])
look_low_action = random.choice(['cooperate', 'defect'])
else:
look_high_action = look_low_action = random.choice(['cooperate', 'defect'])
set = {
'strategy_set': {
'next': random.choice(state_ids),
},
'action_set': {
'look': look,
'high': look_high_action,
'low': look_low_action,
},
'id': new_id,
}
self.states[new_id] = State(**set)
return new_id
def test_add_recurring_reminder(database, reddit):
created = utils.datetime_now()
username = "******"
keyword = "reminderstring"
id = utils.random_id()
message = reddit_test.RedditObject(
body=f"[{keyword}]\n{static.TRIGGER_RECURRING}! 1 day",
author=username,
created=created,
id=id)
messages.process_message(message, reddit, database)
result = message.get_first_child().body
assert "reminderstring" in result
assert "and then every `1 day`" in result
assert "This time has already passed" not in result
assert "Could not find a time in message" not in result
assert "Could not parse date" not in result
assert "Can't use a default for a recurring reminder" not in result
assert "I got the same date rather than one after it" not in result
assert "I got a date before that rather than one after it" not in result
reminders = database.get_all_user_reminders(username)
assert len(reminders) == 1
assert reminders[0].user.name == username
assert reminders[0].message == keyword
assert reminders[0].source == utils.message_link(id)
assert reminders[0].requested_date == created
assert reminders[0].target_date == created + timedelta(hours=24)
assert reminders[0].id is not None
assert reminders[0].recurrence == "1 day"
def test_add_reminder(database, reddit):
created = utils.datetime_now()
username = "******"
keyword = "reminderstring"
id = utils.random_id()
message = reddit_test.RedditObject(
body=f"[{keyword}]\n{static.TRIGGER}! 1 day",
author=username,
created=created,
id=id)
messages.process_message(message, reddit, database)
result = message.get_first_child().body
assert "reminderstring" in result
assert "This time has already passed" not in result
assert "Could not find a time in message" not in result
assert "Could not parse date" not in result
reminders = database.get_user_reminders(username)
assert len(reminders) == 1
assert reminders[0].user == username
assert reminders[0].message == keyword
assert reminders[0].source == utils.message_link(id)
assert reminders[0].requested_date == created
assert reminders[0].target_date == created + timedelta(hours=24)
assert reminders[0].db_id is not None
def create_job(self):
table = self.dynamo_connector.Table(self.db_table)
try:
lambdaArn = self.body['lambdaArn']
time = self.body['time']
except KeyError as exc:
raise HTTPError(status=400,
message='Missing required body fields: %s' % exc)
try:
parse(time)
except ValueError as exc:
raise HTTPError(status=400,
message='Invalid date format: %s' % exc)
db_item = {
'jobid': utils.random_id(),
'lambdaArn': lambdaArn,
'time': time,
'created_at': str(datetime.now()),
'modified_at': str(datetime.now())
}
try:
table.put_item(Item=db_item)
except Exception as exc:
warning_string = "Error creating new At Job DB entry {}"
LOG.warning(warning_string.format(lambdaArn), exc_info=exc)
raise
return db_item
def test_commenting_deleted(database, reddit):
comment_id = utils.random_id()
thread_id = utils.random_id()
comment = reddit_test.RedditObject(
body=f"{static.TRIGGER}! 1 day",
author="Watchful1",
created=utils.datetime_now(),
id=comment_id,
link_id="t3_" + thread_id,
permalink=f"/r/test/{thread_id}/_/{comment_id}/",
subreddit="test")
comments.process_comment(comment.get_pushshift_dict(), reddit, database)
assert len(comment.children) == 0
assert len(reddit.sent_messages) == 1
assert "it was deleted before I could get to it" in reddit.sent_messages[
0].body
def eval_gen(self, xs, ys):
"""
Predicts pretreatment
:param xs: x: (N, T1); seqlens; sents1
:param ys:
:return:
y_hat: (N, T2)
"""
x, seqlens, sents1 = xs
decoder_inputs, y, y_seqlen, sents2 = ys
decoder_inputs = tf.ones(
(tf.shape(xs[0])[0], 1), tf.int32) * self.token2idx["<s>"]
ys = (decoder_inputs, y, y_seqlen, sents2)
logging.info("Inference graph is being built. Please be patient.")
for _ in tqdm(range(3)):
memory, sents1, src_masks = self.encode(xs, False)
# memory_ = tf.to_int32(tf.argmax(memory, axis=-1))
# memory_ = random_id(memory)
logits, y_hat, y, sents2 = self.decode(ys, memory, src_masks,
False)
if tf.reduce_sum(y_hat, 1) == self.token2idx["<pad>"]: break
# concat input
_x = tf.concat((x, random_id(logits)), 1)
xs = (_x, seqlens, sents1)
_decoder_inputs = tf.concat((decoder_inputs, random_id(logits)), 1)
ys = (_decoder_inputs, y, y_seqlen, sents2)
# monitor a random sample
n = tf.random_uniform((), 0, tf.shape(y_hat)[0] - 1, tf.int32)
sent1 = sents1[n]
pred = convert_idx_to_token_tensor(y_hat[n], self.idx2token)
sent2 = sents2[n]
tf.summary.text("sent1", sent1)
tf.summary.text("pred", pred)
tf.summary.text("sent2", sent2)
summaries = tf.summary.merge_all()
return y_hat, summaries, logits
async def process_save(message: types.Message, state: FSMContext):
if not message.photo:
await message.answer('Отправьте валидное фото')
async with state.proxy() as data:
db.add_fake(random_id(), data['name'], data['age'], data['gender'],
data['city'], data['occupation'], data['about'],
message.photo[-1].file_id)
await state.finish()
await message.answer('Фейк добавлен. Нажмите /fake чтобы добавить ещё')
def test_commenting_banned(database, reddit):
reddit.ban_subreddit("test")
comment_id = utils.random_id()
thread_id = utils.random_id()
comment = reddit_test.RedditObject(
body=f"{static.TRIGGER}! 1 day",
author="Watchful1",
created=utils.datetime_now(),
id=comment_id,
link_id="t3_" + thread_id,
permalink=f"/r/test/{thread_id}/_/{comment_id}/",
subreddit="test")
reddit.add_comment(comment)
comments.process_comment(comment.get_pushshift_dict(), reddit, database)
assert len(comment.children) == 0
assert len(reddit.sent_messages) == 1
assert "I'm not allowed to reply in this subreddit" in reddit.sent_messages[
0].body
def test_commenting_locked(database, reddit):
thread_id = utils.random_id()
reddit.lock_thread(thread_id)
comment_id = utils.random_id()
comment = reddit_test.RedditObject(
body=f"{static.TRIGGER}! 1 day",
author="Watchful1",
created=utils.datetime_now(),
id=comment_id,
link_id="t3_" + thread_id,
permalink=f"/r/test/{thread_id}/_/{comment_id}/",
subreddit="test")
reddit.add_comment(comment)
comments.process_comment(comment.get_pushshift_dict(), reddit, database)
assert len(comment.children) == 0
assert len(reddit.sent_messages) == 1
assert "the thread is locked" in reddit.sent_messages[0].body
def save_docs(idxs, docs, params, name):
'''Save the idxs, docs with pickle.
Then you can load it again by using get_docs with name'''
docs = np.array(docs).astype(np.int)
idxs = np.array(idxs).astype(np.int)
params = filter_dict(params, prec.default_params.keys()) # only save parameters relevant to the preproc
params["docs_id"] = random_id()
file_path = get_docs_path(name)
file = open(file_path, "wb" )
pickle.dump((idxs, docs, params), file)
file.close()
def gen_unique_id(self):
"""
Generate a unique alphanumeric id for the image
The length of the id is controlled by self.id_size, set during class init by ID_SIZE config property.
"""
for _ in range(5):
id = utils.random_id(self.id_size)
if self.images.find_one({ "id": id }) == None and \
self.galleries.find_one({ "id": id }) == None:
return id
raise Exception("Failed to generate unique ID!")
async def _shorten(req):
data = await req.post()
url = data.get("input")
if url is None:
raise web.HTTPBadRequest()
if not re.match(r"^https?:\/\/.+\..+$", url):
raise web.HTTPBadRequest
url_id = random_id(req.app.config.id_length)
await req.app.db.urls.insert_one({"_id": url_id, "url": url})
return web.Response(text=url_id)
def Initialization(self,
request: environment_pb2.InitializationRequest,
context
) -> environment_pb2.InitializationResponse:
environment_parameters = from_bytes_dict(request.environment_parameters)
environment_id = random_id()
environment = self.environment_class(**environment_parameters)
with self.environments_lock:
self.environments[environment_id] = environment
print(f'started environment with id={environment_id}, parameters={environment_parameters}')
return environment_pb2.InitializationResponse(success=True, environment_id=environment_id)
def test_process_cakeday_comment(database, reddit):
username = "******"
user = reddit_test.User(
username,
utils.parse_datetime_string("2015-05-05 15:25:17").timestamp())
reddit.add_user(user)
created = utils.parse_datetime_string("2019-01-05 11:00:00")
comment_id = utils.random_id()
thread_id = utils.random_id()
comment = reddit_test.RedditObject(
body=f"{static.TRIGGER_CAKEDAY}!",
author=username,
created=created,
id=comment_id,
link_id="t3_" + thread_id,
permalink=f"/r/test/{thread_id}/_/{comment_id}/",
subreddit="test")
reddit.add_comment(comment)
utils.debug_time = utils.parse_datetime_string("2019-01-05 12:00:00")
comments.process_comment(comment.get_pushshift_dict(), reddit, database)
result = comment.get_first_child().body
assert "to remind you of your cakeday" in result
reminders = database.get_all_user_reminders(username)
assert len(reminders) == 1
assert reminders[0].user.name == username
assert reminders[0].source == utils.reddit_link(comment.permalink)
assert reminders[0].requested_date == created
assert reminders[0].target_date == utils.parse_datetime_string(
"2019-05-05 15:25:17")
assert reminders[0].id is not None
assert reminders[0].recurrence == "1 year"
assert reminders[0].message == "Happy Cakeday!"
async def _shorten(req):
data = await req.post()
text = data.get("input")
filename = data.get("filename")
if text is None:
raise web.HTTPBadRequest()
text_id = random_id(req.app.config.id_length)
await req.app.db.text.insert_one({
"_id": text_id,
"text": text,
"filename": filename
})
return web.Response(text=text_id)
def registration():
# Считывание логин, пароль, повтор пороля
data = request.get_json(force=True)
new_login = data['new_login']
new_password = data['new_password']
new_repeat_password = data['new_repeat_password']
new_nickname = data['new_nickname']
# Проверка, логина на дубляж и сравнение двух паролей.
if users.find({"login": new_login}).count() == 0:
new_id = random_id()
while users.find_one({"id": new_id}):
new_id = random_id()
token = random_string()
response = make_response()
if new_password == new_repeat_password:
password_hash = hashlib.md5(
new_password.strip().encode('utf-8'))
users.insert_one({
"id": new_id,
"login": new_login,
"password_hash": password_hash.hexdigest(),
"nickname": new_nickname,
"chat_list": [],
"contacts": [],
"session": token
})
response.set_cookie('session', token)
return json_util.dumps({'session': token})
return json_util.dumps({
'code': 400,
'status_msg': 'Пароли не совпадают.'
})
return json_util.dumps({
'code': 400,
'status_msg': 'Такой логин уже занят.'
})
def create_member(name: str, photo: str, parent: str) -> str:
command = "INSERT INTO arbre VALUES (?, ?, ?, ?)"
# create member
id = random_id() # gen ID for the new member
cursor.execute(command, (
id,
name,
photo,
parent,
))
try:
conn.commit() # commit changes to db
member = {"id": id, "name": name, "photo": photo, "parent": parent}
return member
except:
return "Member creation failed"
def join(self, known_node):
"""
Run by a node when it wants to join the network.
http://xlattice.sourceforge.net/components/protocol/kademlia/specs.html#join
"""
# When a new node is created, ping some known_node
logger.info("Pinging %r", known_node)
try:
yield from self.ping(known_node, self.identifier)
except socket.timeout:
logger.warn("Could not ping %r", known_node)
return
# Try to find all peers close to myself
# (this'll update my routing table)
yield from self.lookup_node(self.identifier)
# Pinging all neighbors will update their routing tables
logger.info("Pinging all neighbors")
yield from self.ping_all_neighbors()
try:
# Check if my public key is already in the network
yield from self.get(self.identifier)
except KeyError:
# Store my information onto the network
# (allowing others to find me)
yield from self.put(self.identifier,
(self.socket_addr, self.pub_key))
logger.info("Sending my genesis transaction %r",
self.ledger.genesis_tx)
yield from self.add_tx_to_ledger(
known_node, self.identifier,
self.ledger.genesis_tx) # add it to the ledger of bootstrapper
ledger_bootstrap = yield from self.get_ledger(
known_node, self.identifier) # get the bootstrapper's ledger
logger.info("Got Ledger %r", ledger_bootstrap)
self.ledger.record = ledger_bootstrap.record # replace my ledger with that of bootstrappers
yield from self.broadcast(
random_id(), 'add_tx_to_ledger', self.identifier, self.ledger.
genesis_tx) # broadcast my genesis transaction to everyone
def __init__(self, initial_strategy=None, states=None, initial_state=None):
if states is None:
self.states = {}
else:
self.states = states
if initial_state is None:
self.initial_state = utils.random_id()
else:
self.initial_state = initial_state
self.state = self.initial_state
self.type = 2
self.payoffs = 0
if initial_strategy:
self._set_initial(initial_strategy)
def __init__(self, game):
self.game = game
self.x = 3
self.y = 21
self.rotation = 0
self.shape_cache = {}
self.shape_cache[0] = self.shape
for i in range(3)[::-1]:
self.shape_cache[i + 1] = rotate_cw(self.shape_cache[(i + 2) % 4])
self.last_successful_movement = None
self.last_rotation_info = None
self.phase = 'drop'
self.locking_start = 0
self.tick = 0
self.move_counter = 0
self.id = random_id()
def _add_random_state(self):
"""
Creates a random new state
"""
action = random.choice(['continue', 'exit'])
num_states = len(self.states)
new_id = utils.random_id()
ids = self.states.keys() + [new_id]
set = {
'strategy_set': {
'looked': {
'low': {
'defect': random.choice(ids),
'cooperate': random.choice(ids),
},
'high': {
'defect': random.choice(ids),
'cooperate': random.choice(ids),
},
},
'nolook': {
'low': {
'defect': random.choice(ids),
'cooperate': random.choice(ids),
},
'high': {
'defect': random.choice(ids),
'cooperate': random.choice(ids),
},
}
},
'action_set': {
'action': action,
},
'id': new_id,
}
self.states[new_id] = State(**set)
return new_id
def __init__(self, alpha=3, k=20, identifier=None):
# Initialiaze DatagramRPCProtocol
super(KademliaNode, self).__init__()
# TODO: Make the node id a function of node's public key
# Just like Bitcoin wallet IDs use HASH160
if identifier is None:
identifier = random_id()
self.identifier = identifier
# Constants from the kademlia protocol
self.k = k
self.alpha = alpha
# Each node has their own dictionary
self.storage = {}
# The k-bucket based kademlia routing table
self.routing_table = RoutingTable(self.identifier, k=self.k)
def test_add_reminder_no_date(database, reddit):
created = utils.datetime_now()
username = "******"
id = utils.random_id()
message = reddit_test.RedditObject(
body=f"{static.TRIGGER}! \"error test\"",
author=username,
created=created,
id=id)
messages.process_message(message, reddit, database)
result = message.get_first_child().body
assert "This time has already passed" not in result
assert "Could not find a time in message, defaulting to one day" in result
reminders = database.get_all_user_reminders(username)
assert len(reminders) == 1
assert reminders[0].user.name == username
assert reminders[0].message == "error test"
assert reminders[0].source == utils.message_link(id)
assert reminders[0].requested_date == created
assert reminders[0].target_date == created + timedelta(hours=24)
assert reminders[0].id is not None
def __init__(self, torrent):
self.torrent = torrent
self.peer_id = "-DE13F0-" + utils.random_id(12)
self.download_key = utils.random_id(12)
self.port = 12394
def test_update_incorrect_comments(database, reddit):
comment_id1 = utils.random_id()
thread_id1 = utils.random_id()
comment1 = reddit_test.RedditObject(
body=f"{static.TRIGGER}! 1 day",
author="Watchful1",
created=utils.datetime_now(),
id=comment_id1,
link_id="t3_" + thread_id1,
permalink=f"/r/test/{thread_id1}/_/{comment_id1}/",
subreddit="test")
reddit.add_comment(comment1)
comments.process_comment(comment1.get_pushshift_dict(), reddit, database)
comment_id2 = utils.random_id()
thread_id2 = utils.random_id()
comment2 = reddit_test.RedditObject(
body=f"{static.TRIGGER}! 1 day",
author="Watchful1",
created=utils.datetime_now(),
id=comment_id2,
link_id="t3_" + thread_id2,
permalink=f"/r/test/{thread_id2}/_/{comment_id2}/",
subreddit="test")
reddit.add_comment(comment2)
comments.process_comment(comment2.get_pushshift_dict(), reddit, database)
comment_id3 = utils.random_id()
thread_id3 = utils.random_id()
comment3 = reddit_test.RedditObject(
body=f"{static.TRIGGER}! 1 day",
author="Watchful1",
created=utils.datetime_now(),
id=comment_id3,
link_id="t3_" + thread_id3,
permalink=f"/r/test/{thread_id3}/_/{comment_id3}/",
subreddit="test")
reddit.add_comment(comment3)
comments.process_comment(comment3.get_pushshift_dict(), reddit, database)
reminders = [
Reminder(
source="https://www.reddit.com/message/messages/XXXXX",
message=utils.reddit_link(comment1.permalink),
user=database.get_or_add_user("Watchful1"),
requested_date=utils.parse_datetime_string("2019-01-01 04:00:00"),
target_date=utils.parse_datetime_string("2019-01-05 05:00:00")),
Reminder(
source="https://www.reddit.com/message/messages/XXXXX",
message=utils.reddit_link(comment1.permalink),
user=database.get_or_add_user("Watchful1"),
requested_date=utils.parse_datetime_string("2019-01-01 04:00:00"),
target_date=utils.parse_datetime_string("2019-01-06 05:00:00")),
Reminder(
source="https://www.reddit.com/message/messages/XXXXX",
message=utils.reddit_link(comment1.permalink),
user=database.get_or_add_user("Watchful1"),
requested_date=utils.parse_datetime_string("2019-01-01 04:00:00"),
target_date=utils.parse_datetime_string("2019-01-07 05:00:00")),
Reminder(
source="https://www.reddit.com/message/messages/XXXXX",
message=utils.reddit_link(comment2.permalink),
user=database.get_or_add_user("Watchful1"),
requested_date=utils.parse_datetime_string("2019-01-01 04:00:00"),
target_date=utils.parse_datetime_string("2019-01-08 05:00:00")),
Reminder(
source="https://www.reddit.com/message/messages/XXXXX",
message=utils.reddit_link(comment2.permalink),
user=database.get_or_add_user("Watchful1"),
requested_date=utils.parse_datetime_string("2019-01-01 04:00:00"),
target_date=utils.parse_datetime_string("2019-01-09 05:00:00"))
]
for reminder in reminders:
database.add_reminder(reminder)
comments.update_comments(reddit, database)
assert "3 OTHERS CLICKED THIS LINK" in reddit.get_comment(
comment_id1).get_first_child().body
assert "2 OTHERS CLICKED THIS LINK" in reddit.get_comment(
comment_id2).get_first_child().body
assert "CLICK THIS LINK" in reddit.get_comment(
comment_id3).get_first_child().body
def two_phase_protocol(node):
logger = logging.getLogger('node')
while True:
if (node.isbusy[0]): # if involved in some transaction
txs = node.isbusy[1] # get that transaction
if txs[0].sender == node.identifier: # if current node is the sender
"""Phase 1"""
print("I am sender")
digital_signature = sign_msg(node.pvt_key, repr(txs))
logger.info("Generated Digital Signature %r",
digital_signature)
senders_pub_key = (yield from node.get(txs[0].sender))[1]
receiver_sock = (yield from node.get(txs[0].receiver))[0]
receiver_status = yield from node.become_receiver(
receiver_sock, node.identifier, txs)
witness_sock = (yield from node.get(txs[0].witness))[0]
witness_status = yield from node.become_witness(
witness_sock, node.identifier, txs)
if receiver_status == "busy" or witness_status == "busy":
logger.info("Phase 1 failed, aborting transaction!")
# Send abort to both receiver & witness
receiver_abort = yield from node.abort_tx(
receiver_sock, node.identifier, txs)
witness_abort = yield from node.abort_tx(
witness_sock, node.identifier, txs)
# If both of them have aborted then I'll abort too
if (witness_abort == "aborted"
and receiver_abort == "aborted"):
yield from node.abort_tx(node.socket_addr,
node.identifier, txs)
else:
""" Phase 2 """
logger.info("Phase 1 complete - Now entering Phase 2")
# Send commit to both receiver & witness
receiver_commit = yield from node.commit_tx(
receiver_sock, node.identifier, txs, digital_signature,
senders_pub_key)
witness_commit = yield from node.commit_tx(
witness_sock, node.identifier, txs, digital_signature,
senders_pub_key)
if (witness_commit == "committed"
and receiver_commit == "committed"):
logger.info("Phase 2 complete")
yield from node.commit_tx(
node.socket_addr, node.identifier, txs,
digital_signature,
senders_pub_key) # Commit transaction
yield from node.broadcast(random_id(), 'commit_tx',
node.identifier, txs,
digital_signature,
senders_pub_key)
node.isbusy = (False, None)
else:
receiver_abort = yield from node.abort_tx(
receiver_sock, node.identifier,
txs) # send abort to receiver
witness_abort = yield from node.abort_tx(
witness_sock, node.identifier,
txs) # send abort to witness
if (witness_abort == "aborted"
and receiver_abort == "aborted"):
yield from node.abort_tx(
node.socket_addr, node.identifier,
txs) # send abort to itslef(sender)
# do the work of sender
elif txs[0].receiver == node.identifier:
print("I am receiver")
# do the work of receiver
# Do the work of witnes
elif txs[0].witness == node.identifier:
print("I am witness")
yield from asyncio.sleep(1)
def _set_initial(self, strat='alle'):
"""
Sets initial strategy
Options are:
alle
allc
only_cwol
"""
if strat == 'alle':
strategy_set ={
'looked':{
'low': {
'defect': self.initial_state,
'cooperate': self.initial_state,
},
'high': {
'defect': self.initial_state,
'cooperate': self.initial_state,
},
},
'nolook': {
'low': {
'defect': self.initial_state,
'cooperate': self.initial_state,
},
'high': {
'defect': self.initial_state,
'cooperate': self.initial_state,
},
}
}
action_set = {
'action': 'exit',
}
self.states[self.initial_state] = State(strategy_set=copy.deepcopy(strategy_set), action_set=copy.deepcopy(action_set), id=self.initial_state)
self.state = self.initial_state
elif strat == 'allc':
strategy_set ={
'looked':{
'low': {
'defect': self.initial_state,
'cooperate': self.initial_state,
},
'high': {
'defect': self.initial_state,
'cooperate': self.initial_state,
},
},
'nolook': {
'low': {
'defect': self.initial_state,
'cooperate': self.initial_state,
},
'high': {
'defect': self.initial_state,
'cooperate': self.initial_state,
},
}
}
action_set = {
'action': 'continue',
}
self.states[self.initial_state] = State(strategy_set=copy.deepcopy(strategy_set), action_set=copy.deepcopy(action_set), id=self.initial_state)
self.state = self.initial_state
elif strat == 'only_cwol':
id_2 = utils.random_id()
strategy_set ={
'looked':{
'low': {
'defect': self.initial_state,
'cooperate': self.initial_state,
},
'high': {
'defect': self.initial_state,
'cooperate': self.initial_state,
},
},
'nolook': {
'low': {
'defect': self.initial_state,
'cooperate': id_2,
},
'high': {
'defect': self.initial_state,
'cooperate': id_2,
},
}
}
action_set = {
'action': 'exit',
}
strategy_set2 ={
'looked':{
'low': {
'defect': self.initial_state,
'cooperate': self.initial_state,
},
'high': {
'defect': self.initial_state,
'cooperate': self.initial_state,
},
},
'nolook': {
'low': {
'defect': self.initial_state,
'cooperate': id_2,
},
'high': {
'defect': self.initial_state,
'cooperate': id_2,
},
}
}
action_set2 = {
'action': 'continue',
}
self.states[self.initial_state] = State(strategy_set=copy.deepcopy(strategy_set), action_set=copy.deepcopy(action_set), id=self.initial_state)
self.states[id_2] = State(strategy_set=copy.deepcopy(strategy_set2), action_set=copy.deepcopy(action_set2), id=id_2)
self.state = self.initial_state
def run_training(df_name, model_name, is_GPU=True, params=None):
default_params = {
"nb_epochs": 10,
"my_patience": 4,
"batch_size": 80,
"optimizer": "adam",
"learning_rate": 0.01,
"momentum": 0.9,
"nesterov": True,
"activation": "linear",
"drop_rate": 0.3,
"n_units": 50,
"roll2vec": True,
"embs_multiplier": 1,
"multi_dense": True,
"dense_acti": "linear",
"full_pred": True,
}
params = merge_params(params, default_params)
docs, target, params_data = data.get_dataset(df_name)
params = merge_params(
params_data,
params) # Force the parameters to be the one of the dataset
X_train, X_test, y_train, y_test = train_test_split(docs,
target,
test_size=0.3)
params["split_id"] = random_id() # id to identify the split later
# = = = = = fitting the model on 4 targets = = = = #
# Building the models
embeddings = data.get_embeddings(roll2vec=params["roll2vec"],
multiplier=params["embs_multiplier"])
print("### EMBS SHAPE : {} ###".format(embeddings.shape))
model = HAN(embeddings,
docs.shape,
is_GPU=is_GPU,
activation=params["activation"],
drop_rate=params["drop_rate"],
n_units=params["n_units"],
multi_dense=params["multi_dense"],
dense_acti=params["dense_acti"],
full_pred=params["full_pred"])
if params["optimizer"] == 'sgd':
decay_rate = params["learning_rate"] / params["nb_epochs"]
my_optimizer = optimizers.SGD(lr=params["learning_rate"],
decay=decay_rate,
momentum=params["momentum"],
nesterov=params["nesterov"])
elif params["optimizer"] == 'adam':
my_optimizer = optimizers.Adam()
elif params["optimizer"] == 'nadam':
my_optimizer = optimizers.Nadam()
model.compile(loss='mean_squared_error',
optimizer=my_optimizer,
metrics=['mae'])
# Training for each target
params["train_id"] = random_id()
n_target = 1 if params["full_pred"] else 4
for tgt in range(n_target):
t0 = time.process_time()
# = = = = = training = = = = =
early_stopping = EarlyStopping(monitor='val_loss',
patience=params["my_patience"],
mode='min')
# save model corresponding to best epoch
if params["full_pred"]: tgt = "full"
model_file = os.path.join(
data.data_path, "models/",
"{}_{}_{}_model.h5".format(model_name, df_name, tgt))
checkpointer = ModelCheckpoint(filepath=model_file,
verbose=1,
save_best_only=True,
save_weights_only=True)
my_callbacks = [early_stopping, checkpointer]
y_train_tgt = y_train if params["full_pred"] else y_train[tgt]
y_test_tgt = y_test if params["full_pred"] else y_test[tgt]
model.fit(X_train,
y_train_tgt,
batch_size=params["batch_size"],
epochs=params["nb_epochs"],
validation_data=(X_test, y_test_tgt),
callbacks=my_callbacks)
T = time.process_time() - t0
hist = model.history.history
scores = get_scores(hist)
scores["T"] = time.process_time() - t0
data.save_perf(params, scores, tgt)
print("################ {} minutes spent...###########".format(
round(T / 60)))
return params
def __init__(self, torrent):
self.torrent = torrent
self.peer_id = "-DE13F0-" + utils.random_id(12)
self.download_key = utils.random_id(12)
self.port = random.randint(1025, 65535)
async def node_repl(node):
while True:
line = await ainput(">>> ")
# Since it reads the "\n" when you press enter
line = line.strip()
if not line:
continue
# Handle arguments with spaces etc.
line = list(shlex.shlex(line))
cmd = line[0]
args = line[1:]
if cmd in ['id']:
"Print id of a node"
if len(args) == 1:
peer_name = args[0]
peer_socket = get_sock_from_name(args[0])
try:
peer_id = await node.ping(peer_socket, node.identifier)
print("%s's id is %d" % (peer_name, peer_id))
except socket.timeout:
print("Failed to ping node %s" % args[0])
else:
print("My id is %d" % node.identifier)
# TODO: Print hash table of a particular node
elif cmd in ['ht', 'hash_table']:
"Print my hash table"
print(node.storage_str())
# TODO: Print routing table of a particular node
elif cmd in ['rt', 'routing_table']:
"Print my routing table"
print(node.routing_table)
elif cmd in ['put']:
"Store a (key, value) pair on the network DHT"
if (len(args) != 2):
print("Expected 2 arguments, %d given" % len(args))
else:
num = await node.put(args[0], args[1], hashed=False)
print("Value stored at %d node(s)" % num)
elif cmd in ['get']:
"Access a previously stored value by its key"
if (len(args) != 1):
print("Expected 1 argument, %d given" % len(args))
else:
try:
value = await node.get(args[0], hashed=False)
print(value)
except KeyError:
print("Key not found")
elif cmd in ['sa', 'send_amount']:
"Send bitcoins to a node"
if (len(args) != 4):
print("Expected 4 arguments, %d given" % len(args))
else:
try:
sender_sock = get_sock_from_name(args[0])
receiver_sock = get_sock_from_name(args[1])
witness_sock = get_sock_from_name(args[2])
receiver_id = await node.ping(receiver_sock,
node.identifier)
witness_id = await node.ping(witness_sock, node.identifier)
amount = int(args[3])
reply = await node.request(sender_sock,
"send_amount", node.identifier,
int(receiver_id),
int(witness_id), amount)
print(reply)
except Exception as e:
print("Exception Caught : ", e)
elif cmd in ['?', 'help']:
"List commands"
# Find left-justification factor
ljust = max(map(len, HELP_DICT.keys()))
for cmd, doc in HELP_DICT.items():
print(cmd.ljust(ljust) + " : " + doc)
print()
elif cmd in ['bd', 'brd', 'bc', 'broadcast']:
"Broadcast an RPC over the network"
if (len(args) < 1):
print("Expected atleast 1 argument, %d given" % len(args))
else:
await node.broadcast(random_id(), args[0], node.identifier,
*args[1:])
elif cmd in ['ld', 'ledger']:
"Pretty print the ledger."
print(node.ledger)
else:
print("Please enter valid input.\nType help to see commands")
