personnalisation du gestionnaire d'erreur

.env

@@ -5,5 +5,4 @@ SYSTEMD_LOGGING=False
 matrix_home_server="https://matrix.agent.ministere_example.tchap.gouv.fr"
 matrix_bot_username="jean.quidam@ministere_example.gouv.fr"
 matrix_bot_password="test"
-join_on_invite=True
 #https_proxy=http://adresse.du.proxy:port/

.gitignore

@@ -2,5 +2,3 @@
 .venv/
 session.txt
 store/
-__pycache__
-corpus/

README.md

@@ -20,7 +20,7 @@ pip install \
   tchap-bot --index-url https://code.peren.fr/api/v4/projects/83/packages/pypi/simple
 
 # Renseignez les informations de connexion :
-$EDITOR .env
+editor .env
 python -c 'import secrets; print("salt=", secrets.token_bytes(16), sep="")' >> .env
 
 # Lancer
@@ -43,4 +43,3 @@ sudo systemctl enable --now tchap-beta.service
 ````
 
 (L'emplacement et le nom d'utilisateur sont libres tant que c'est cohérent avec le service.)
-

callbacks.py

@@ -1,30 +0,0 @@
-from functools import wraps
-
-from nio import MatrixRoom, Event
-
-from matrix_bot.config import logger
-from matrix_bot.client import MatrixClient
-
-
-def properly_fail(error_message="failed to answer", style="m.notice"):
-    def custom_properly_fail(function):
-        """use this decorator so that your async callback never crash, log the error and return a message to the room"""
-
-        @wraps(function)
-        def decorated(room: MatrixRoom, message: Event, matrix_client: MatrixClient):
-            function_instance = function(room, message, matrix_client)
-
-            async def inner():
-                try:
-                    return await function_instance
-                except Exception as unexpected_exception:  # noqa
-                    await matrix_client.send_text_message(room.room_id, error_message, style)
-                    logger.warning(f"command failed with exception : {unexpected_exception}")
-                    exit()
-                finally:
-                    await matrix_client.room_typing(room.room_id, typing_state=False)
-
-            return inner()
-
-        return decorated
-    return custom_properly_fail

config.py

@@ -1,9 +0,0 @@
-from pydantic import Field
-
-from tchap_bot.config import Config
-
-
-class ConfigProxy(Config):
-    https_proxy: str = Field("", description="Proxy URL")
-
-env_config = ConfigProxy()

markov.py

@@ -1,20 +1,18 @@
 from collections import defaultdict
-from pathlib import Path
+from random import choice, randrange
-from random import choice
-
 
 suivants = defaultdict(list)
-for chemin in Path("corpus").iterdir():
+
-    with open(chemin, "r", encoding="utf-8") as fichier:
+with open("fra_wikipedia_2021_10K-sentences.txt", "r", encoding="utf-8") as fichier:
     for phrase in fichier:
         antepenultieme, penultieme = "", ""
         for word in phrase.split():
             suivants[(antepenultieme, penultieme)].append(word)
             antepenultieme, penultieme = penultieme, word
 
-def parle(nb_phrases=1):
+def parle():
     phrases = []
-    for _ in range(nb_phrases):
+    for _ in range(randrange(1, 4)):
         antepenultieme, penultieme = "", ""
         phrase = []
         while mots_possibles := suivants[(antepenultieme, penultieme)]:
@@ -23,7 +21,3 @@ def parle(nb_phrases=1):
             antepenultieme, penultieme = penultieme, mot_suivants
         phrases.append(" ".join(phrase))
     return "\n".join(phrases)
-
-
-if __name__ == "__main__":
-    print(parle())

tchap-beta.py

@@ -1,29 +1,54 @@
 import asyncio
+from functools import wraps
 
 from nio import MatrixRoom, Event
+from nio.crypto import ENCRYPTION_ENABLED
+
+from pydantic import Field
 
 from matrix_bot.bot import MatrixBot
 from matrix_bot.client import MatrixClient
 from matrix_bot.eventparser import MessageEventParser, ignore_when_not_concerned, EventNotConcerned
+from matrix_bot.config import logger
+from tchap_bot.config import Config
+
 
-from config import env_config
-from callbacks import properly_fail
 from markov import parle
 
 
-async def non_lus(room_id):
+class ConfigProxy(Config):
-    room = tchap_bot.matrix_client.rooms[room_id]
+    https_proxy: str = Field("", description="Proxy URL")
-    if room.unread_notifications:
+
-        response = await tchap_bot.matrix_client.room_messages(room_id=room_id, limit=room.unread_notifications, direction="back", start="")
+env_config = ConfigProxy()
-        for message in response.chunk:
+
-            await repond(room, message, tchap_bot.matrix_client)
+
+def properly_fail(function):
+    """use this decorator so that your async callback never crash, log the error and return a message to the room"""
+
+    @wraps(function)
+    def decorated(room: MatrixRoom, message: Event, matrix_client: MatrixClient):
+        function_instance = function(room, message, matrix_client)
+
+        async def inner():
+            try:
+                return await function_instance
+            except Exception as unexpected_exception:  # noqa
+                await matrix_client.send_text_message(room.room_id, "Oups, j'ai buggué 😿", "m.notice")
+                logger.warning(f"command failed with exception : {unexpected_exception}")
+                exit()
+            finally:
+                await matrix_client.room_typing(room.room_id, typing_state=False)
+
+        return inner()
+
+    return decorated
 
 
 # le décorateur @properly_fail va permettre à la commande de laisser un message d'erreur si la commande plante et
 # d'envoyer le message que le bot n'est plus en train d'écrire
 # la fonction va être appelée dans tous les cas, le décorateur @ignore_when_not_concerned
 # permet de laisser event_parser gérer le cas où la commande n'est pas concernée
-@properly_fail("Oups, j'ai buggué 😿")
+@properly_fail
 @ignore_when_not_concerned
 async def repond(room: MatrixRoom, message: Event, matrix_client: MatrixClient):
     # on initialise un event_parser pour décider à quel message cette commande va répondre
@@ -31,34 +56,16 @@ async def repond(room: MatrixRoom, message: Event, matrix_client: MatrixClient):
     # il ne va pas répondre à ses propres messages
     event_parser.do_not_accept_own_message()
 
-
-    if not hasattr(message, "body") or not hasattr(message, "formatted_body"):
-        # message non textuel
-        raise EventNotConcerned
-
     # ne répond qu'en message direct ou dans un salon s'il est interpellé avec @identifiant.du.bot dans le corps du message
     if len(room.users) > 2 and not (message.formatted_body and matrix_client.user_id in message.formatted_body):
         raise EventNotConcerned
 
+    reponse = parle()
     # il envoie l'information qu'il est en train d'écrire
     await matrix_client.room_typing(room.room_id)
-    reponse = parle()
+    await asyncio.sleep(len(reponse) / 30)
-    await asyncio.sleep(len(reponse) / 50)
     # il envoie le message
-    await matrix_client.room_typing(room.room_id, typing_state=False)
+    await matrix_client.send_text_message(room.room_id, reponse, "m.notice")
-    await matrix_client.send_html_message(room.room_id, reponse)
-
-
-@properly_fail("Oups, j'ai buggué 😿")
-@ignore_when_not_concerned
-async def dune(room: MatrixRoom, message: Event, matrix_client: MatrixClient):
-    event_parser = MessageEventParser(room=room, event=message, matrix_client=matrix_client)
-    event_parser.do_not_accept_own_message()
-
-    if ("Adrien" in message.body or "adrien" in message.body):
-        await matrix_client.room_typing(room.room_id)
-        await matrix_client.send_html_message(room.room_id, "<em>Lisan al-Gaib !</em>", "m.notice")
-
 
 tchap_bot = MatrixBot(
     env_config.matrix_home_server,
@@ -69,7 +76,10 @@ tchap_bot = MatrixBot(
     ssl=True
 )
 
-tchap_bot.callbacks.register_on_startup(non_lus)
+tchap_bot.matrix_client.matrix_config.encryption_enabled = True
-tchap_bot.callbacks.register_on_message_event(dune)
+tchap_bot.matrix_client.matrix_config.ignore_unverified_devices = True
+tchap_bot.matrix_client.matrix_config.join_on_invite = True
+
 tchap_bot.callbacks.register_on_message_event(repond)
 tchap_bot.run()
+