messager.py

#!/usr/bin/env python3
import logging

from requests import ReadTimeout
from twython import Twython
from clients.MatrixClient import MatrixClient
from clients.DiscordClient import DiscordClient
from mastodon import Mastodon
import config
import helper
from readwiki import ReadWiki
import CanMessage

log = logging.getLogger(__name__)


def get_bot_twitter() -> Twython or None:
 if not helper.can_twitter():
 return None

 log.debug("set up a connection to twitter")

 twitter_bot = None
 try:
 twitter_bot = Twython(
 config.TWITTER_API_KEY,
 config.TWITTER_API_SECRET,
 config.TWITTER_TOKEN,
 config.TWITTER_TOKEN_SECRET
 )
 except Exception as ex:
 log.error("ERROR LOGIN TWITTER: " + str(ex))
 twitter_bot = None

 return twitter_bot


def get_bot_matrix() -> MatrixClient() or None:
 if not helper.can_matrix():
 return None

 log.debug("set up a connection to matrix")

 matrix_bot = None
 try:
 matrix_bot = MatrixClient()
 matrix_bot.login()
 except Exception as ex:
 log.error("ERROR LOGIN MATRIX: " + str(ex))
 matrix_bot = None

 return matrix_bot


def get_bot_mastodon() -> Mastodon() or None:
 if not helper.can_mastodon():
 return None

 log.debug("set up a connection to mastodon")

 mastodon_bot = None
 try:
 mastodon_bot = Mastodon(
 access_token=config.MASTODON_ACCESS_TOKEN,
 api_base_url=config.MASTODON_API_BASE_URL
 )
 except Exception as ex:
 log.error("ERROR LOGIN MASTODON: " + str(ex))
 mastodon_bot = None

 return mastodon_bot


def get_bot_discord() -> DiscordClient() or None:
 if not helper.can_discord():
 return None

 log.debug("initialise discord client")

 return DiscordClient()


def run(last_revid):
 """
 Sends messages less than 'max_changes' changes newer than 'last_revid'.
 Returns the new 'last_revid'.
 """
 log.debug("last rev id: %s", last_revid)

 twitter_bot = get_bot_twitter() if config.TWITTER_ACTIVE else None
 matrix_bot = get_bot_matrix() if config.MATRIX_ACTIVE else None
 mastodon_bot = get_bot_mastodon() if config.MASTODON_ACTIVE else None
 discord_bot = get_bot_discord() if config.DISCORD_ACTIVE else None

 changes = list()
 changes_overflow = False
 new_messages_count = 0

 try:
 read_wiki = ReadWiki()
 for change in read_wiki.get_changes():
 if change.revId <= last_revid:
 break

 new_messages_count += 1
 changes.append(change)

 if new_messages_count >= config.MAX_ENTRIES:
 changes_overflow = True
 break
 except ReadTimeout as ex:
 log.debug("Read TimeOut: %s", ex)

 log.debug("got the following changes: %s", changes)

 changes.reverse()

 if changes_overflow:
 log.debug("detected a overflow in changes")
 missing_message = \
 "Limit of {} changes reached. Please see https://{}{}Special:RecentChanges for more information."\
 .format(config.MAX_ENTRIES, config.WIKI_SITE, config.WIKI_VIEW_PATH)
 missing_link = ReadWiki.WikiChange()
 missing_link.revId = changes[-1].revId
 missing_link.set_message(missing_message)
 
 changes.insert(0, missing_link)

 for change in changes:
 message = change.get_message()
 send_tweet(twitter_bot, message)
 send_toot(mastodon_bot, message)
 send_matrix(matrix_bot, message)
 send_discord(discord_bot, message)

 if not changes:
 log.debug("no changes, rev id: %s", last_revid)
 return last_revid

 log.debug("new rev id: %s", changes[-1].revId)
 return changes[-1].revId


def send_tweet(twitter, message):
 if twitter is None:
 return

 logging.debug("Send tweet: %s", message)

 if not config.TWITTER_DRY_RUN:
 try:
 twitter.update_status(status=message)
 except Exception as ex:
 log.error('TWITTER SEND ERROR: ' + str(ex))
 else:
 log.warning('TWITTER DRY RUN!')


def send_toot(_mastodon, message):
 if _mastodon is None:
 return

 logging.debug("Send toot: %s", message)

 if not config.MASTODON_DRY_RUN:
 try:
 _mastodon.toot(message)
 except Exception as ex:
 log.error('MASTODON SEND ERROR: ' + str(ex))
 else:
 log.warning('MASTODON DRY RUN!')


def send_matrix(_matrix, message):
 if _matrix is None:
 return

 logging.debug("Send matrix: %s", message)

 if not config.MATRIX_DRY_RUN:
 try:
 _matrix.send_message(message)
 except Exception as ex:
 log.error('MATRIX SEND ERROR: ' + str(ex))
 else:
 log.warning('MATRIX DRY RUN!')


def send_discord(_discord, message):
 if _discord is None:
 return

 logging.debug("Send discord: %s", message)

 if not config.DISCORD_DRY_RUN:
 try:
 _discord.send_message(message)
 except Exception as ex:
 log.error('DISCORD SEND ERROR: ' + str(ex))
 else:
 log.warning('DISCORD DRY RUN!')


if __name__ == '__main__':
 can_message = CanMessage.CanMessage()

 highest_ref_id = run(can_message.last_revid)
 log.info("finished, got %s as the latest revid", highest_ref_id)

 if helper.any_dry_run():
 log.warning("DRY_RUN, don't save %s revid", highest_ref_id)
 else:
 can_message.set_last_revid(highest_ref_id)
 can_message.save()