def test_initialization():
source = Lego(None, threading.Lock())
metadata = Metadata(source)
message = Message('a message', metadata)
assert (message.text == 'a message') # nosec
assert (message.metadata == metadata) # nosec
message = Message('a message', metadata, True)
assert (message.text == 'a message') # nosec
assert (message.metadata == metadata) # nosec
assert (message.should_log) # nosec
def test_reply():
# Setup
baseplate = Lego.start(None, threading.Lock())
baseplate_proxy = baseplate.proxy()
urn = baseplate.actor_urn
meta = Metadata(source=urn).__dict__
message = Message(text='0', metadata=meta, should_log=True).__dict__
log_file_name = 'test_reply.log'
children = baseplate_proxy.children.get()
for child in children:
print(child.actor_urn)
# Test
baseplate_proxy.add_child(ReplyTestingPingLego, log_file_name)
baseplate.tell(message)
time.sleep(1)
# Cleanup
children = baseplate_proxy.children.get()
for child in children:
child.stop()
baseplate.stop()
with open(log_file_name, mode='r') as f:
log = json.loads(f.read())
os.remove(log_file_name)
assert log['text'] == '1' # nosec
def on_receive(self, message):
"""
Handle being informed of a message.
This function is called whenever a Lego receives a message, as
specified in the pykka documentation.
Legos should not override this function.
:param message:
:return:
"""
if self.log_file is not None and message['should_log']:
message_copy = Message(message['text'],
Metadata(None).__dict__,
message['should_log']).__dict__
with open(self.log_file, mode='w') as f:
f.write(json.dumps(message_copy))
logger.info(message['metadata']['source'])
if self.listening_for(message):
self_thread = self.HandlerThread(self.handle, message)
self_thread.start()
self.cleanup()
for child in self.children:
child.tell(message)
def on_message(self, event):
'''Runs when a message event is received
Args:
event: RTM API event.
Returns:
Legobot.messge
'''
metadata = self._parse_metadata(event)
message = Message(text=metadata['text'], metadata=metadata).__dict__
if message.get('text'):
message['text'] = self.find_and_replace_userids(message['text'])
message['text'] = self.find_and_replace_channel_refs(
message['text'])
return message
def handle(self, message):
if message['text'] == '0':
self.baseplate.tell(
Message('1',
Metadata(self).__dict__, True).__dict__)
elif message['text'] == '2':
self.reply(message, '3')
else:
print(message['text'])
def on_message(self, event):
'''
Runs when a message event is received
:return: Legobot.Message
'''
metadata = self._parse_metadata(event)
message = Message(text=event['text'],
metadata=metadata).__dict__
return message
def on_pubmsg(self, c, e):
"""
This function runs when the bot receives a public message.
"""
text = e.arguments[0]
metadata = self.set_metadata(e)
metadata['is_private_message'] = False
message = Message(text=text, metadata=metadata).__dict__
self.baseplate.tell(message)
def test_receive_logs():
log_file_name = 'test_logging.log'
lego = Lego(None, threading.Lock(), log_file_name)
message = Message('Test Message 1',
Metadata(None).__dict__, True).__dict__
lego.on_receive(message)
with open(log_file_name, mode='r') as f:
log = json.loads(f.read())
assert log == message # nosec
os.remove(log_file_name)
def on_message(self, event):
'''Runs when a message event is received
Args:
event: RTM API event.
Returns:
Legobot.messge
'''
metadata = self._parse_metadata(event)
message = Message(text=metadata['text'],
metadata=metadata).__dict__
if message.get('text'):
message['text'] = self.find_and_replace_userids(message['text'])
message['text'] = self.find_and_replace_channel_refs(
message['text']
)
return message
def on_privmsg(self, c, e):
"""
This function runs when the bot receives a private message (query).
"""
text = e.arguments[0]
logger.debug('{0!s}'.format(e.source))
metadata = self.set_metadata(e)
metadata['is_private_message'] = True
message = Message(text=text, metadata=metadata).__dict__
self.baseplate.tell(message)
def on_message(self, event):
'''Runs when a message event is received
Args:
event: RTM API event.
Returns:
Legobot.messge
'''
metadata = self._parse_metadata(event)
message = Message(text=metadata['text'], metadata=metadata).__dict__
return message
def on_pubmsg(self, c, e):
"""
This function runs when the bot receives a public message.
"""
text = e.arguments[0]
metadata = Metadata(source=self.actor_urn).__dict__
metadata['source_channel'] = e.target
metadata['source_user'] = e.source
metadata['source_username'] = e.source.split('!')[0]
metadata['is_private_message'] = False
message = Message(text=text, metadata=metadata).__dict__
self.baseplate.tell(message)
def test_on_receive_informs_children():
log_file_name = 'test_child_informed.log'
baseplate = Lego(None, threading.Lock())
child = Lego.start(baseplate, threading.Lock(), log_file_name)
baseplate.children.append(child)
message = Message('Test Message 1',
Metadata(None).__dict__, True).__dict__
baseplate.on_receive(message)
child.stop()
with open(log_file_name, mode='r') as f:
log = json.loads(f.read())
os.remove(log_file_name)
assert log == message # nosec
def on_privmsg(self, c, e):
"""
This function runs when the bot receives a private message (query).
"""
text = e.arguments[0]
metadata = Metadata(source=self).__dict__
logger.debug('{0!s}'.format(e.source))
metadata['source_channel'] = e.source.split('!')[0]
metadata['source_username'] = e.source.split('!')[0]
metadata['source_user'] = e.source
metadata['is_private_message'] = True
message = Message(text=text, metadata=metadata).__dict__
self.baseplate.tell(message)
def on_message(self, message):
"""Runs on a create_message event from websocket connection
Args:
message (dict): Full message from Discord websocket connection"
"""
if 'content' in message['d']:
metadata = self._parse_metadata(message)
message = Message(text=message['d']['content'],
metadata=metadata).__dict__
logger.debug(message)
self.baseplate.tell(message)
def test_reply(self):
log_file_name = 'test_reply.log'
baseplate = Lego.start(None, threading.Lock())
baseplate_proxy = baseplate.proxy()
baseplate_proxy.add_child(ReplyTestingPingLego, log_file_name)
baseplate_proxy.add_child(ReplyTestingPongLego)
baseplate.tell(Message('0', Metadata(None).__dict__, True).__dict__)
time.sleep(1)
children = baseplate_proxy.children.get()
for child in children:
child.stop()
baseplate.stop()
with open(log_file_name, mode='r') as f:
log = json.loads(f.read())
os.remove(log_file_name)
assert log['text'] == '4' # nosec
def reply(self, message, text, opts=None):
"""
Reply to the sender of the provided message with a message \
containing the provided text.
:param message: the message to reply to
:param text: the text to reply with
:param opts: A dictionary of additional values to add to metadata
:return: None
"""
metadata = Metadata(source=self,
dest=message['metadata']['source']).__dict__
metadata['opts'] = opts
message = Message(text=text,
metadata=metadata,
should_log=message['should_log']).__dict__
self.baseplate.tell(message)
def reply(self, message, text, opts=None):
"""Reply to the sender of the message with a containing the text
:param message: the message to reply to
:param text: the text to reply with
:param opts: A dictionary of additional values to add to metadata
:return: None
"""
metadata = Metadata(source=self.actor_urn,
dest=message['metadata']['source']).__dict__
metadata['opts'] = opts
message = Message(text=text, metadata=metadata,
should_log=message['should_log']).__dict__
dest_actor = ActorRegistry.get_by_urn(message['metadata']['dest'])
if dest_actor is not None:
dest_actor.tell(message)
else:
raise("Tried to send message to nonexistent actor")
def handle(self, message):
try:
target = message['metadata']['source_channel']
opts = {'target': target}
except IndexError:
logger.error('Could not identify message source in message: %s' %
str(message))
query = ' '.join(message['text'].split()[1:])
query = query.replace(' ', '%20')
req_url = self._make_url(query)
response = requests.get(req_url)
urls = []
url_regex = '"https?://[^"]*\.(jpg|jpeg|png|gif|gifv)"'
for url in re.finditer(url_regex, response.text):
urls += [url.group(0).strip('"')]
if len(urls) == 0:
url = 'Nothing found :('
else:
url = random.choice(urls)
metadata = Metadata(source=self).__dict__
metadata['opts'] = opts
message = Message(text=str(url), metadata=metadata).__dict__
self.baseplate.tell(message)
def make_message(self):
metadata = Metadata(self, None)
return Message('a message', metadata)
def test_default_init_values():
source = Lego(None, threading.Lock())
metadata = Metadata(source)
message = Message('a message', metadata)
assert (not message.should_log) # nosec
def _make_message():
source = Lego(None, threading.Lock())
metadata = Metadata(source)
message = Message('blah', metadata)
return message
def test_initialization():
lego = Lego(None, threading.Lock())
message = Message('Test Message', Metadata(lego))
thread = Lego.HandlerThread(lego.handle, message)
assert thread.handler == lego.handle # nosec
assert thread.message == message # nosec
