def serve_forever(self):
self.jid = Identifier('Err')
me = Identifier(config.BOT_ADMINS[0])
self.connect_callback() # notify that the connection occured
self.callback_presence(Presence(identifier=me, status=ONLINE))
try:
while True:
if ANSI:
entry = input('\n' + A_CYAN + ' >>> ' + A_RESET)
else:
entry = input('\n>>> ')
msg = Message(entry)
msg.frm = me
msg.to = self.jid
self.callback_message(msg)
except EOFError as eof:
pass
except KeyboardInterrupt as ki:
pass
finally:
# simulate some real presence
self.callback_presence(Presence(identifier=me, status=OFFLINE))
logging.debug("Trigger disconnect callback")
self.disconnect_callback()
logging.debug("Trigger shutdown")
self.shutdown()
def test_identifier_parsing(self):
id1 = Identifier(jid="[email protected]/toto")
self.assertEqual(id1.node, "gbin")
self.assertEqual(id1.domain, "gootz.net")
self.assertEqual(id1.resource, "toto")
id2 = Identifier(jid="*****@*****.**")
self.assertEqual(id2.node, "gbin")
self.assertEqual(id2.domain, "gootz.net")
self.assertIsNone(id2.resource)
def test_identifier_parsing(self):
id1 = Identifier(jid='[email protected]/toto')
self.assertEqual(id1.node, 'gbin')
self.assertEqual(id1.domain, 'gootz.net')
self.assertEqual(id1.resource, 'toto')
id2 = Identifier(jid='*****@*****.**')
self.assertEqual(id2.node, 'gbin')
self.assertEqual(id2.domain, 'gootz.net')
self.assertIsNone(id2.resource)
def test_identifier_parsing(self):
id1 = Identifier(jid="[email protected]/toto")
self.assertEqual(id1.getNode(), "gbin")
self.assertEqual(id1.getDomain(), "gootz.net")
self.assertEqual(id1.getResource(), "toto")
id2 = Identifier(jid="*****@*****.**")
self.assertEqual(id2.getNode(), "gbin")
self.assertEqual(id2.getDomain(), "gootz.net")
self.assertIsNone(id2.getResource())
def serve_forever(self):
import config
self.jid = Identifier('Err') # whatever
self.connect_callback() # notify that the connection occured
self.sender = config.BOT_ADMINS[
0] # By default, assume this is the admin talking
try:
while True:
stanza_type, entry = incoming_stanza_queue.get()
if entry == QUIT_MESSAGE:
logging.info("Stop magic message received, quitting...")
break
if stanza_type is STZ_MSG:
msg = Message(entry)
msg.frm = self.sender
msg.to = self.jid # To me only
self.callback_message(msg)
elif stanza_type is STZ_PRE:
logging.info("Presence stanza received.")
self.callback_presence(entry)
elif stanza_type is STZ_IQ:
logging.info("IQ stanza received.")
else:
logging.error("Unknown stanza type.")
except EOFError as _:
pass
except KeyboardInterrupt as _:
pass
finally:
logging.debug("Trigger disconnect callback")
self.disconnect_callback()
logging.debug("Trigger shutdown")
self.shutdown()
def user_left_chat(self, event):
logging.debug("user_left_chat %s" % event)
idd = Identifier(str(event['from']))
p = Presence(chatroom=idd,
nick=idd.resource,
status=OFFLINE)
self.callback_presence(p)
def test_streaming():
canary = b'this is my test' * 1000
source = Stream(Identifier("*****@*****.**"), BytesIO(canary))
clients = [StreamingClient() for i in range(50)]
Tee(source, clients).run()
for client in clients:
assert client.response == canary
def on_group_message(self, group_number, friend_group_number, message):
logging.debug('TOX: Group-%i User-%i: %s' % (group_number, friend_group_number, message))
msg = Message(message, type_='groupchat')
msg.frm = Identifier(node=str(group_number), resource=str(friend_group_number))
msg.to = self.backend.jid
logging.debug('TOX: callback with type = %s' % msg.type)
self.backend.callback_message(msg)
class DummyBackend(Backend):
outgoing_message_queue = Queue()
jid = Identifier('err@localhost/err')
def build_message(self, text):
return build_message(text, Message)
def send_message(self, mess):
self.outgoing_message_queue.put(mess)
def pop_message(self, timeout=3, block=True):
return self.outgoing_message_queue.get(timeout=timeout, block=block)
@botcmd
def return_args_as_str(self, mess, args):
return "".join(args)
@botcmd(template='args_as_html')
def return_args_as_html(self, mess, args):
return {'args': args}
@botcmd
def raises_exception(self, mess, args):
raise Exception("Kaboom!")
@botcmd
def yield_args_as_str(self, mess, args):
for arg in args:
yield arg
@botcmd(template='args_as_html')
def yield_args_as_html(self, mess, args):
for arg in args:
yield {'args': [arg]}
@botcmd
def yields_str_then_raises_exception(self, mess, args):
yield "foobar"
raise Exception("Kaboom!")
@botcmd
def return_long_output(self, mess, args):
return LONG_TEXT_STRING * 3
@botcmd
def yield_long_output(self, mess, args):
for i in range(2):
yield LONG_TEXT_STRING * 3
def __init__(self):
super(DummyBackend, self).__init__()
self.commands['return_args_as_str'] = self.return_args_as_str
self.commands['return_args_as_html'] = self.return_args_as_html
self.commands['raises_exception'] = self.raises_exception
self.commands['yield_args_as_str'] = self.yield_args_as_str
self.commands['yield_args_as_html'] = self.yield_args_as_html
self.commands[
'yields_str_then_raises_exception'] = self.yields_str_then_raises_exception
self.commands['return_long_output'] = self.return_long_output
self.commands['yield_long_output'] = self.yield_long_output
def test_identifier_parsing(self):
id1 = Identifier(jid="[email protected]/toto")
self.assertEqual(id1.getNode(), "gbin")
self.assertEqual(id1.getDomain(), "gootz.net")
self.assertEqual(id1.getResource(), "toto")
id2 = Identifier(jid="*****@*****.**")
self.assertEqual(id2.getNode(), "gbin")
self.assertEqual(id2.getDomain(), "gootz.net")
self.assertIsNone(id2.getResource())
def on_group_namelist_change(self, group_number, friend_group_number, change):
logging.debug("TOX: user %s changed state in group %s" % (friend_group_number, group_number))
newstatus = TOX_GROUP_TO_ERR_STATUS[change]
if newstatus:
chatroom = Identifier(node=str(group_number), resource=str(friend_group_number))
pres = Presence(nick=self.group_peername(group_number, friend_group_number),
status=newstatus,
chatroom=chatroom)
self.backend.callback_presence(pres)
def user_changed_status(self, event):
logging.debug("user_changed_status %s" % event)
errstatus = XMPP_TO_ERR_STATUS.get(event['type'], None)
message = event['status']
if not errstatus:
errstatus = event['type']
p = Presence(identifier=Identifier(str(event['from'])),
status=errstatus, message=message)
self.callback_presence(p)
def __init__(self,
nickname,
server,
port=6667,
password=None,
ssl=False,
username=None):
self.jid = Identifier(node=nickname, domain=server)
super(IRCBackend, self).__init__()
self.conn = IRCConnection(self, nickname, server, port, ssl, password,
username)
def connect(self):
if not self.conn:
self.conn = CampfireConnection(self.subdomain, self.username,
self.password, self.ssl)
self.jid = Identifier(node=self.username,
domain=self.conn.get_room_by_name(
self.chatroom).name,
resource=self.username)
# put us by default in the first room
# resource emulates the XMPP behavior in chatrooms
return self.conn
def __init__(self, username, password, *args, **kwargs):
super(XMPPBackend, self).__init__(*args, **kwargs)
self.jid = Identifier(username)
self.password = password
self.conn = self.create_connection()
self.conn.add_event_handler("message", self.incoming_message)
self.conn.add_event_handler("session_start", self.connected)
self.conn.add_event_handler("disconnected", self.disconnected)
# presence related handlers
self.conn.add_event_handler("got_online", self.contact_online)
self.conn.add_event_handler("got_offline", self.contact_offline)
self.conn.add_event_handler("changed_status", self.user_changed_status)
# MUC subject events
self.conn.add_event_handler("groupchat_subject", self.chat_topic)
self._room_topics = {}
def test_buildreply(self):
class DummyBackend(Backend):
def build_message(self, text):
return Message(text)
be = DummyBackend()
be.jid = Identifier("[email protected]/metal")
m = be.build_message("Content")
m.setFrom("[email protected]/fromresource")
m.setTo("[email protected]/toresource")
resp = be.build_reply(m, "Response")
self.assertEqual(str(resp.getTo()), "*****@*****.**")
self.assertEqual(str(resp.getFrom()), "[email protected]/metal")
self.assertEqual(str(resp.getBody()), "Response")
def connect(self):
if not self.conn:
if not CHATROOM_PRESENCE:
raise Exception(
'Your bot needs to join at least one room, please set CHATROOM_PRESENCE in your config'
)
self.conn = CampfireConnection(self.subdomain, self.username,
self.password, self.ssl)
self.jid = Identifier(node=self.username,
domain=self.conn.get_room_by_name(
CHATROOM_PRESENCE[0]).name,
resource=self.username)
# put us by default in the first room
# resource emulates the XMPP behavior in chatrooms
return self.conn
def __init__(self, config):
identity = config.BOT_IDENTITY
nickname = identity['nickname']
server = identity['server']
port = identity.get('port', 6667)
password = identity.get('password', None)
ssl = identity.get('ssl', False)
username = identity.get('username', None)
private_rate = config.__dict__.get('IRC_PRIVATE_RATE', 1)
channel_rate = config.__dict__.get('IRC_CHANNEL_RATE', 1)
self.jid = Identifier(node=nickname, domain=server)
super(IRCBackend, self).__init__(config)
self.conn = IRCConnection(self, nickname, server, port, ssl, password, username, private_rate, channel_rate)
def __init__(self, config):
if not hasattr(config, 'TOX_BOOTSTRAP_SERVER'):
logging.fatal("""
You need to provide a server to bootstrap from in config.TOX_BOOTSTRAP_SERVER.
for example :
TOX_BOOTSTRAP_SERVER = ["54.199.139.199", 33445,
"7F9C31FE850E97CEFD4C4591DF93FC757C7C12549DDD55F8EEAECC34FE76C029"]
You can find currently active public ones on :
https://wiki.tox.im/Nodes """)
sys.exit(-1)
username = config.BOT_IDENTITY['username']
super(ToxBackend, self).__init__(config)
self.conn = ToxConnection(self, username)
self.jid = Identifier(str(self.conn.get_address()), resource=username)
def __init__(self, config):
super(XMPPBackend, self).__init__(config)
identity = config.BOT_IDENTITY
self.jid = Identifier(identity['username'])
self.password = identity['password']
self.feature = config.__dict__.get('XMPP_FEATURE_MECHANISMS', {})
self.keepalive = config.__dict__.get('XMPP_KEEPALIVE_INTERVAL', None)
self.ca_cert = config.__dict__.get('XMPP_CA_CERT_FILE', '/etc/ssl/certs/ca-certificates.crt')
self.conn = self.create_connection()
self.conn.add_event_handler("message", self.incoming_message)
self.conn.add_event_handler("session_start", self.connected)
self.conn.add_event_handler("disconnected", self.disconnected)
# presence related handlers
self.conn.add_event_handler("got_online", self.contact_online)
self.conn.add_event_handler("got_offline", self.contact_offline)
self.conn.add_event_handler("changed_status", self.user_changed_status)
# MUC subject events
self.conn.add_event_handler("groupchat_subject", self.chat_topic)
self._room_topics = {}
def friend_to_idd(self, friend_number):
return Identifier(node=str(friend_number), resource=self.get_name(friend_number))
def __init__(self, username):
super(ToxBackend, self).__init__()
self.conn = ToxConnection(self, username)
self.jid = Identifier(str(self.conn.get_address()), resource=username)
def contact_offline(self, event):
log.debug("contact_offline %s" % event)
p = Presence(identifier=Identifier(str(event['from'])), status=OFFLINE)
self.callback_presence(p)
def test_identifier_double_at_parsing(self):
id1 = Identifier(jid="[email protected]@gootz.net/toto")
self.assertEqual(id1.getNode(), "*****@*****.**")
self.assertEqual(id1.getDomain(), "gootz.net")
self.assertEqual(id1.getResource(), "toto")
def test_identifier_stripping(self):
id1 = Identifier(jid="[email protected]/toto")
self.assertEqual(id1.getStripped(), "*****@*****.**")
def test_identifier_double_at_parsing(self):
id1 = Identifier(jid="[email protected]@gootz.net/toto")
self.assertEqual(id1.node, "*****@*****.**")
self.assertEqual(id1.domain, "gootz.net")
self.assertEqual(id1.resource, "toto")
class DummyBackend(Backend):
outgoing_message_queue = Queue()
jid = Identifier('err@localhost/err')
def build_message(self, text):
return build_message(text, Message)
def send_message(self, mess):
self.outgoing_message_queue.put(mess)
def pop_message(self, timeout=3, block=True):
return self.outgoing_message_queue.get(timeout=timeout, block=block)
@botcmd
def command(self, mess, args):
return "Regular command"
@re_botcmd(pattern=r'^regex command with prefix$', prefixed=True)
def regex_command_with_prefix(self, mess, match):
return "Regex command"
@re_botcmd(pattern=r'^regex command without prefix$', prefixed=False)
def regex_command_without_prefix(self, mess, match):
return "Regex command"
@re_botcmd(pattern=r'regex command with capture group: (?P<capture>.*)',
prefixed=False)
def regex_command_with_capture_group(self, mess, match):
return match.group('capture')
@re_botcmd(pattern=r'matched by two commands')
def double_regex_command_one(self, mess, match):
return "one"
@re_botcmd(pattern=r'matched by two commands', flags=re.IGNORECASE)
def double_regex_command_two(self, mess, match):
return "two"
@botcmd
def return_args_as_str(self, mess, args):
return "".join(args)
@botcmd(template='args_as_html')
def return_args_as_html(self, mess, args):
return {'args': args}
@botcmd
def raises_exception(self, mess, args):
raise Exception("Kaboom!")
@botcmd
def yield_args_as_str(self, mess, args):
for arg in args:
yield arg
@botcmd(template='args_as_html')
def yield_args_as_html(self, mess, args):
for arg in args:
yield {'args': [arg]}
@botcmd
def yields_str_then_raises_exception(self, mess, args):
yield "foobar"
raise Exception("Kaboom!")
@botcmd
def return_long_output(self, mess, args):
return LONG_TEXT_STRING * 3
@botcmd
def yield_long_output(self, mess, args):
for i in range(2):
yield LONG_TEXT_STRING * 3
@property
def mode(self):
return "Dummy"
@property
def rooms(self):
return []
def __init__(self):
super(DummyBackend, self).__init__()
self.inject_commands_from(self)
def test_identifier_unicode_rep(self):
self.assertEqual(str(Identifier(jid="[email protected]/へようこそ")),
"[email protected]/へようこそ")
def test_identifier_str_rep(self):
self.assertEqual(str(Identifier(jid="[email protected]/toto")),
"[email protected]/toto")
self.assertEqual(str(Identifier(jid="*****@*****.**")),
"*****@*****.**")
def test_identifier_stripping(self):
id1 = Identifier(jid="[email protected]/toto")
self.assertEqual(id1.stripped, "*****@*****.**")
def __init__(self, config):
super().__init__(config)
self.jid = Identifier('Err')
self.rooms = set()
def test_identifier_matching(self):
id1 = Identifier(jid="[email protected]/toto")
id2 = Identifier(jid="[email protected]/titi")
id3 = Identifier(jid="[email protected]/titi")
self.assertTrue(id1.bare_match(id2))
self.assertFalse(id2.bare_match(id3))
def __init__(self, config):
self.conn = None
super().__init__(config)
self.jid = Identifier('Err')
self.app = None
def test_identifier_matching(self):
id1 = Identifier(jid="[email protected]/toto")
id2 = Identifier(jid="[email protected]/titi")
id3 = Identifier(jid="[email protected]/titi")
self.assertTrue(id1.bare_match(id2))
self.assertFalse(id2.bare_match(id3))
