Telegram: A bit more robust

[home-hw.git] / telegram / test.py

diff --git a/telegram/test.py b/telegram/test.py
index aaff5bfce8a064046a588776bbb1089fc3415361..8ff3797ffd2d1de80193667b498daed022c61e29 100755 (executable)
--- a/telegram/test.py
+++ b/telegram/test.py
@@ -5,23 +5,30 @@ import asyncio
 import asyncio_mqtt
 from datetime import datetime, timedelta
 import logging
+import signal
 import ssl
+import sys
 
 import config
 
-logging.basicConfig(level=logging.INFO)
+formatter = logging.Formatter(fmt="%(asctime)s %(name)s.%(levelname)s: %(message)s", datefmt='%Y-%m-%d %H:%M:%S')
+log_handler = logging.StreamHandler(stream=sys.stdout)
+log_handler.setFormatter(formatter)
+logger = logging.getLogger()
+logger.setLevel(logging.DEBUG)
+logger.addHandler(log_handler)
 
 bot = Bot(token=config.API_TOKEN)
-dp = Dispatcher(bot)
+dispatcher = Dispatcher(bot)
 
 
-@dp.message_handler(commands=['start', 'help'])
+@dispatcher.message_handler(commands=['start', 'help'])
 async def send_welcome(message: types.Message):
-    logging.info(f'Start from {message.chat}')
+    logger.info(f'Start from {message.chat}')
     await message.reply("Brum!\nI'm BurrowBot!\n")
 
 
-@dp.message_handler()
+@dispatcher.message_handler()
 async def echo(message: types.Message):
     print(message)
     # await message.answer(message.text)
@@ -35,24 +42,24 @@ bucket_last_fill = datetime.now()
 
 async def send_msg(text):
     global bucket, bucket_last_fill
-    logging.info(f'>>> Sending message: {text}')
+    logger.info(f'Sending message: {text}')
 
     if bucket < BUCKET_CAPACITY:
         now = datetime.now()
         while bucket < BUCKET_CAPACITY and bucket_last_fill + BUCKET_REFRESH <= now:
             bucket_last_fill += BUCKET_REFRESH
             bucket += 1
-            logging.info(f'Bucket refill: {bucket}')
+            logger.debug(f'Bucket refill: {bucket}')
 
     if bucket > 0:
         bucket -= 1
-        logging.info(f'Bucket drain: {bucket}')
+        logger.debug(f'Bucket drain: {bucket}')
 
         for chat in config.CHATS:
             await bot.send_message(chat, text + '\n')
 
     else:
-        logging.info('Bucket empty :(')
+        logger.info('Bucket empty :(')
 
 
 hyst_state = {}
@@ -85,15 +92,22 @@ last_boiler_err = 0
 async def mqtt_process_msg(topic, val):
     global last_temp_state, last_temp_warning
     global last_boiler_err
+    now = datetime.now()
 
-    # print(topic, '->', val)
+    print(topic, '->', val)
 
     if topic == 'burrow/temp/catarium':
-        temp = float(val.split(' ')[0])
-        temp_state = hysteresis('catarium-temp', temp, 23.2, 23.5)
+        temp, when = map(float, val.split(' '))
+        if when < now.timestamp() - 3600:
+            temp_state = 0
+        else:
+            temp_state = hysteresis('catarium-temp', temp, 23.2, 23.5)
         if temp_state != last_temp_state:
             last_temp_state = temp_state
-            await send_msg(f'Teplota v pracovně: {temp} °C')
+            if temp_state == 0:
+                await send_msg('Teplotní čidlo v pracovně nefunguje.')
+            else:
+                await send_msg(f'Teplota v pracovně: {temp} °C')
 
     if topic == 'burrow/heating/error':
         err = int(val.split(' ')[0])
@@ -119,19 +133,31 @@ async def mqtt_loop():
 async def mqtt_watcher():
     while True:
         try:
-            logging.info(">>> Starting MQTT")
+            logger.info("Starting MQTT")
             await mqtt_loop()
         except asyncio_mqtt.MqttError as error:
-            logging.error(f"MQTT error: {error}")
+            logger.error(f"MQTT error: {error}")
         finally:
-            await asyncio.sleep(30)
+            await asyncio.sleep(10)
+
+
+async def fortunes():
+    while True:
+        proc = await asyncio.create_subprocess_exec('fortune', stdout=asyncio.subprocess.PIPE)
+        out, err = await proc.communicate()
+        if proc.returncode == 0:
+            await send_msg(out.decode())
+        else:
+            logger.error(f'fortune failed with return code {proc.returncode}')
+        await asyncio.sleep(24*60*60)
 
 
-loop = asyncio.get_event_loop()
-loop.create_task(mqtt_watcher())
+async def main():
+    loop = asyncio.get_event_loop()
+    t1 = loop.create_task(mqtt_watcher())
+    t2 = loop.create_task(dispatcher.start_polling(timeout=20, relax=0.01, fast=True, allowed_updates=None))
+    t3 = loop.create_task(fortunes())
+    await asyncio.wait((t1, t2, t3))
 
-executor.start_polling(dp, skip_updates=True)
 
-## loop = asyncio.get_event_loop()
-## loop.create_task(self.dispatcher.start_polling(reset_webhook=reset_webhook, timeout=20, relax=0.01, fast=True, allowed_updates=None))
-## loop.run_forever()
+asyncio.run(main())