diff --git a/bot.py b/bot.py index 6f06a1b..3b3e725 100644 --- a/bot.py +++ b/bot.py @@ -5,11 +5,11 @@ import time import schedule from telegram import InlineKeyboardMarkup, ParseMode from telegram.error import BadRequest -from telegram.ext import Updater, CommandHandler, InlineQueryHandler, CallbackQueryHandler +from telegram.ext import Updater, CommandHandler from exceptions import * +from marudor_departures import handle_marudor_departures from push_information import __init__ as push_init -from vvs import inline_station_search, handle_vvs, handle_multiple_stations_reply from weather_meteomedia import handle_meteomedia from weather_openweathermap import __init__ as openweathermap_init from weather_openweathermap import handle_weather @@ -53,19 +53,15 @@ class ScheduleThread(threading.Thread): def __main__(): - inline_station_search_handler = InlineQueryHandler(inline_station_search) - dispatcher.add_handler(inline_station_search_handler) - dispatcher.add_handler(CommandHandler('vvs', handle_vvs)) dispatcher.add_handler(CommandHandler('meteomedia', handle_meteomedia)) - dispatcher.add_handler(CommandHandler("weather", handle_weather)) + dispatcher.add_handler(CommandHandler('weather', handle_weather)) + dispatcher.add_handler(CommandHandler('departure', handle_marudor_departures)) openweathermap_init() dispatcher.add_handler(push_init()) dispatcher.add_error_handler(error_callback) - dispatcher.add_handler(CallbackQueryHandler(handle_multiple_stations_reply, pattern="^\/vvs")) - continuous_thread = ScheduleThread() continuous_thread.start() diff --git a/marudor_departures.py b/marudor_departures.py new file mode 100644 index 0000000..d034a27 --- /dev/null +++ b/marudor_departures.py @@ -0,0 +1,78 @@ +import re +from datetime import timezone, timedelta + +import requests +from dateutil.parser import parse + +from exceptions import ServerCommunicationError, StationNotFoundError + +parse_regex = r' to | times | in ' + + +def handle_marudor_departures(update, context): + command = ' '.join(context.args) + arguments = parse_arguments(command) + eva_id = get_eva_id_for_station_name(arguments['station']) + departures = get_departures(eva_id) + if ' in ' in arguments: + departures = filter_line_names(departures, arguments[' in ']) + if ' to ' in arguments: + departures = filter_destination(departures, arguments[' to ']) + departure_count = 4 + if ' times ' in arguments: + departure_count = int(arguments[' times ']) + departures = departures[:departure_count] + for reply in build_reply(departures): + update.message.reply_text(reply) + + +def parse_arguments(command: str) -> dict: + included_commands = re.findall(parse_regex, command) + parameters = re.split(parse_regex, command) + return dict(zip(['station'] + included_commands, parameters)) + + +def get_eva_id_for_station_name(station_name: str) -> str: + request = requests.get(f'https://marudor.de/api/hafas/v1/station/{station_name}') + if request.status_code != 200: + raise ServerCommunicationError + response = request.json() + if len(response) == 0 or 'id' not in response[0]: + raise StationNotFoundError + return response[0]['id'] + + +def get_departures(eva_id: str) -> list: + request = requests.get(f'https://marudor.de/api/hafas/experimental/irisCompatibleAbfahrten/{eva_id}?lookbehind=1') + if request.status_code != 200: + raise ServerCommunicationError + response = request.json() + return response['departures'] + + +def filter_destination(departures: list, destination: str) -> list: + departures[:] = [departure for departure in departures if + destination.casefold() in departure['destination'].casefold() or destination.casefold() in departure[ + 'scheduledDestination'].casefold()] + return departures + + +def filter_line_names(departures: list, line_name: str) -> list: + departures[:] = [departure for departure in departures if + line_name in departure['train']['name']] + return departures + + +def build_reply(departures: list) -> list: + if len(departures) == 0: + return ['No departures found!'] + reply = [f'Next departures for station: {departures[0]["currentStation"]["title"]}'] + for departure in departures: + reply_text = f'{departure["train"]["name"]} to "{departure["destination"]}" at ' \ + f'{parse(departure["departure"]["time"]).astimezone(timezone(timedelta(hours=1))).strftime("%H:%M")}' + + if 'delay' in departure['departure']: + reply_text += f' (+{str(departure["departure"]["delay"])})' + + reply.append(reply_text) + return reply diff --git a/vvs.py b/vvs.py deleted file mode 100644 index dbf65ff..0000000 --- a/vvs.py +++ /dev/null @@ -1,133 +0,0 @@ -import re -import requests -from telegram import InlineQueryResultArticle, InputTextMessageContent, InlineKeyboardButton, InlineKeyboardMarkup - -from exceptions import MultipleStationsFoundError, NoArgError, ServerCommunicationError, StationNotFoundError -from telegram_helpers import build_menu - -sent_multiple_station_message_ids = dict() - - -class Query: - station_id = -1 - departure_count = 4 - line = '' - destination = "" - - def __init__(self, args): - request_tmp = ' '.join(args) - argument_names = re.findall(r' to | in | times ', request_tmp) - arguments = re.split(r' to | in | times ', request_tmp) - if not arguments[0].isdigit(): - reply = search_vvs_station(arguments[0]) - if len(reply) == 1: - self.station_id = reply[0]['stationId'] - else: - raise MultipleStationsFoundError(request_tmp, arguments[0], reply) - else: - self.station_id = arguments[0] - - if ' to ' in argument_names: - self.destination = arguments[argument_names.index(' to ') + 1] - if ' in ' in argument_names: - self.line = arguments[argument_names.index(' in ') + 1] - if ' times ' in argument_names: - self.departure_count = int(arguments[argument_names.index(' times ') + 1]) - - -def reply_multiple_stations(message, message_text, queried_station, station_list): - button_list = [] - for station in station_list: - button_list.append(InlineKeyboardButton(station['fullName'], - callback_data="/vvs " + message_text - .replace(queried_station, station['stationId']))) - reply_markup = InlineKeyboardMarkup(build_menu(button_list, n_cols=2)) - sent_multiple_station_message_ids[message.chat_id] = message.reply_text("Multiple stations found:", - reply_markup=reply_markup).message_id - - -def handle_multiple_stations_reply(update, context): - query = parse_station(update.callback_query.data.split(' ')[1:]) - departures = get_vvs_departures(query) - for reply in departures: - context.bot.send_message(update.effective_chat['id'], reply) - context.bot.delete_message(chat_id=update.effective_chat['id'], - message_id=sent_multiple_station_message_ids[update.effective_chat['id']]) - del sent_multiple_station_message_ids[update.effective_chat['id']] - - -def search_vvs_station(query): - request = requests.get("https://efa-api.asw.io/api/v1/station/?search=" + query) - if request.status_code != 200: - raise ServerCommunicationError - if request.status_code == 200 and len(request.text) <= 2: - raise StationNotFoundError - else: - return request.json() - - -def handle_vvs(update, context): - try: - query = parse_station(context.args) - except MultipleStationsFoundError as error: - reply_multiple_stations(update.message, error.message_text, error.queried_station, error.station_list) - return - departures = get_vvs_departures(query) - - for reply in departures: - update.message.reply_text(reply, disable_notification=True) - - -def parse_station(args): - if len(args) == 0: - raise NoArgError - try: - query = Query(args) - except StationNotFoundError: - raise - except MultipleStationsFoundError: - raise - if query.station_id == -1: - raise StationNotFoundError - return query - - -def get_vvs_departures(query): - reply = [] - request = requests.get("https://efa-api.asw.io/api/v1/station/" + query.station_id + "/departures") - if request.status_code != 200: - raise ServerCommunicationError - reply.append("Next departures for station: " + request.json()[0]['stopName']) - printed_departures = 0 - for station in request.json(): - if station['direction'].casefold().find(query.destination.casefold()) != -1: - if query.line == '' or (query.line != -1 and station['number'] == query.line): - reply.append( - "Line " + station['number'] + " to \"" + station['direction'] + "\" at " - + station['departureTime']['hour'].zfill(2) + ':' + station['departureTime']['minute'].zfill(2) - + " (+" + str(station['delay']) + ")") - printed_departures += 1 - if printed_departures >= query.departure_count: - break - return reply - - -def inline_station_search(update, context): - query = update.inline_query.query - if len(query) < 5 or not query: - return - results = list() - for station in get_station_id_list(query): - results.append( - InlineQueryResultArticle( - id=station['stationId'], - title=station['name'], - input_message_content=InputTextMessageContent("/vvs " + station['stationId']) - ) - ) - context.bot.answer_inline_query(update.inline_query.id, results) - - -def get_station_id_list(name): - request = requests.get("https://efa-api.asw.io/api/v1/station/?search=" + name) - return request.json()