Redesign app, put commands into separate files

Author: kennyhei

Procfile

@@ -1 +1 @@
-worker: python bot.py
+worker: python main.py

README.md

@@ -68,10 +68,6 @@ Content-Length: 240
 ## TODO
 
 - Redesign commands:
-    - /start
-    - /poll - Notify user every 10 minutes what's the current price
-    - /showlatestprice -> rename /price - Show current price, ask for address if not given already
-    - /help
-    - /stop
     - /setaddress(?) - User can set address so that bot doesn't need to ask it again in /start, /poll and /price commands
 - Show prices of all nearby restaurants
+- Don't ask address again in /start, /poll if it's found in the memory

bot.py

@@ -1,147 +1,38 @@
-import asyncio
-import i18n
 import logging
 import settings
 
 from aiogram import Bot
 from aiogram import Dispatcher
 from aiogram.contrib.fsm_storage.memory import MemoryStorage
-from aiogram.dispatcher.filters.state import State
-from aiogram.dispatcher.filters.state import StatesGroup
 from aiogram.utils import executor
 from aiogram.types.message import ParseMode
 
-from scraper import fetch_delivery_price
-from utils import Message
-from utils import is_float
 
-logging.basicConfig(level=logging.INFO)
+class TelegramBot:
 
-# Initialize bot and dispatcher
-bot = Bot(settings.TOKEN, parse_mode=ParseMode.MARKDOWN_V2)
-storage = MemoryStorage()
-dp = Dispatcher(bot, storage=storage)
-
-
-# States for "start" command
-class Form(StatesGroup):
-    address = State()
-    max_price = State()
-
-
-async def _poll_price(message, data):
-    address = data['address']
-    max_price = data['max_price']
-    state = None
-    # Poll two hours at max
-    for _ in range(20):
-        result = await asyncio.gather(fetch_delivery_price(address))
-        state = dp.current_state()
-        data = await state.get_data()
-        if not data['poll_price']:
-            break
-        price = result[0]
-        if not price:
-            await Message.answer(
-                message, i18n['poll_failure'].format(
-                    address=address
-                ),
-                escape_text=False, bot=bot
-            )
-            break
-        price_str = format(price, '.2f')
-        if price < max_price:
-            await Message.answer(
-                message, i18n['poll_success'].format(
-                    price_str=price_str
-                ),
-                bot=bot
-            )
-            break
-        await state.update_data(latest_price=price_str)
-        await asyncio.sleep(60 * 10)
-    await state.reset_state()
-
-
-@dp.message_handler(commands=['start'])
-async def cmd_start(message):
-    await Form.address.set()
-    return await Message.reply(message, i18n['start'])
-
-
-@dp.message_handler(state=Form.address)
-async def process_address(message, state):
-    await state.update_data(address=message.text)
-    await Form.next()
-    return await Message.reply(message, i18n['process_address'])
-
-
-@dp.message_handler(lambda message: not is_float(message.text), state=Form.max_price)
-async def process_max_price_invalid(message):
-    return await Message.reply(message, i18n['process_max_price_invalid'])
-
-
-@dp.message_handler(lambda message: is_float(message.text), state=Form.max_price)
-async def process_max_price(message, state):
-    await state.update_data(
-        max_price=float(message.text.replace(',', '.')),
-        poll_interval=60 * 10,  # seconds
-        poll_price=True,
-        latest_price=None
-    )
-    await Form.next()
-    async with state.proxy() as data:
-        asyncio.create_task(_poll_price(message, data))
-        price_str = str(data['max_price']).replace('.', '\\.')
-        return await Message.answer(
-            message, i18n['process_max_price'].format(
-                price_str=price_str,
-                address=data['address']
-            ),
-            escape_text=False
-        )
-
-
-@dp.message_handler(commands=['showlatestprice'])
-async def cmd_latest_price(message):
-    data = await dp.current_state().get_data()
-    price = data.get('latest_price')
-    if not price:
-        return await Message.answer(message, i18n['latest_price_invalid'])
-    else:
-        return await Message.answer(message, i18n['latest_price'].format(price=price))
-
-
-@dp.message_handler(commands=['stop'])
-async def cmd_stop(message):
-    await dp.current_state().update_data(poll_price=False)
-    return await Message.answer(message, i18n['stop'])
-
-
-@dp.message_handler(commands=['help'])
-async def cmd_help(message):
-    return await Message.answer(message, i18n['help'])
-
-
-@dp.message_handler()
-async def echo(message):
-    print(message)
+    # Initialize bot and dispatcher
+    bot = Bot(settings.TOKEN, parse_mode=ParseMode.MARKDOWN_V2)
+    storage = MemoryStorage()
+    dp = Dispatcher(bot, storage=storage)
 
 
 async def on_startup(dp):
+    from cmds import setup_handlers
     if settings.ENV == 'production':
-        await bot.set_webhook(settings.WEBHOOK_URL)
+        await TelegramBot.bot.set_webhook(settings.WEBHOOK_URL)
+    setup_handlers(dp)
 
 
 async def on_shutdown(dp):
     # Remove webhook (not acceptable in some cases)
-    await bot.delete_webhook()
+    await TelegramBot.bot.delete_webhook()
 
 
 def main():
+    logging.basicConfig(level=logging.INFO)
     if settings.MODE == 'webhook':
         executor.start_webhook(
-            dispatcher=dp,
+            dispatcher=TelegramBot.dp,
             webhook_path=settings.WEBHOOK_PATH,
             on_startup=on_startup,
             on_shutdown=on_shutdown,
@@ -150,7 +41,4 @@ def main():
             port=settings.WEBAPP_PORT
         )
     if settings.MODE == 'polling':
-        executor.start_polling(dp, skip_updates=True)
-
-
-main()
+        executor.start_polling(TelegramBot.dp, on_startup=on_startup, skip_updates=True)

cmds/__init__.py

@@ -0,0 +1,15 @@
+from cmds.start import setup_start
+from cmds.poll import setup_poll
+from cmds.price import setup_price
+from cmds.help import setup_help
+from cmds.stop import setup_stop
+from cmds.echo import setup_echo
+
+
+def setup_handlers(dp):
+    setup_start(dp)
+    setup_poll(dp)
+    setup_price(dp)
+    setup_help(dp)
+    setup_stop(dp)
+    setup_echo(dp)

cmds/echo.py

@@ -0,0 +1,11 @@
+
+
+# @dp.message_handler(commands=['stop'])
+async def cmd_echo(message):
+    print(message)
+    message.text = 'jee'
+    print(message)
+
+
+def setup_echo(dp):
+    dp.register_message_handler(cmd_echo)

cmds/help.py

@@ -0,0 +1,12 @@
+import i18n
+
+from utils import Message
+
+
+# @dp.message_handler(commands=['stop'])
+async def cmd_help(message):
+    return await Message.answer(message, i18n['help'])
+
+
+def setup_help(dp):
+    dp.register_message_handler(cmd_help, commands=['help'])

cmds/poll.py

@@ -0,0 +1,66 @@
+import asyncio
+import i18n
+
+from aiogram.dispatcher.filters.state import State
+from aiogram.dispatcher.filters.state import StatesGroup
+
+from bot import TelegramBot
+from scraper import fetch_delivery_price
+from utils import Message
+
+
+class Form(StatesGroup):
+    address = State()
+
+
+async def _poll_price(message, address):
+    state = None
+    # Poll two hours at max
+    for _ in range(20):
+        result = await asyncio.gather(fetch_delivery_price(address))
+        state = TelegramBot.dp.current_state()
+        data = await state.get_data()
+        if not data['poll_price']:
+            break
+        price = result[0]
+        if not price:
+            await Message.answer(
+                message, i18n['poll_failure'].format(
+                    address=address
+                ),
+                escape_text=False, bot=TelegramBot.bot
+            )
+            break
+        price_str = format(price, '.2f')
+        await Message.answer(
+            message, i18n['latest_price'].format(price=price_str),
+            bot=TelegramBot.bot
+        )
+        await state.update_data(latest_price=price_str)
+        await asyncio.sleep(60 * 10)
+    await state.reset_state()
+
+
+# @dp.message_handler(commands=['poll'])
+async def cmd_poll(message):
+    await Form.address.set()
+    return await Message.reply(message, i18n['start'])
+
+
+# @dp.message_handler(state=Form.address)
+async def process_address(message, state):
+    await state.update_data(
+        address=message.text,
+        poll_price=True
+    )
+    await Form.next()
+    async with state.proxy() as data:
+        asyncio.create_task(_poll_price(message, data['address']))
+        return await Message.answer(
+            message, 'Haetaan...'
+        )
+
+
+def setup_poll(dp):
+    dp.register_message_handler(cmd_poll, commands=['poll'])
+    dp.register_message_handler(process_address, state=Form.address)

cmds/price.py

@@ -0,0 +1,58 @@
+import asyncio
+import i18n
+
+from aiogram.dispatcher.filters.state import State
+from aiogram.dispatcher.filters.state import StatesGroup
+
+from bot import TelegramBot
+from scraper import fetch_delivery_price
+from utils import Message
+
+
+class PriceForm(StatesGroup):
+    address = State()
+
+
+async def _get_price(message, address):
+    result = await asyncio.gather(fetch_delivery_price(address))
+    price = result[0]
+    if not price:
+        await Message.answer(
+            message, i18n['poll_failure'].format(
+                address=address
+            ),
+            escape_text=False, bot=TelegramBot.bot
+        )
+        return
+    price_str = format(price, '.2f')
+    return await Message.answer(
+        message, i18n['latest_price'].format(price=price_str),
+        bot=TelegramBot.bot
+    )
+
+
+# @dp.message_handler(commands=['poll'])
+async def cmd_price(message):
+    data = await TelegramBot.dp.current_state().get_data()
+    await PriceForm.address.set()
+    if data.get('address'):
+        message.text = data['address']
+        state = TelegramBot.dp.current_state()
+        return await process_address(message, state)
+    return await Message.reply(message, i18n['start'])
+
+
+# @dp.message_handler(state=Form.address)
+async def process_address(message, state):
+    await state.update_data(address=message.text)
+    await PriceForm.next()
+    async with state.proxy() as data:
+        asyncio.create_task(_get_price(message, data['address']))
+        return await Message.answer(
+            message, 'Haetaan...'
+        )
+
+
+def setup_price(dp):
+    dp.register_message_handler(cmd_price, commands=['price'])
+    dp.register_message_handler(process_address, state=PriceForm.address)