def test_addDocument(self):
message1 = Message(3, 'sdf',
'A project to cluster high-dimensional streams.',
test_time)
message1.vector = Vector({3: 4})
stream1 = Stream(3, message1)
message2 = Message(4, 'sdf',
'A project to cluster high-dimensional streams.',
test_time)
message2.vector = Vector({2: 4})
stream2 = Stream(4, message2)
self.assertNotEqual(test_time, self.cluster1.lastStreamAddedTime)
self.cluster1.addDocument(stream1)
self.assertEqual(test_time, self.cluster1.lastStreamAddedTime)
# Test if cluster id is set.
self.assertEqual(self.cluster1.clusterId, stream1.clusterId)
# Test that cluster mean is updated.
self.assertEqual({1: 2 / 2., 2: 2., 3: 2.}, self.cluster1)
# Test that cluster aggrefate is updated.
self.assertEqual({1: 2, 2: 4, 3: 4}, self.cluster1.aggregateVector)
# Test that document is added to cluster documents.
self.assertEqual(stream1,
self.cluster1.documentsInCluster[stream1.docId])
self.cluster1.addDocument(stream2)
self.assertEqual(3, self.cluster1.vectorWeights)
self.assertEqual({1: 2 / 3., 2: 8 / 3., 3: 4 / 3.}, self.cluster1)
self.assertEqual({1: 2, 2: 8, 3: 4}, self.cluster1.aggregateVector)
def setUp(self):
self.m1 = Message(1, 'sdf',
'A project to cluster high-dimensional streams.',
test_time - timedelta(seconds=60))
self.m1.vector = Vector({1: 1., 2: 3.})
self.stream = Stream(1, self.m1)
self.m2 = Message(1, 'sdf',
'A project to cluster high-dimensional streams.',
test_time)
self.m2.vector = Vector({2: 3.})
def congrats(surface):
global RETRY_COUNTER
draw_tint(GREEN, surface)
c1 = Message(surface, (480, 220), 'You Completed ', font=pg.font.SysFont('comicsansms', 60, True),
bg_color=BROWN)
c2 = Message(surface, (480, 300), 'All the Waves! ', font=pg.font.SysFont('comicsansms', 60, True),
bg_color=BROWN)
c1.blit()
c2.blit()
RETRY_COUNTER += DT
if RETRY_COUNTER >= 2:
user.try_again = Message(surface, (560, 420), 'Play Again?', font=pg.font.SysFont('comicsansms', 58, True),
bg_color=GREEN)
user.try_again.blit()
def gg(surface):
global RETRY_COUNTER
draw_tint(RED, surface)
gg1 = Message(surface, (480, 223), ' You Lost All ', font=pg.font.SysFont('comicsansms', 56, True),
bg_color=BROWN)
gg2 = Message(surface, (480, 300), ' Your Lives...', font=pg.font.SysFont('comicsansms', 56, True),
bg_color=BROWN)
gg1.blit()
gg2.blit()
RETRY_COUNTER += DT
if RETRY_COUNTER >= 2:
user.try_again = Message(surface, (565, 420), 'Try Again?', font=pg.font.SysFont('comicsansms', 58, True),
bg_color=GREEN)
user.try_again.blit()
def cmd_help(args):
if len(args) == 0:
msg =\
"""
For additional help, run `!help <command name>` e.g. `!help !roll`
Available commands:
"""
for cmd in commands.list:
msg += "`{cmd}`: {desc}\n".format(cmd=cmd.name, desc=cmd.desc)
else:
msg = ""
for name in args:
if name in commands.map.keys():
cmd = commands.map[name]
if type(cmd.help) is str:
msg += cmd.help
elif cmd.help is None:
msg += "Usage: `{cmd}`\n{desc}".format(cmd=cmd.name,
desc=cmd.desc)
else:
msg += cmd.help(args[1:]).content
else:
msg += "`{name}` is not a valid command".format(name=name)
msg += '\n'
return Message(content=msg)
def setUp(self):
self.message = Message(
1, 'sdf', 'A project to cluster high-dimensional streams.',
datetime.now())
self.message.vector = Vector({1: 2., 2: 3.})
self.s1 = Stream(1, self.message)
self.v1 = Vector({1: 2., 3: 3.})
def show_start_wave(user_info, surface):
global WAVE_TIME, START_WAVE, CREATE_WAVE
start_wave = Message(surface, (0, 10), ('Start Wave ' + str(user_info.wave + 1) + '/' + str(user_info.waves)),
font=pg.font.SysFont('comicsansms', 24, True), bg_color=BROWN)
start_wave.rect.right = 48*TILE_SIZE - 10
start_wave.blit()
user_info.start_wave = start_wave
def send(self, user_id, message: Message):
if isinstance(message, str):
message = Message(content=message)
assert (isinstance(message, Message))
payload = {
"recipient": {
"id": user_id
},
"message": dict(),
"notification_type": message.notification_type.value,
"messaging_type": message.message_type.value
}
if message.content:
payload["message"]["text"] = message.content
if message.quick_replies:
payload["message"]["quick_replies"] = [
x.to_dict() for x in message.quick_replies
]
if message.metadata:
payload["message"]["metadata"] = message.metadata
if message.tag:
payload["tag"] = message.tag
self.send_raw(payload)
def createMockData():
connection = sqlite3.connect(DATABASE_URI)
c = connection.cursor()
c.execute("DELETE FROM users")
c.execute("DELETE FROM messages")
connection.commit()
connection.close()
user = User("*****@*****.**", hash("abcde"),"John","Smith","Decidedly male","Kansas City","Murica")
user2 = User("*****@*****.**", hash("abcdef"),"John","Wick","Surely male","Missouri","Murica")
message = Message(user.email, user.email, "Hello World!")
message2 = Message(user.email, user2.email, "Hej World!")
addUser(user)
addUser(user2)
addMessage(message)
addMessage(message2)
def handler_custom_email(self, req: MessagingEntry):
req.sender.send(
Message(content="Thanks for signing up! You just got $250!"))
self.balances[req.sender.id] = 250.0
self.emails[req.sender.id] = req.message
req.sender.set_state("Home")
req.continue_processing = True
def send_signup(self, user):
user.send(
Message(content="Welcome to PayBot! What's your email?",
quick_replies=[
QuickReply("",
action=ExecuteFunction(self.save_email),
content_type=ContentType.email)
]))
user.set_state("WaitingEmail")
def help_stats(args):
msg =\
"""
Usage: `!stats <subcommand>`
Subcommands:
"""
msg += commands_stats.help_commands(args)
return Message(msg)
def send_home_options(self, user: User):
user.send(
Message(content="What do you want to do?",
quick_replies=[
QuickReply("Pay", ExecuteFunction(self.prompt_pay)),
QuickReply("Get balance",
ExecuteFunction(self.send_balance)),
QuickReply("Something else", SetState("Advanced"))
]))
def test_maxClusterSize(self):
self.assertEqual(1, self.crowd.maxClusterSize)
message2 = Message(4, 'sdf',
'A project to cluster high-dimensional streams.',
test_time)
message2.vector = Vector({2: 4})
stream2 = Stream(4, message2)
self.cluster.addDocument(stream2)
self.assertEqual(2, self.crowd.maxClusterSize)
def test_parse_message():
# (message "{channel}" "{text}")
got = lisp.parse('(message "#chan" "toxt")')
want = Message("#chan", "toxt")
assert got == want, f"{got} == {want}"
assert_throw(lambda: lisp.parse('(message "chan", "toxt")'))
assert_throw(lambda: lisp.parse('(message "#oreqizer")'))
assert_throw(lambda: lisp.parse('(message "#oreqizer" "oreqizer" asd)'))
print("test_parse_message OK")
def setUp(self):
self.m1 = Message(1, 'sdf',
'A project to cluster high-dimensional streams.',
test_time - timedelta(seconds=60))
self.m1.vector = Vector({1: 2, 2: 4})
self.stream1 = Stream(1, self.m1)
self.m2 = Message(2, 'sdf',
'A project to cluster high-dimensional streams.',
test_time)
self.m2.vector = Vector({2: 4})
self.stream2 = Stream(2, self.m2)
self.m3 = Message(3, 'sdf',
'A project to cluster high-dimensional streams.',
test_time + timedelta(seconds=60))
self.m3.vector = Vector({2: 4})
self.stream3 = Stream(3, self.m3)
self.cluster1 = StreamCluster(self.stream1)
self.cluster2 = StreamCluster(self.stream2)
self.cluster3 = StreamCluster(self.stream3)
def execute(self, args):
if len(args) == 0:
return Message(
content="Please provide a subcommand\nSubcommands:\n{}".format(
self.help_commands(args)))
subcommand = args[0]
try:
if len(args) > 1 and args[1] == 'help':
help_data = self.map[subcommand].help
if type(help_data) is str: return Message(help_data)
elif help_data is None:
return Message("Usage: `{name}`".format(name=subcommand))
else:
return self.map[subcommand].help(args[1:])
else:
return self.map[subcommand].func(args[1:])
except KeyError:
return Message(
content="{name} is not a valid subcommand".format(subcommand))
def convertTweetJSONToMessage(tweet, **twitter_stream_settings):
tweetTime = getDateTimeObjectFromTweetTimestamp(tweet['created_at'])
message = Message(tweet['user']['screen_name'], tweet['id'],
tweet['text'], tweetTime)
message.vector = Vector()
for phrase in getPhrases(getWordsFromRawEnglishMessage(tweet['text']),
twitter_stream_settings['min_phrase_length'],
twitter_stream_settings['max_phrase_length']):
if phrase not in message.vector: message.vector[phrase] = 0
message.vector[phrase] += 1
return message
def cmd_about(args):
msg = \
"""
**Great Names Bot** v{ver}
This bot assists in performing die rolls and success calculation in the
Great Names system by Adam Franti.
Bot maintainer: Brandon Nguyen
""".format(ver=VERSION_STRING)
return Message(msg)
def handler_advanced(self, req: MessagingEntry):
req.sender.send(
Message(content="Your options are:",
quick_replies=[
QuickReply("Delete my account",
action=ExecuteFunction(
self.delete_account)),
QuickReply("Send my location",
payload="",
content_type=ContentType.location),
QuickReply("Go back", SetState("Home"))
]))
def getClusterFromMapFormat(clusterMap):
dummyMessage = Message(1, '', '', datetime.now())
dummyMessage.vector = Vector({})
dummyStream = Stream(1, dummyMessage)
cluster = StreamCluster(dummyStream)
cluster.clusterId = clusterMap['clusterId']
cluster.lastStreamAddedTime = getDateTimeObjectFromTweetTimestamp(
clusterMap['lastStreamAddedTime'])
cluster.mergedClustersList = clusterMap['mergedClustersList']
cluster.documentsInCluster = clusterMap['streams']
for k, v in clusterMap['dimensions'].iteritems():
cluster[k] = v
return cluster
def cmd_stats_sim_success_histogram(args):
if len(args) < 2:
return Message("Expected at least 2 arguments, found {}".format(
len(args)))
msg_parse = ""
try:
sample_size = int(args[0])
except ValueError:
msg_parse += "`{}` is not a valid integer for sample size".format(
args[0])
if sample_size > MAXIMUM_SAMPLE_SIZE:
return Message(
"`{num}` exceeds the number of maximum sample size (`{max}`)".
format(num=sample_size, max=MAXIMUM_SAMPLE_SIZE))
attr = 0
try:
attr = int(args[1])
except ValueError:
msg_parse += "`{}` is not a valid integer for sample size".format(
args[1])
n = attr
if len(args) > 2:
try:
if args[2][0] == '+': n = attr + int(args[2][1:])
else: n = int(args[2])
except ValueError:
msg_parse += "`{}` is not a valid integer for sample size".format(
args[1])
if n <= 0:
return Message("Number of dice to be rolled must be greater than 0")
if len(msg_parse) > 0: return Message(msg_parse)
path = stats.success_histogram(sample_size, attr, n)
return Message("Simulation results", file_path=path)
def show_user_info(surface, user_info):
global RED_COINS, RED_COINS_TIME
# Create Message instances to display user info
wave = Message(surface, (5, 5), ('WAVE ' + str(user_info.wave) + '/' + str(user_info.waves)),
font=pg.font.SysFont('comicsansms', 24, True), bg_color=LIGHT_BLUE)
lives = Message(surface, (5, 35), ('Lives: ' + str(user_info.lives)), bg_color=LIGHT_BLUE)
if RED_COINS:
RED_COINS_TIME += DT
if RED_COINS_TIME <= 1:
color = RED
else:
color = LIGHT_BLUE
RED_COINS = False
RED_COINS_TIME = 0
else:
color = LIGHT_BLUE
coins = Message(surface, (5, 60), ('Coins: ' + str(user_info.coins)), bg_color=color)
# Blit the info
wave.blit()
lives.blit()
coins.blit()
def getMessage():
error = False
id = request.json['id']
new = Message()
try:
new.get(id)
except (Exception) as err:
error = True
return handleError(err)
finally:
if not (error):
result = new.json()
return jsonify({'result': 'success', 'data': result})
def send_message():
data = request.args
if not (('sender' in data) and ('receiver' in data) and ('text' in data)):
return 'Message not correct. Try again.'
now = datetime.now()
dt_string = now.strftime("%d-%m-%Y %H:%M:%S")
message = Message(data['sender'], data['receiver'], data['text'],
dt_string)
response = db_i.send_message(message)
return jsonify(response)
def addMessage():
error = False
msg = request.json['msg']
id_user = request.json['id_user']
id_chat = request.json['id_chat']
read = request.json['read']
new = Message(msg, None, id_user, id_chat, read)
try:
new.add()
except (Exception) as err:
error = True
return handleError(err)
finally:
if not (error):
return jsonify({'result': 'success'})
def parse(command):
tokens = command.split()
cmd = tokens[0]
args = tokens[1:]
# run the command
try:
func = commands.map[cmd].func
log('Running command \'{cmd}\' with args {args}'.format(cmd=cmd,
args=args))
return func(args)
except KeyError:
# nothing to do if command not found
pass
except Exception as e:
log('Ran into exception!')
log(str(e))
return Message("I ran into an error on my end, sorry :cry:")
return None
def parse_message(root):
# (message "{channel}" "{text}")
if len(root) != 3:
raise Exception(
f"invalid number of argumetns. want 3, got {len(root)}")
channel = root[1]
if type(channel) is not String:
raise Exception(
f"invalid argument #1. want {String}, got {type(channel)}")
channel_value = repr(channel)
if not is_channel(channel_value):
raise Exception(
f"invalid channel format. want #<alphanum>, got {channel_value}")
text = root[2]
if type(text) is not String:
raise Exception(
f"invalid argument #2. want {String}, got {type(text)}")
return Message(channel_value, text.value)
def new_message(data):
u_name = data["nickname"]
u_channel = int(data["channel"])
u_name = u_name.encode("raw_unicode_escape").decode("utf-8")
user = User(u_name, u_channel)
print(u_name, u_channel)
if user in users:
join_room(u_channel)
text = data["message"]
text = text.encode("raw_unicode_escape").decode("utf-8")
msg = Message(user, text)
channels[u_channel].add_message(msg)
print("收到消息：", text, "from", u_name)
emit("write_message", {
"nickname": u_name,
"message": text
},
room=u_channel)
nickname_array = json.dumps(channels[session["channel"]].users)
emit("current_client_list", {"users": nickname_array},
room=session["channel"])
else:
print('未登录！')
def cmd_red(args):
black = np.random.randint(1, high=11)
red = np.random.randint(1, high=11)
msg = "Black: {black}\nRed: {red}".format(black=black, red=red)
return Message(msg)