def test_conversation_sorting(self):
lastest = Conversation(self.user1, 'lastest', start_time=datetime(2013,1,1))
Conversation(self.user1, 'last', start_time=datetime(2013,1,3))
Conversation(self.user1, 'first', start_time=datetime(2013,1,1))
Conversation(self.user1, 'middle', start_time=datetime(2013,1,2))
lastest.update_time = datetime(2013,1,4)
db.session.commit()
r = self.app.get(self.path)
d = PyQuery(r.data)
assert len(d('.conversation')) == 4
assert [e.text() for e in d('.conversation > .title > a').items()] == ['lastest', 'last', 'middle', 'first']
def test_unread_conversations(self):
user = User('user', '123456')
conv1 = Conversation(user, 'first conversation')
conv1.messages.append(Message(user, 'first conversation message'))
conv2 = Conversation(user, 'second conversation')
conv2.messages.append(Message(user, 'second conversation message'))
db.session.add(user)
db.session.commit()
user.set_last_read_message(conv2, conv2.messages[-1].id)
db.session.commit()
assert len(conv1.get_unread_messages(user)) == 1
assert len(conv2.get_unread_messages(user)) == 0
conversations = user.get_unread_conversations()
assert len(conversations) == 1
assert conversations[0].title == 'first conversation'
def setUp(self):
super(UnreadTests, self).setUp()
self.user1 = User('self.user1', '123456')
self.user2 = User('self.user2', '123456')
self.conv = Conversation(self.user1, 'some title')
self.conv.messages.append(Message(self.user2, 'first message'))
self.conv.messages.append(Message(self.user2, 'second message'))
self.conv.messages.append(Message(self.user1, 'third message'))
self.conv.messages.append(Message(self.user2, 'fourth message'))
db.session.add_all([self.user1, self.user2])
db.session.commit()
def _make_estimator():
params = tf.contrib.training.HParams(**Config.model.to_dict())
# Using CPU
run_config = tf.contrib.learn.RunConfig(
model_dir=Config.train.model_dir,
session_config=tf.ConfigProto(device_count={'GPU': 0}))
conversation = Conversation()
return tf.estimator.Estimator(model_fn=conversation.model_fn,
model_dir=Config.train.model_dir,
params=params,
config=run_config)
async def _instantiate_dialog(self, user: User, peer: Union[User, Bot]):
log.info(f'instantiating the dialog')
conversation = Conversation(participant1=ConversationPeer(peer=user),
participant2=ConversationPeer(peer=peer))
profiles = await run_sync_in_executor(PersonProfile.objects)
profiles_count = await run_sync_in_executor(profiles.count)
for p in conversation.participants:
p.assigned_profile = profiles[random.randrange(profiles_count)]
while True:
conv_id = random.getrandbits(31)
if conv_id not in self._active_dialogs and \
await run_sync_in_executor(lambda: Conversation.objects(conversation_id=conv_id).count()) == 0:
break
conversation.conversation_id = conv_id
self._active_dialogs[conv_id] = conversation
for p in conversation.participants:
target_gateway = self._gateway_for_peer(p)
await target_gateway.start_conversation(conv_id, p.peer, p.assigned_profile)
self._reset_inactivity_timer(conv_id)
def experiment_fn(run_config, params):
# 先定义estimator
conversation = Conversation()
estimator = tf.estimator.Estimator(model_fn=conversation.model_fn,
model_dir=Config.train.model_dir,
params=params,
config=run_config)
# 返回字典
vocab = data_loader.load_vocab("vocab")
Config.data.vocab_size = len(vocab)
# 定义训练数据
train_X, test_X, train_y, test_y = data_loader.make_train_and_test_set()
train_input_fn, train_input_hook = data_loader.make_batch(
(train_X, train_y), batch_size=Config.model.batch_size)
test_input_fn, test_input_hook = data_loader.make_batch(
(test_X, test_y), batch_size=Config.model.batch_size, scope="test")
train_hooks = [train_input_hook]
if Config.train.print_verbose:
train_hooks.append(
hook.print_variables(
variables=['train/enc_0', 'train/dec_0', 'train/pred_0'],
rev_vocab=utils.get_rev_vocab(vocab),
every_n_iter=Config.train.check_hook_n_iter))
if Config.train.debug:
train_hooks.append(tf_debug.LocalCLIDebugHook())
eval_hooks = [test_input_hook]
if Config.train.debug:
eval_hooks.append(tf_debug.LocalCLIDebugHook())
# 定义实验
experiment = tf.contrib.learn.Experiment(
estimator=estimator,
train_input_fn=train_input_fn,
eval_input_fn=test_input_fn,
train_steps=Config.train.train_steps,
min_eval_frequency=Config.train.min_eval_frequency,
train_monitors=train_hooks,
eval_hooks=eval_hooks,
eval_delay_secs=0)
return experiment
def main_route():
if request.method == 'POST':
try:
payload = request.get_json()
for message, sender in messaging_events(payload):
# if a convo with this sender exists, run the appropriate protocol
#found = convos.find_one({"id": sender}).count()
#if found != 0:
# temp = Conversation(sender);
# temp.prefs = found["prefs"]
# temp.curState = found["curState"]
# temp.id = found["id"]
# temp.numBeds = found["numBeds"]
# parse_and_respond(temp, message)
# convos.update_one({"id": sender}, temp)
#else:
# temp = Conversation(sender);
# convos.insert_one(temp)
# message = "Initial question as result of function here"
if sender in convos:
parse_and_respond(sender, message)
else:
convos[sender] = Conversation(sender)
parse_and_respond(sender, message)
return "okay"
except Exception as e:
print(type(e))
print(e.args)
elif request.method == 'GET':
if request.args.get('hub.verify_token') == config.env['verify_token']:
return request.args.get('hub.challenge')
return "Wrong Verify Token"
return "Hello World"
def check_or_create_conversation(user_id):
"""Checks if there is a chat history between the current user and the other user_id. If there is, it loads the history,
if there isn't it creates a row in the table. Users are assigned to messager1 or 2 depending on whose user is is larger.
"""
bigger = max(current_user.id, int(user_id))
lower = min(current_user.id, int(user_id))
conversation = Conversation.query.filter(
(Conversation.messager_1 == bigger)
& (Conversation.messager_2 == lower)).first()
if not conversation:
new_convo = Conversation(messager_1=bigger, messager_2=lower)
db.session.add(new_convo)
db.session.commit()
# As soon as the conversation has been added to the database, query the database for the conversation.
conversation = Conversation.query.filter(
(Conversation.messager_1 == bigger)
& (Conversation.messager_2 == lower)).first()
return redirect(f'/chat/messages/{conversation.id}')
class UnreadTests(Base):
def setUp(self):
super(UnreadTests, self).setUp()
self.user1 = User('self.user1', '123456')
self.user2 = User('self.user2', '123456')
self.conv = Conversation(self.user1, 'some title')
self.conv.messages.append(Message(self.user2, 'first message'))
self.conv.messages.append(Message(self.user2, 'second message'))
self.conv.messages.append(Message(self.user1, 'third message'))
self.conv.messages.append(Message(self.user2, 'fourth message'))
db.session.add_all([self.user1, self.user2])
db.session.commit()
def test_all_unread(self):
messages = self.conv.get_unread_messages(for_user=self.user1)
assert len(messages) == 4
messages = self.conv.get_unread_messages(for_user=self.user2)
assert len(messages) == 4
def test_no_unread(self):
self.user1.set_last_read_message(self.conv, message_id=4)
db.session.commit()
messages = self.conv.get_unread_messages(for_user=self.user1)
assert len(messages) == 0
def test_some_unread(self):
self.user1.set_last_read_message(self.conv, message_id=2)
self.user1.set_last_read_message(self.conv, message_id=3)
user1messages = self.conv.get_unread_messages(for_user=self.user1)
user2messages = self.conv.get_unread_messages(for_user=self.user2)
[m.text for m in user1messages] == ['third message', 'fourth message']
[m.text for m in user2messages] == ['fourth message']
def test_mark_read(self):
self.conv.mark_read(self.user1)
db.session.commit()
user1messages = self.conv.get_unread_messages(for_user=self.user1)
assert len(user1messages) == 0
def response():
action = cgi_get("action", choices=["join", "activate", "login", "contact", "edit", "email"])
if action == "join":
email = cgi_get("email")
if CTUser.query(CTUser.email == email).get():
fail("this email is already in use")
user_type = cgi_get("utype")
u = db.get_model(user_type)(email=email,
firstName=cgi_get("firstName"), lastName=cgi_get("lastName"),
**cgi_get("extras"))
u.put() # to generate created timestamp
u.password = db.hashpass(cgi_get("password"), u.created)
rule = config.ctuser.activation.get(user_type, config.ctuser.activation.ctuser)
if rule == "auto":
u.active = True
else: # assumes config.mailer (otherwise, don't change activation "auto" default)
usk = u.key.urlsafe()
if rule == "confirm":
send_mail(to=u.email, subject="activation required",
body=JOIN%(usk,))
else: # email admin to handle it
send_mail(to=rule, subject="activation required", body=JOINED%(email, usk))
u.put()
succeed(u.data())
elif action == "activate":
u = db.get(cgi_get("key"))
if u and not u.active: # else, don't even trip
u.active = True
u.put()
send_mail(to=u.email, subject="account activated",
body=ACTIVATE)
redirect("/", "you did it!")
elif action == "login":
u = CTUser.query(CTUser.email == cgi_get("email"),
CTUser.active == True).get()
if not u or u.password != db.hashpass(cgi_get("password"), u.created):
fail()
succeed(u.data())
elif action == "contact":
sender = db.get(cgi_get("user"))
message = cgi_get("message")
convokey = cgi_get("conversation", required=False)
if convokey:
conversation = db.get(convokey)
else:
conversation = Conversation()
conversation.topic = cgi_get("topic")
conversation.participants = [sender.key, db.KeyWrapper(cgi_get("recipient"))]
conversation.put()
m = Message(sender=sender.key, conversation=conversation.key, body=message)
m.put()
for recipient in conversation.participants:
if recipient != sender.key:
send_mail(to=recipient.get().email,
subject="message from %s"%(sender.firstName,),
body=CONTACT%(sender.fullName(), message,
sender.firstName, sender.key.urlsafe(), conversation.key.urlsafe()))
succeed(convokey and m.key.urlsafe() or conversation.key.urlsafe())
elif action == "edit":
changes = cgi_get("changes")
changes["key"] = cgi_get("user")
edit(changes)
elif action == "email":
sender = db.get(cgi_get("user"))
if not sender.admin:
fail()
recips = cgi_get("recipients", default=[])
if not recips:
if config.wpmail:
log("no recipients specified -- WP mode enabled -- building recipient list...")
recips = getWPmails()
else:
fail("no recipients specified -- can't email nobody")
batch(recips, lambda chunk : send_mail(bcc=chunk,
subject=cgi_get("subject"), body=cgi_get("body")), chunk=100)
async def _instantiate_dialog(self, user: User, peer: Union[User, Bot]):
log.info(f'instantiating the dialog')
conversation = Conversation(
participant1=ConversationPeer(
peer=user, peer_conversation_guid=uuid4().__str__()),
participant2=ConversationPeer(
peer=peer, peer_conversation_guid=uuid4().__str__()))
tags_set: QuerySet = Settings.objects(name='tags')
active_tags = tags_set.first().value if tags_set.count() else []
if active_tags:
profiles: QuerySet = await run_sync_in_executor(
PersonProfile.objects(tags__in=active_tags))
if profiles.count() == 0:
log.warning(f'Not found any profiles with tags: {active_tags}')
profiles: QuerySet = await run_sync_in_executor(
PersonProfile.objects)
else:
profiles: QuerySet = await run_sync_in_executor(
PersonProfile.objects)
first_profile = None
linked_profile_uuid = None
for p in conversation.participants:
if first_profile is None:
p.assigned_profile = first_profile = random.choice(profiles)
linked_profile_uuid = first_profile.link_uuid
else:
# profiles assignment order:
# other profile from the same linked group || profile with unmatching sentences || same profile
second_profile = random.choice(
profiles(id__ne=first_profile.id,
link_uuid=linked_profile_uuid)
or (profiles(persona__ne=first_profile.persona)
or [first_profile]))
p.assigned_profile = second_profile
while True:
conv_id = random.getrandbits(31)
if conv_id not in self._active_dialogs and \
await run_sync_in_executor(lambda: Conversation.objects(conversation_id=conv_id).count()) == 0:
break
conversation.conversation_id = conv_id
conversation.messages_to_switch_topic = self.dialog_options[
'n_messages_to_switch_topic']
conversation.reset_topic_switch_counter()
self._active_dialogs[conv_id] = conversation
topics = [
'Социальные сети', 'Фитнес', 'Уборка и чистота', 'Одиночество',
'Мода', 'Женская внешность', 'Мужская внешность',
'Деньги, богатство', 'Машины', 'Счастье'
]
curr_topic = random.sample(topics, k=1)
str_topic = curr_topic[0]
msg = conversation.add_message(text='Switched to topic ' + str_topic,
sender=peer,
system=True)
for p in conversation.participants:
target_gateway = self._gateway_for_peer(p)
p.assigned_profile.topics[0] = str_topic
await target_gateway.start_conversation(conv_id, p.peer,
p.assigned_profile,
p.peer_conversation_guid)
self._reset_inactivity_timer(conv_id)
def createConversation(userStarted, partner):
global conversations
c = Conversation(createNewUid(), userStarted, partner)
conversations += [c]
userStarted.conversations += [c]
return c
def conversation(self):
return Conversation(conversation_id=3, participant1=self.conversation_peers[0],
participant2=self.conversation_peers[1], messages=self.messages,
start_time=self.messages[0].time, end_time=self.messages[-1].time)
