def __init__(self, jid, password, relations, algorithm, name):
ClientXMPP.__init__(self, jid, password)
''' Add all event handlers, nickname and
start reciever in alumnchat '''
self.add_event_handler('session_start', self.session_start)
self.add_event_handler('message', self.message)
self.room = 'alumnos'
self.current_reciever = 'alumchat.xyz'
self.auto_subscribe = True
self.relations = relations
self.algorithm_name = algorithm
self.algorithm = getAlgorithm(algorithm)
self.serial = 1
self.neighbours = getNeighbours(relations, name)
self.graph = Graph()
self.name = name
self.lsps = {}
# Functions sent as arguments to main menu
functions = {
'dc': self.dc_and_exit,
'list': self.get_contacts,
'add': self.add_contact,
'rm': self.delete_account,
'send_message': self.message_sender,
'jc': self.join_conversation,
'find': self.start_algorithm,
'd': self.direct_message
}
self.menuInstance = Thread(target=menu, args=(functions, ))
self.add_event_handler('register', self.register)
def __init__(self, jid, password, shell):
ClientXMPP.__init__(self, jid, password)
self.shell = shell
self.add_event_handler("session_start", self.session_start)
self.add_event_handler("message", self.message)
self.add_event_handler("disconnected", self.disconnected)
def __init__(self, jid, password, session_config):
ClientXMPP.__init__(self, jid, password)
self.jabber_id = jid
self.add_event_handler("session_start", self.session_start)
self.add_event_handler("message", self.message)
self.config_path = session_config
self.init_session()
def __init__(self, jid, password, message_handler, data_dir):
"""
jid, password : valid account to send and receive messages
message_handler : a Callable( original_message:Message, decrypted_body )
"""
ClientXMPP.__init__(self, jid, password)
self.add_event_handler("session_start", self.session_start)
self.add_event_handler("message", self.message)
self.register_plugin('xep_0030') # Service Discovery
self.register_plugin('xep_0199') # XMPP Ping
self.register_plugin('xep_0380') # Explicit Message Encryption
if not os.path.exists(data_dir):
os.makedirs(data_dir)
try:
self.register_plugin(
'xep_0384',
{
'data_dir': data_dir,
},
module=slixmpp_omemo,
) # OMEMO
except (PluginCouldNotLoad,):
log.exception('And error occured when loading the omemo plugin.')
sys.exit(1)
self.message_handler = message_handler
def __init__(self, jid, password, nick):
ClientXMPP.__init__(self, jid, password)
""" Add all event handlers, nickname and
start reciever in alumnchat """
self.add_event_handler("session_start", self.session_start)
self.add_event_handler("message", self.message)
self.add_event_handler("socks5_connected", self.stream_opened)
self.add_event_handler("socks5_data", self.stream_data)
self.add_event_handler("socks5_closed", self.stream_closed)
self.room = 'alumnos'
self.nick = nick
self.current_reciever = 'alumchat.xyz'
self.auto_subscribe = True
# Functions sent as arguments to main menu
functions = {
'dc': self.dc_and_exit,
'list': self.get_contacts,
'add': self.add_contact,
'peek': lambda args: print('peekeado hermano'),
'jr': self.join_room,
'lr': self.leave_room,
'cpm': self.change_status,
'sf': self.send_file,
'rm': self.delete_account,
'send_message': self.message_sender,
'jc': self.join_conversation
}
self.menuInstance = Thread(target=menu, args=(functions, ))
def __init__(self, jid, password):
ClientXMPP.__init__(self, jid, password)
self.register_plugin('xep_0332') # HTTP over XMPP Transport
self.add_event_handler(
'session_start', self.session_start
)
self.add_event_handler('http_request', self.http_request_received)
self.add_event_handler('http_response', self.http_response_received)
def __init__(self, jid, password):
ClientXMPP.__init__(self, jid, password)
self.register_plugin('xep_0332') # HTTP over XMPP Transport
self.add_event_handler(
'session_start', self.session_start
)
self.add_event_handler('http_request', self.http_request_received)
self.add_event_handler('http_response', self.http_response_received)
def __init__(self, bot_configuration):
ClientXMPP.__init__(self, bot_configuration.jid,
bot_configuration.password)
self.add_event_handler("session_start", self.on_session_start)
self.add_event_handler("message", self.on_message)
self.blabler_bot_jid = bot_configuration.blabler_bot_jid
def __init__(self, jid: str, password: str, recipient: str, message: str):
ClientXMPP.__init__(self, jid,
password) # Создание клиента для подключения
self.connect(disable_starttls=True
) # Подключение к серверу без шифрования disable_starttls
self.recipient, self.msg = recipient, message # Перенаправление аргументов в среду self
self.add_event_handler("session_start",
self.session_start) # Метод запуска сессии
def __init__(self, jid, password, debug_log, mto):
'''
Connect to XMPP server, and set up callbacks
'''
self.debug_log = debug_log
self.mto = mto
ClientXMPP.__init__(self, jid, password)
self.add_event_handler("session_start", self.session_start)
self.add_event_handler("message", self.message)
def __init__(self, jid: str, password: str, i_answer_obj=False):
ClientXMPP.__init__(self, jid,
password) # Создание клиента для подключения
self.connect(disable_starttls=True
) # Подключение к серверу без шифрования disable_starttls
self.jid, self.i_answer_obj = jid, i_answer_obj # Переопределяем аргументы в локальные переменные
self.add_event_handler("session_start",
self.session_start) # Метод запуска сессии
self.add_event_handler("message",
self.message) # Метод для обработки сообщений
def __init__(self, jid, password, debug_log=lambda x: None):
'''
Log into XMPP server on localhost with username `jid`, and
password `password.` If 'debug_log' is passed, pass log
messages to that callback.
'''
self.debug_log = debug_log
ClientXMPP.__init__(self, jid, password)
self.add_event_handler("session_start", self.session_start)
self.add_event_handler("message", self.message)
self.msg_future = self.new_future()
def __init__(self, sender_id, server_key):
self.sent_count = 0
self.draining = False
ClientXMPP.__init__(self, sender_id + '@fcm.googleapis.com',
server_key)
self.default_port = 5235
self.connected_future = asyncio.Future()
self.add_event_handler("session_start", self.session_start)
self.add_event_handler("message", self.message)
self.register_handler(
Callback('FCM Message', StanzaPath('message'), self.fcm_message))
def __init__(self, cfg: RavenJabberConfig):
ClientXMPP.__init__(self, cfg.username, cfg.password)
self.use_message_ids = True
self.use_ssl = True
self.rooms = None
self.nick = cfg.nickname
self.remote_api = RavenOpenApi()
# session start disconnect events.
self.add_event_handler('session_start', self.start_session)
# register receive handler for both groupchat and normal message events.
self.add_event_handler('message', self.message)
def __init__(self, jid, password, main_bridge):
ClientXMPP.__init__(self, jid, password)
self.main_bridge = main_bridge
self.add_event_handler("session_start", self.session_started)
self.add_event_handler("message", self.message_received)
self.add_event_handler("connection_failed", self.connection_failed)
self.add_event_handler("failed_auth", self.auth_failed)
self.register_plugin('xep_0030') # Service Discovery
self.register_plugin('xep_0045') # Multi-User Chat
self.register_plugin('xep_0199') # XMPP Ping
def __init__(self, jid, password, main_bridge):
ClientXMPP.__init__(self, jid, password)
self.main_bridge = main_bridge
self.add_event_handler("session_start", self.session_started)
self.add_event_handler("message", self.message_received)
self.add_event_handler("connection_failed", self.connection_failed)
self.add_event_handler("failed_auth", self.auth_failed)
self.register_plugin('xep_0030') # Service Discovery
self.register_plugin('xep_0045') # Multi-User Chat
self.register_plugin('xep_0199') # XMPP Ping
def __init__(self, jid, password, make_authorize_uri, get_load_curve,
get_daily):
ClientXMPP.__init__(self, jid, password)
self.add_event_handler("session_start", self.session_start)
self.register_plugin('xep_0004')
self.register_plugin('xep_0050')
self.register_plugin('xep_0199', {'keepalive': True, 'frequency': 15})
self.authorize_uri_handler = AuthorizeUriCommandHandler(
self, make_authorize_uri)
self.load_curve_handler = LoadCurveCommandHandler(self, get_load_curve)
self.daily_handler = DailyCommandHandler(self, get_daily)
def __init__(self, jid: str, password: str, nick: str, db: DBManager,
dbot: DeltaBot) -> None:
ClientXMPP.__init__(self, jid, password)
self.nick = nick
self.db = db
self.dbot = dbot
self.add_event_handler('session_start', self.on_session_start)
self.add_event_handler('message', self.on_message)
self.add_event_handler('disconnected', self.on_disconnected)
self.register_plugin('xep_0045') # Multi-User Chat
self.register_plugin('xep_0054') # vcard-temp
self.register_plugin('xep_0363') # HTTP File Upload
self.register_plugin('xep_0128') # Service Discovery Extensions
def __init__(self, jid, password, cmdparser, connection):
ClientXMPP.__init__(self, jid, password)
# cmdparser.registerCommand([("muc", ), ("join", "Joins a given MUC", self.cmdjoinMuc)])
self.cmdparser = cmdparser
self.connection = connection
self.cursor = connection.cursor()
self.register_plugin('xep_0045')
self.add_event_handler("session_start", self.session_start)
self.add_event_handler("message", self.message)
self.add_event_handler('groupchat_message', self.mucmessage)
self.cursor.execute("CREATE TABLE IF NOT EXISTS MUC(Id INT, MUC TEXT, Nick TEXT, Pass TEXT)")
def cancel_config(xmpp: ClientXMPP, room: str) -> None:
query = ET.Element('{http://jabber.org/protocol/muc#owner}query')
x = ET.Element('{jabber:x:data}x', type='cancel')
query.append(x)
iq = xmpp.make_iq_set(query)
iq['to'] = room
iq.send()
def set_user_affiliation(
xmpp: ClientXMPP,
muc_jid: JID,
affiliation: str,
callback: Callable[[Iq], None],
nick: Optional[str] = None,
jid: Optional[JID] = None,
reason: Optional[str] = None
) -> None:
"""
(try to) Set the affiliation of a MUC user
"""
muc_jid = safeJID(muc_jid)
query = ET.Element('{http://jabber.org/protocol/muc#admin}query')
if nick:
item = ET.Element('{http://jabber.org/protocol/muc#admin}item', {
'affiliation': affiliation,
'nick': nick
})
else:
item = ET.Element('{http://jabber.org/protocol/muc#admin}item', {
'affiliation': affiliation,
'jid': str(jid)
})
if reason:
reason_item = ET.Element(
'{http://jabber.org/protocol/muc#admin}reason')
reason_item.text = reason
item.append(reason_item)
query.append(item)
iq = xmpp.make_iq_set(query)
iq['to'] = muc_jid
iq.send(callback=callback)
def __init__(self, broadcast_msg):
self.broadcast_msg = broadcast_msg
self.conn_lock = asyncio.Lock()
# force locking now
# it seems that the xmpp server really doesn't like it when you send messages
# before the setup is complete, so lock everything until we've authed and joined all the rooms.
[_ for _ in self.conn_lock.acquire()]
self.c = ClientXMPP(self.jabber_id, self.password)
self.c.register_plugin('xep_0030') # Service Discovery
self.c.register_plugin('xep_0045') # Multi-User Chat
self.c.register_plugin('xep_0199') # XMPP Ping
self.c.register_plugin('xep_0203') # XMPP Delayed messages
self.c.register_plugin('xep_0249') # XMPP direct MUC invites
self.c.auto_authorize = True
self.c.auto_subscribe = True
self.c.whitespace_keepalive = True
self.c.whitespace_keepalive_interval = 60
self.c.add_event_handler('session_bind', self.session_start)
self.c.add_event_handler('session_bind', self.c._start_keepalive)
for room, _ in self.rooms:
self.c.add_event_handler('muc::{}::message'.format(room), self.muc_message)
self.c.add_event_handler('muc::{}::got_offline'.format(room), functools.partial(self.send_presence, 'parted'))
self.c.add_event_handler('muc::{}::got_online'.format(room), functools.partial(self.send_presence, 'joined'))
self.c.connect()
def destroy_room(
xmpp: ClientXMPP,
room: str,
reason: str = '',
altroom: str = ''
) -> bool:
"""
destroy a room
"""
room = safeJID(room)
if not room:
return False
iq = xmpp.make_iq_set()
iq['to'] = room
query = ET.Element('{%s}query' % NS_MUC_OWNER)
destroy = ET.Element('{%s}destroy' % NS_MUC_OWNER)
if altroom:
destroy.attrib['jid'] = altroom
if reason:
xreason = ET.Element('{%s}reason' % NS_MUC_OWNER)
xreason.text = reason
destroy.append(xreason)
query.append(destroy)
iq.append(query)
def callback(iq: Iq) -> None:
if not iq or iq['type'] == 'error':
xmpp.core.information('Unable to destroy room %s' % room, 'Info')
else:
xmpp.core.information('Room %s destroyed' % room, 'Info')
iq.send(callback=callback)
return True
def change_subject(xmpp: ClientXMPP, jid: JID, subject: str) -> None:
"""
Change the room subject
"""
jid = safeJID(jid)
msg = xmpp.make_message(jid)
msg['type'] = 'groupchat'
msg['subject'] = subject
msg.send()
def configure_room(xmpp: ClientXMPP, room: str, form: 'Form') -> None:
if form is None:
return
iq = xmpp.make_iq_set()
iq['to'] = room
query = ET.Element('{http://jabber.org/protocol/muc#owner}query')
form['type'] = 'submit'
query.append(form.xml)
iq.append(query)
iq.send()
def __init__(
self,
jid,
password,
feature=None,
keepalive=None,
ca_cert=None,
server=None,
use_ipv6=None,
bot=None,
ssl_version=None,
):
if feature is None:
feature = {}
self._bot = bot
self.connected = False
self.server = server
self.client = ClientXMPP(
jid, password, plugin_config={"feature_mechanisms": feature}
)
self.client.register_plugin("xep_0030") # Service Discovery
self.client.register_plugin("xep_0045") # Multi-User Chat
self.client.register_plugin("xep_0199") # XMPP Ping
self.client.register_plugin("xep_0203") # XMPP Delayed messages
self.client.register_plugin("xep_0249") # XMPP direct MUC invites
if keepalive is not None:
self.client.whitespace_keepalive = (
True # Just in case Slixmpp's default changes to False in the future
)
self.client.whitespace_keepalive_interval = keepalive
if use_ipv6 is not None:
self.client.use_ipv6 = use_ipv6
if ssl_version:
self.client.ssl_version = ssl_version
self.client.ca_certs = ca_cert # Used for TLS certificate validation
self.client.add_event_handler("session_start", self.session_start)
def get_room_form(xmpp: ClientXMPP, room: str, callback: Callable[[Iq], Any]):
def _cb(result):
if result["type"] == "error":
return callback(None)
xform = result.xml.find(
'{http://jabber.org/protocol/muc#owner}query/{jabber:x:data}x')
if xform is None:
return callback(None)
form = xmpp.plugin['xep_0004'].build_form(xform)
return callback(form)
iq = xmpp.make_iq_get(ito=room)
query = ET.Element('{http://jabber.org/protocol/muc#owner}query')
iq.append(query)
iq.send(callback=_cb)
def change_show(
xmpp: ClientXMPP,
jid: JID,
own_nick: str,
show: str,
status: Optional[str]
) -> None:
"""
Change our 'Show'
"""
jid = safeJID(jid)
pres = xmpp.make_presence(pto='%s/%s' % (jid, own_nick))
if show: # if show is None, don't put a <show /> tag. It means "available"
pres['type'] = show
if status:
pres['status'] = status
pres.send()
def set_user_role(
xmpp: ClientXMPP,
jid: JID,
nick: str,
reason: str,
role: str,
callback: Callable[[Iq], None]
) -> None:
"""
(try to) Set the role of a MUC user
(role = 'none': eject user)
"""
jid = safeJID(jid)
iq = xmpp.make_iq_set()
query = ET.Element('{%s}query' % NS_MUC_ADMIN)
item = ET.Element('{%s}item' % NS_MUC_ADMIN, {'nick': nick, 'role': role})
if reason:
reason_el = ET.Element('{%s}reason' % NS_MUC_ADMIN)
reason_el.text = reason
item.append(reason_el)
query.append(item)
iq.append(query)
iq['to'] = jid
iq.send(callback=callback)
def __init__(self, jid, password):
"""Initialize the client."""
ClientXMPP.__init__(self, jid, password)
self.add_event_handler("session_start", self.session_start)
self.add_event_handler("message", self.message)
def stream_start(self,
mode='client',
skip=True,
header=None,
socket='mock',
jid='tester@localhost/resource',
password='******',
server='localhost',
port=5222,
sasl_mech=None,
plugins=None,
plugin_config={}):
"""
Initialize an XMPP client or component using a dummy XML stream.
Arguments:
mode -- Either 'client' or 'component'. Defaults to 'client'.
skip -- Indicates if the first item in the sent queue (the
stream header) should be removed. Tests that wish
to test initializing the stream should set this to
False. Otherwise, the default of True should be used.
socket -- Either 'mock' or 'live' to indicate if the socket
should be a dummy, mock socket or a live, functioning
socket. Defaults to 'mock'.
jid -- The JID to use for the connection.
Defaults to 'tester@localhost/resource'.
password -- The password to use for the connection.
Defaults to 'test'.
server -- The name of the XMPP server. Defaults to 'localhost'.
port -- The port to use when connecting to the server.
Defaults to 5222.
plugins -- List of plugins to register. By default, all plugins
are loaded.
"""
if not plugin_config:
plugin_config = {}
if mode == 'client':
self.xmpp = ClientXMPP(jid,
password,
sasl_mech=sasl_mech,
plugin_config=plugin_config)
elif mode == 'component':
self.xmpp = ComponentXMPP(jid,
password,
server,
port,
plugin_config=plugin_config)
else:
raise ValueError("Unknown XMPP connection mode.")
self.xmpp.connection_made(TestTransport(self.xmpp))
self.xmpp.session_bind_event.set()
# Remove unique ID prefix to make it easier to test
self.xmpp._id_prefix = ''
self.xmpp.default_lang = None
self.xmpp.peer_default_lang = None
def new_id():
self.xmpp._id += 1
return str(self.xmpp._id)
self.xmpp._id = 0
self.xmpp.new_id = new_id
# Must have the stream header ready for xmpp.process() to work.
if not header:
header = self.xmpp.stream_header
self.xmpp.data_received(header)
self.wait_for_send_queue()
if skip:
self.xmpp.socket.next_sent()
if mode == 'component':
self.xmpp.socket.next_sent()
if plugins is None:
self.xmpp.register_plugins()
else:
for plugin in plugins:
self.xmpp.register_plugin(plugin)
# Some plugins require messages to have ID values. Set
# this to True in tests related to those plugins.
self.xmpp.use_message_ids = False
self.xmpp.use_presence_ids = False
class XMPPConnection(object):
def __init__(self,
jid,
password,
feature=None,
keepalive=None,
ca_cert=None,
server=None,
use_ipv6=None,
bot=None,
ssl_version=None):
if feature is None:
feature = {}
self._bot = bot
self.connected = False
self.server = server
self.client = ClientXMPP(jid,
password,
plugin_config={'feature_mechanisms': feature})
self.client.register_plugin('xep_0030') # Service Discovery
self.client.register_plugin('xep_0045') # Multi-User Chat
self.client.register_plugin('xep_0199') # XMPP Ping
self.client.register_plugin('xep_0203') # XMPP Delayed messages
self.client.register_plugin('xep_0249') # XMPP direct MUC invites
if keepalive is not None:
self.client.whitespace_keepalive = True # Just in case Slixmpp's default changes to False in the future
self.client.whitespace_keepalive_interval = keepalive
if use_ipv6 is not None:
self.client.use_ipv6 = use_ipv6
if ssl_version:
self.client.ssl_version = ssl_version
self.client.ca_certs = ca_cert # Used for TLS certificate validation
self.client.add_event_handler("session_start", self.session_start)
def session_start(self, _):
self.client.send_presence()
self.client.get_roster()
def connect(self):
if not self.connected:
if self.server is not None:
self.client.connect(self.server)
else:
self.client.connect()
self.connected = True
return self
def disconnect(self):
self.client.disconnect(wait=True)
self.connected = False
def serve_forever(self):
self.client.process()
def add_event_handler(self, name, cb):
self.client.add_event_handler(name, cb)
def del_event_handler(self, name, cb):
self.client.del_event_handler(name, cb)
class HipchatClient(object):
def __init__(self, broadcast_msg):
self.broadcast_msg = broadcast_msg
self.conn_lock = asyncio.Lock()
# force locking now
# it seems that the xmpp server really doesn't like it when you send messages
# before the setup is complete, so lock everything until we've authed and joined all the rooms.
[_ for _ in self.conn_lock.acquire()]
self.c = ClientXMPP(self.jabber_id, self.password)
self.c.register_plugin('xep_0030') # Service Discovery
self.c.register_plugin('xep_0045') # Multi-User Chat
self.c.register_plugin('xep_0199') # XMPP Ping
self.c.register_plugin('xep_0203') # XMPP Delayed messages
self.c.register_plugin('xep_0249') # XMPP direct MUC invites
self.c.auto_authorize = True
self.c.auto_subscribe = True
self.c.whitespace_keepalive = True
self.c.whitespace_keepalive_interval = 60
self.c.add_event_handler('session_bind', self.session_start)
self.c.add_event_handler('session_bind', self.c._start_keepalive)
for room, _ in self.rooms:
self.c.add_event_handler('muc::{}::message'.format(room), self.muc_message)
self.c.add_event_handler('muc::{}::got_offline'.format(room), functools.partial(self.send_presence, 'parted'))
self.c.add_event_handler('muc::{}::got_online'.format(room), functools.partial(self.send_presence, 'joined'))
self.c.connect()
def session_start(self, event):
self.c.send_presence()
self.c.get_roster()
for room, password in self.rooms:
self.c.plugin['xep_0045'].joinMUC(room, self.nickname, password=password, wait=True)
self.conn_lock.release()
def muc_message(self, msg):
# yes, this is how you check to see if 'delay' is set on a message.
# this API is dumb
if isinstance(msg['delay']['stamp'], datetime.datetime):
return
if msg['from'].resource == self.nickname:
return
self.broadcast_msg(self.format_msg(msg))
def format_msg(self, msg):
return '({0}) {1}'.format(msg['from'].resource, msg['body'])
def format_presence(self, user, status):
return '*** {0} has {1}'.format(user, status)
def send_presence(self, status, msg):
self.broadcast_msg(self.format_presence(msg['from'].resource, status))
@asyncio.coroutine
def send_msg(self, msg):
with (yield from self.conn_lock):
for room, _ in self.rooms:
self.c.send_message(mto=room, mbody=msg, mtype='groupchat')
def __init__(self, jid, password):
ClientXMPP.__init__(self, jid, password)
self.add_event_handler("session_start", self.session_start)
self.register_plugin('xep_0045')
def __init__(self, jid, password, nick, rooms, MUC_name, Ignored):
ClientXMPP.__init__(self, jid, password)
self.nickname = nick
self.room_names = rooms
self.MUC = MUC_name
self.model = {}
self.char2idx = {}
self.idx2char = {}
self.Ignored = Ignored
for room_name in self.room_names:
vocab_filepath = checkpoint_dir + '/vocab_' + room_name + '.npy'
if os.path.isfile(vocab_filepath):
vocab = np.load(
vocab_filepath) # The unique characters in the file
else:
print("Could not find vocab file at: " + vocab_filepath)
exit()
vocab_size = len(vocab) # Length of the vocabulary in chars
# Creating a mapping from unique characters to indices
self.char2idx[room_name] = {u: i for i, u in enumerate(vocab)}
self.idx2char[room_name] = np.array(vocab)
self.model[room_name] = build_model(vocab_size,
embedding_dim,
batch_size=1)
checkpoint_file = checkpoint_dir + "/weights_" + room_name + ".h5"
if os.path.isfile(checkpoint_file):
self.model[room_name].load_weights(checkpoint_file)
else:
print("Could not find checkpoint file: " + checkpoint_file)
exit()
self.model[room_name].build(tf.TensorShape([1, None]))
text = ""
logfile = regex.compile(
regex.escape(room_name) + r'@' + regex.escape(MUC) +
r'-\d\d\d\d-\d\d-\d\d\.log')
for file in sorted(os.listdir(logs_dir), reverse=True):
match = logfile.search(file)
if match != None and match.span()[0] == 0:
print("Parsing " + file + " for inference initialisation")
text = open(logs_dir + '/' + file).read() + text
if len(text) >= Initialisation_Length:
break
init_text = ""
segment_counter = 2
while len(init_text) - init_text.find(
'\n') < Initialisation_Length:
start_idx = max(
0,
len(text) - segment_counter * Initialisation_Length)
init_text = text[start_idx:]
segment_counter += 1
init_text = init_text[text.find('\n') + 1:]
init_text = Filter_Logs(init_text)
init_text = init_text[len(init_text) - Initialisation_Length:]
init_text = init_text[init_text.find('\n') + 1:]
if len(init_text) > 0:
Feed_Model(
self.model[room_name], init_text,
self.char2idx[room_name]) #Give the model some state
if Test:
first_room = self.room_names[0]
Test_Bot(self.model[first_room], self.idx2char[first_room],
self.char2idx[first_room])
self.register_plugin('xep_0045')
self.add_event_handler("session_start", self.session_start)
self.add_event_handler("message", self.message)
self.add_event_handler("groupchat_message", self.muc_message)
self.add_event_handler("session_end", self.crash)
self.add_event_handler("socket_error", self.crash)
self.add_event_handler("disconnected", self.crash)
self.add_event_handler("stream_error", self.crash)
self.add_event_handler("killed", self.crash)
self.add_event_handler("connection_failed", self.crash)
self.add_event_handler("close", self.crash)
def __init__(self, jid, password, recipient, msg):
ClientXMPP.__init__(self, jid, password)
self.recipient = recipient
self.msg = msg
self.add_event_handler("session_start", self.session_start)
