async def listen(self) -> None:
if not self.listener:
self.listener = fbchat.Listener(session=self.session, chat_on=True, foreground=False)
handlers: Dict[Type[fbchat.Event], Callable[[Any], Awaitable[None]]] = {
fbchat.MessageEvent: self.on_message,
fbchat.MessageReplyEvent: self.on_message,
fbchat.TitleSet: self.on_title_change,
fbchat.UnsendEvent: self.on_message_unsent,
fbchat.ThreadsRead: self.on_message_seen,
fbchat.ReactionEvent: self.on_reaction,
fbchat.Presence: self.on_presence,
fbchat.Typing: self.on_typing,
fbchat.PeopleAdded: self.on_members_added,
fbchat.PersonRemoved: self.on_member_removed,
fbchat.Connect: self.on_connect,
fbchat.Disconnect: self.on_disconnect,
}
self.log.debug("Starting fbchat listener")
async for event in self.listener.listen():
self.log.debug("Handling facebook event %s", event)
try:
handler = handlers[type(event)]
except KeyError:
self.log.debug(f"Received unknown event type {type(event)}")
else:
try:
await handler(event)
except Exception:
self.log.exception("Failed to handle facebook event")
self._is_connected = False
await self.send_bridge_notice("Facebook Messenger connection closed without error")
async def _listen(self) -> None:
if not self.listener:
self.listener = fbchat.Listener(session=self.session, chat_on=True, foreground=False)
self.log.debug("Starting fbchat listener")
async for event in self.listener.listen():
await self._handle_event(event)
self.is_connected = False
if not self._is_refreshing:
await self.send_bridge_notice("Facebook Messenger connection closed without error")
async def main():
ksiendzobot = TextBot(consts.mail, consts.passFb, consts.ksiadzId, consts.kolegiumId)
session = await ksiendzobot.get_session()
client = fbchat.Client(session=session)
listener = fbchat.Listener(session=session, chat_on=False, foreground=False)
listen_task = asyncio.create_task(ksiendzobot.run(listener, session))
client.sequence_id_callback = listener.set_sequence_id
# Call the fetch_threads API once to get the latest sequence ID
await client.fetch_threads(limit=1).__anext__()
# Let the listener run, otherwise the script will stop
await listen_task
async def main():
session = await fbchat.Session.login("<email>", "<password>")
client = fbchat.Client(session=session)
listener = fbchat.Listener(session=session,
chat_on=False,
foreground=False)
listen_task = asyncio.create_task(listen(listener, session))
client.sequence_id_callback = listener.set_sequence_id
# Call the fetch_threads API once to get the latest sequence ID
await client.fetch_threads(limit=1).__anext__()
# Let the listener run, otherwise the script will stop
await listen_task
async def listening(self):
await self.init_commands()
listener = fbchat.Listener(session=self.session,
chat_on=True,
foreground=True)
MAIN_LOOP.create_task(self.set_sequence_id(listener))
print("\nListening...\n")
async for event in listener.listen():
if isinstance(event,
(fbchat.MessageEvent, fbchat.MessageReplyEvent)):
MAIN_LOOP.create_task(self.handle_message_event(event))
elif isinstance(event, fbchat.PeopleAdded):
MAIN_LOOP.create_task(
self.bot_commands.send_message_on_person_added(event))
elif isinstance(event, fbchat.PersonRemoved):
MAIN_LOOP.create_task(
self.bot_commands.reply_on_person_removed(event))
def start(self, bot: Optional[Chatbot] = None):
"""Log in to facebook messenger and start listening for and handling events.
This is a blocking method.
"""
session, status = get_session(self.config)
atexit.register(lambda: save_session(session))
print(f"{status}, user {session.user.id}")
# TODO Figure out what these kwargs do
chat_listener = fbchat.Listener(session=session,
chat_on=True,
foreground=True)
unassigned_bots = self.bots - set(self.thread_map.values())
assert (len(unassigned_bots) <=
1), "Cannot have more than 1 bot assigned to no threads"
fallback_bot: Optional[Chatbot] = None
if len(unassigned_bots) == 1:
fallback_bot = unassigned_bots.pop()
available_bots = set([bot]) if bot else self.bots
bots_for_event = available_bots.copy()
client = fbchat.Client(session=session) # type: ignore
for bot in available_bots:
bot.client = client
# Listener event loop
print("Listening...")
for event in chat_listener.listen():
if isinstance(event, fbchat.ThreadEvent):
b = self.thread_map.get(event.thread.id, fallback_bot)
if b:
bots_for_event &= set([b])
else:
bots_for_event.clear()
for b in bots_for_event:
b.handle(event)
bots_for_event |= available_bots
async def run(self):
loop = get_event_loop()
try:
WiertarBot.listener = fbchat.Listener(session=WiertarBot.session,
chat_on=True,
foreground=True)
# funny sequence id fetching
WiertarBot.client.sequence_id_callback = WiertarBot.listener.set_sequence_id
loop.create_task(
execute_after_delay(
5,
WiertarBot.client.fetch_threads(limit=1).__anext__()))
async for event in WiertarBot.listener.listen():
await EventDispatcher.send_signal(event)
except fbchat.NotConnected as e:
print(e)
if e.message in [
'MQTT error: no connection', 'MQTT reconnection failed'
]:
print('Reconnecting mqtt...')
self.listener.disconnect()
asyncio.get_event_loop().create_task(self.run())
return
except (fbchat.NotLoggedIn, ValueError) as e:
print(e)
if 'account is locked' in e.message:
config.password = config.unlock_facebook_account()
WiertarBot.session = await self._login()
WiertarBot.client = fbchat.Client(session=WiertarBot.session)
loop.create_task(self.run())
return
loop.stop()
nom_scheduler.print_jobs()
nom_scheduler.start()
current_time = datetime.now().strftime('%H:%M:%S')
print(current_time)
#------------ Remote Commands ------------
setup_gpio()
ev_scheduler = BackgroundScheduler()
ev_scheduler.start()
session = fbchat.Session.login(email, password)
listener = fbchat.Listener(session=session, chat_on=False, foreground=False)
verified_users = []
for event in listener.listen():
if isinstance(event, fbchat.MessageEvent):
if event.author.id != session.user.id:
thread = event.thread
if event.author not in verified_users:
thread.send_text(hello_message)
thread.send_emoji('😄', size=fbchat.EmojiSize.LARGE)
time.sleep(1.5)
async def main():
session = await fbchat.Session.login("<email>", "<password>")
listener = fbchat.Listener(session=session, chat_on=False, foreground=False)
async for event in listener.listen():
if isinstance(event, fbchat.MessageEvent):
await on_message(event)
def listener(session):
return fbchat.Listener(session=session, chat_on=False, foreground=False)
