From f136d15975db2b292a408727f76b3fce1b3f1351 Mon Sep 17 00:00:00 2001
From: Michel <michel@mj91.fr>
Date: Fri, 18 Apr 2025 06:48:52 +0200
Subject: [PATCH 01/12] =?UTF-8?q?"Ajout=20entr=C3=A9es=20au=20fichier=20Gi?=
 =?UTF-8?q?tignore"?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .gitignore | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/.gitignore b/.gitignore
index 22e4576..cedf7ec 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,10 +1,14 @@
 # 👉 Dossiers de configuration PyCharm
 .idea/
+*.iml
+*.ipr
+*.iws
 
 # 👉 Environnement virtuel
 .venv/
 venv/
 env/
+.env/
 
 # 👉 Fichiers Python compilés
 __pycache__/

From b06da00d9c8ecaaa0407451cf745f27637582ea9 Mon Sep 17 00:00:00 2001
From: Michel <michel@mj91.fr>
Date: Fri, 18 Apr 2025 07:30:41 +0200
Subject: [PATCH 02/12] Restauration des fichiers de develop depuis sauvegarde
 Synology

---
 .idea/workspace.xml                        | 158 ++++++----
 Chat-Id.py                                 |  36 +++
 Chaufferie.py                              |  30 ++
 Fichiers restaurés/Chat-Id.py              |  36 +++
 Fichiers restaurés/Chaufferie.py           |  30 ++
 Fichiers restaurés/Purge_Alertes_saclay.py |  18 ++
 Fichiers restaurés/README.md               |  52 ++++
 Fichiers restaurés/Societe_Generale.py     | 107 +++++++
 Fichiers restaurés/Telegram_sondes.py      | 324 +++++++++++++++++++++
 Fichiers restaurés/Test_mail.py            |  24 ++
 Fichiers restaurés/Tracker.py              | 106 +++++++
 Fichiers restaurés/logs_analyse.py         |  39 +++
 Fichiers restaurés/supervisor_watchdog.py  |  47 +++
 Purge_Alertes_saclay.py                    |  18 ++
 README.md                                  |  52 ++++
 Societe_Generale.py                        | 107 +++++++
 Telegram_sondes.py                         | 324 +++++++++++++++++++++
 Test_mail.py                               |  24 ++
 Tracker.py                                 | 106 +++++++
 logs_analyse.py                            |  39 +++
 supervisor_watchdog.py                     |  47 +++
 21 files changed, 1669 insertions(+), 55 deletions(-)
 create mode 100644 Chat-Id.py
 create mode 100644 Chaufferie.py
 create mode 100644 Fichiers restaurés/Chat-Id.py
 create mode 100644 Fichiers restaurés/Chaufferie.py
 create mode 100644 Fichiers restaurés/Purge_Alertes_saclay.py
 create mode 100644 Fichiers restaurés/README.md
 create mode 100644 Fichiers restaurés/Societe_Generale.py
 create mode 100644 Fichiers restaurés/Telegram_sondes.py
 create mode 100644 Fichiers restaurés/Test_mail.py
 create mode 100644 Fichiers restaurés/Tracker.py
 create mode 100644 Fichiers restaurés/logs_analyse.py
 create mode 100644 Fichiers restaurés/supervisor_watchdog.py
 create mode 100644 Purge_Alertes_saclay.py
 create mode 100644 README.md
 create mode 100644 Societe_Generale.py
 create mode 100644 Telegram_sondes.py
 create mode 100644 Test_mail.py
 create mode 100644 Tracker.py
 create mode 100644 logs_analyse.py
 create mode 100644 supervisor_watchdog.py

diff --git a/.idea/workspace.xml b/.idea/workspace.xml
index 2f1b464..6354e07 100644
--- a/.idea/workspace.xml
+++ b/.idea/workspace.xml
@@ -4,11 +4,8 @@
     <option name="autoReloadType" value="SELECTIVE" />
   </component>
   <component name="ChangeListManager">
-    <list default="true" id="a12d9762-568e-4ace-91c1-148c598387a7" name="Changes" comment="&quot;Ajout bt impression rapports et dossier PDF crée&quot;">
-      <change afterPath="$PROJECT_DIR$/tools/deploy_product.sh" afterDir="false" />
+    <list default="true" id="a12d9762-568e-4ace-91c1-148c598387a7" name="Changes" comment="&quot;Ajout entrées au fichier Gitignore&quot;">
       <change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/Scripts/.deploy.sh" beforeDir="false" afterPath="$PROJECT_DIR$/Scripts/.deploy.sh" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/domo91.py" beforeDir="false" afterPath="$PROJECT_DIR$/domo91.py" afterDir="false" />
     </list>
     <option name="SHOW_DIALOG" value="false" />
     <option name="HIGHLIGHT_CONFLICTS" value="true" />
@@ -28,7 +25,7 @@
   <component name="Git.Settings">
     <option name="RECENT_BRANCH_BY_REPOSITORY">
       <map>
-        <entry key="$PROJECT_DIR$" value="develop" />
+        <entry key="$PROJECT_DIR$" value="f136d15975db2b292a408727f76b3fce1b3f1351" />
       </map>
     </option>
     <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
@@ -50,55 +47,55 @@
     <option name="showLibraryContents" value="true" />
     <option name="showScratchesAndConsoles" value="false" />
   </component>
-  <component name="PropertiesComponent"><![CDATA[{
-  "keyToString": {
-    "Python.AlerteMonitoring.executor": "Run",
-    "Python.Alerte_journalière.executor": "Run",
-    "Python.AlertesSondesSaclay.executor": "Run",
-    "Python.Alertes_Saclay.executor": "Run",
-    "Python.Alertes_Telegram.executor": "Run",
-    "Python.Alertes_saclay.executor": "Run",
-    "Python.Alertes_telegram.executor": "Run",
-    "Python.Base.executor": "Run",
-    "Python.Base2.executor": "Run",
-    "Python.Chat-Id.executor": "Run",
-    "Python.Chaufferie.executor": "Run",
-    "Python.Code_général.executor": "Run",
-    "Python.Connexion_mysql.executor": "Run",
-    "Python.Cuisine_meudon.executor": "Run",
-    "Python.Cuisine_saclay.executor": "Run",
-    "Python.Général.executor": "Run",
-    "Python.Insertion_tables_Msql.executor": "Run",
-    "Python.Lecture_tableau_frigos.executor": "Run",
-    "Python.Monitor.executor": "Run",
-    "Python.Saclay.executor": "Run",
-    "Python.Saclay_buffer.executor": "Run",
-    "Python.Sondes tracker.executor": "Run",
-    "Python.Streamlit.executor": "Run",
-    "Python.Streamlit_Saaclay.executor": "Run",
-    "Python.Streamlit_Saclay.executor": "Run",
-    "Python.Telegram_sondes.executor": "Run",
-    "Python.Test Tables MYSQL.executor": "Run",
-    "Python.Test Tables Sondes.executor": "Run",
-    "Python.Test table Meudon.executor": "Run",
-    "Python.Test table Saclay.executor": "Run",
-    "Python.Test.executor": "Run",
-    "Python.Test_mail.executor": "Run",
-    "Python.Tracker.executor": "Run",
-    "Python.Vérification Triggers.executor": "Run",
-    "Python.Vérification_temperatures_alertes_mail.executor": "Run",
-    "Python.domo91.executor": "Run",
-    "Python.logs_analyses.executor": "Run",
-    "Python.test.executor": "Run",
-    "RunOnceActivity.ShowReadmeOnStart": "true",
-    "RunOnceActivity.git.unshallow": "true",
-    "git-widget-placeholder": "Merging product",
-    "ignore.virus.scanning.warn.message": "true",
-    "last_opened_file_path": "C:/Users/miche/PycharmProjects/Gestion sondes",
-    "settings.editor.selected.configurable": "com.jetbrains.python.configuration.PyActiveSdkModuleConfigurable",
-    "settings.editor.splitter.proportion": "0.28861153"
+  <component name="PropertiesComponent">{
+  &quot;keyToString&quot;: {
+    &quot;Python.AlerteMonitoring.executor&quot;: &quot;Run&quot;,
+    &quot;Python.Alerte_journalière.executor&quot;: &quot;Run&quot;,
+    &quot;Python.AlertesSondesSaclay.executor&quot;: &quot;Run&quot;,
+    &quot;Python.Alertes_Saclay.executor&quot;: &quot;Run&quot;,
+    &quot;Python.Alertes_Telegram.executor&quot;: &quot;Run&quot;,
+    &quot;Python.Alertes_saclay.executor&quot;: &quot;Run&quot;,
+    &quot;Python.Alertes_telegram.executor&quot;: &quot;Run&quot;,
+    &quot;Python.Base.executor&quot;: &quot;Run&quot;,
+    &quot;Python.Base2.executor&quot;: &quot;Run&quot;,
+    &quot;Python.Chat-Id.executor&quot;: &quot;Run&quot;,
+    &quot;Python.Chaufferie.executor&quot;: &quot;Run&quot;,
+    &quot;Python.Code_général.executor&quot;: &quot;Run&quot;,
+    &quot;Python.Connexion_mysql.executor&quot;: &quot;Run&quot;,
+    &quot;Python.Cuisine_meudon.executor&quot;: &quot;Run&quot;,
+    &quot;Python.Cuisine_saclay.executor&quot;: &quot;Run&quot;,
+    &quot;Python.Général.executor&quot;: &quot;Run&quot;,
+    &quot;Python.Insertion_tables_Msql.executor&quot;: &quot;Run&quot;,
+    &quot;Python.Lecture_tableau_frigos.executor&quot;: &quot;Run&quot;,
+    &quot;Python.Monitor.executor&quot;: &quot;Run&quot;,
+    &quot;Python.Saclay.executor&quot;: &quot;Run&quot;,
+    &quot;Python.Saclay_buffer.executor&quot;: &quot;Run&quot;,
+    &quot;Python.Sondes tracker.executor&quot;: &quot;Run&quot;,
+    &quot;Python.Streamlit.executor&quot;: &quot;Run&quot;,
+    &quot;Python.Streamlit_Saaclay.executor&quot;: &quot;Run&quot;,
+    &quot;Python.Streamlit_Saclay.executor&quot;: &quot;Run&quot;,
+    &quot;Python.Telegram_sondes.executor&quot;: &quot;Run&quot;,
+    &quot;Python.Test Tables MYSQL.executor&quot;: &quot;Run&quot;,
+    &quot;Python.Test Tables Sondes.executor&quot;: &quot;Run&quot;,
+    &quot;Python.Test table Meudon.executor&quot;: &quot;Run&quot;,
+    &quot;Python.Test table Saclay.executor&quot;: &quot;Run&quot;,
+    &quot;Python.Test.executor&quot;: &quot;Run&quot;,
+    &quot;Python.Test_mail.executor&quot;: &quot;Run&quot;,
+    &quot;Python.Tracker.executor&quot;: &quot;Run&quot;,
+    &quot;Python.Vérification Triggers.executor&quot;: &quot;Run&quot;,
+    &quot;Python.Vérification_temperatures_alertes_mail.executor&quot;: &quot;Run&quot;,
+    &quot;Python.domo91.executor&quot;: &quot;Run&quot;,
+    &quot;Python.logs_analyses.executor&quot;: &quot;Run&quot;,
+    &quot;Python.test.executor&quot;: &quot;Run&quot;,
+    &quot;RunOnceActivity.ShowReadmeOnStart&quot;: &quot;true&quot;,
+    &quot;RunOnceActivity.git.unshallow&quot;: &quot;true&quot;,
+    &quot;git-widget-placeholder&quot;: &quot;develop&quot;,
+    &quot;ignore.virus.scanning.warn.message&quot;: &quot;true&quot;,
+    &quot;last_opened_file_path&quot;: &quot;C:/Users/miche/PycharmProjects/Gestion sondes&quot;,
+    &quot;settings.editor.selected.configurable&quot;: &quot;vcs.Git&quot;,
+    &quot;settings.editor.splitter.proportion&quot;: &quot;0.28861153&quot;
   }
-}]]></component>
+}</component>
   <component name="RecentsManager">
     <key name="CopyFile.RECENT_KEYS">
       <recent name="C:\Users\miche\PycharmProjects\Gestion sondes" />
@@ -134,6 +131,10 @@
     <recent_temporary>
       <list>
         <item itemvalue="Python.domo91" />
+        <item itemvalue="Python.domo91" />
+        <item itemvalue="Python.domo91" />
+        <item itemvalue="Python.domo91" />
+        <item itemvalue="Python.domo91" />
       </list>
     </recent_temporary>
   </component>
@@ -260,9 +261,55 @@
       <option name="project" value="LOCAL" />
       <updated>1744891048964</updated>
     </task>
-    <option name="localTasksCounter" value="14" />
+    <task id="LOCAL-00014" summary="&quot;Ajout entrées au fichier Gitignore&quot;">
+      <option name="closed" value="true" />
+      <created>1744951733528</created>
+      <option name="number" value="00014" />
+      <option name="presentableId" value="LOCAL-00014" />
+      <option name="project" value="LOCAL" />
+      <updated>1744951733528</updated>
+    </task>
+    <option name="localTasksCounter" value="15" />
     <servers />
   </component>
+  <component name="Vcs.Log.Tabs.Properties">
+    <option name="RECENT_FILTERS">
+      <map>
+        <entry key="Branch">
+          <value>
+            <list>
+              <RecentGroup>
+                <option name="FILTER_VALUES">
+                  <option value="develop" />
+                </option>
+              </RecentGroup>
+            </list>
+          </value>
+        </entry>
+      </map>
+    </option>
+    <option name="TAB_STATES">
+      <map>
+        <entry key="MAIN">
+          <value>
+            <State>
+              <option name="FILTERS">
+                <map>
+                  <entry key="branch">
+                    <value>
+                      <list>
+                        <option value="develop" />
+                      </list>
+                    </value>
+                  </entry>
+                </map>
+              </option>
+            </State>
+          </value>
+        </entry>
+      </map>
+    </option>
+  </component>
   <component name="VcsManagerConfiguration">
     <MESSAGE value="Ajout README Complet" />
     <MESSAGE value=".gitignore" />
@@ -270,6 +317,7 @@
     <MESSAGE value="Base de données SG" />
     <MESSAGE value="&quot;Injection données dans Tables Meudon et Roissy&quot;" />
     <MESSAGE value="&quot;Ajout bt impression rapports et dossier PDF crée&quot;" />
-    <option name="LAST_COMMIT_MESSAGE" value="&quot;Ajout bt impression rapports et dossier PDF crée&quot;" />
+    <MESSAGE value="&quot;Ajout entrées au fichier Gitignore&quot;" />
+    <option name="LAST_COMMIT_MESSAGE" value="&quot;Ajout entrées au fichier Gitignore&quot;" />
   </component>
 </project>
\ No newline at end of file
diff --git a/Chat-Id.py b/Chat-Id.py
new file mode 100644
index 0000000..a5bd401
--- /dev/null
+++ b/Chat-Id.py
@@ -0,0 +1,36 @@
+import requests
+import json
+
+# Remplace par ton token de bot Telegram
+token = "8128378340:AAF2sO3gaH1XpMNya_pEslzerqokoCiFRGs"
+
+url = f"https://api.telegram.org/bot{token}/getUpdates"
+
+try:
+    response = requests.get(url)
+    data = response.json()
+
+    print("🔍 Récupération des chats Telegram récents...\n")
+
+    if "result" in data:
+        chats = set()
+
+        for update in data["result"]:
+            message = update.get("message") or update.get("edited_message")
+            if not message:
+                continue
+
+            chat = message["chat"]
+            chat_id = chat["id"]
+            chat_title = chat.get("title") or chat.get("username") or chat.get("first_name") or "Inconnu"
+
+            if chat_id not in chats:
+                chats.add(chat_id)
+                print(f"➡️  Chat : {chat_title} | ID : {chat_id}")
+
+        if not chats:
+            print("⚠️ Aucun chat trouvé. Envoie un message depuis un groupe ou une discussion avec le bot.")
+    else:
+        print("❌ Erreur : aucune donnée 'result' trouvée dans la réponse.")
+except Exception as e:
+    print(f"Erreur lors de la récupération des chats : {e}")
diff --git a/Chaufferie.py b/Chaufferie.py
new file mode 100644
index 0000000..73eab00
--- /dev/null
+++ b/Chaufferie.py
@@ -0,0 +1,30 @@
+import paho.mqtt.client as mqtt
+import mysql.connector
+
+# Configuration de la connexion MySQL
+mydb = mysql.connector.connect(
+  host="54.36.188.119",
+  user="michel",
+  password="#SO2&1nf%mZ@jfh",
+  database="Sondes"
+)
+
+# Fonction de callback quand un message est reçu
+def on_message(_client, _userdata, msg):
+    print(f"Message reçu sur {msg.topic}: {msg.payload.decode()}")
+    cursor = mydb.cursor()
+    frigo_name = msg.topic.split('/')[-1]  # Prend la dernière partie après le "/"
+    sql = "INSERT INTO Chaufferie (Sonde, Temperature) VALUES (%s, %s)"
+    val = (frigo_name, msg.payload.decode())
+    cursor.execute(sql, val)
+    mydb.commit()
+
+# Configuration du client MQTT
+client = mqtt.Client()
+client.username_pw_set("Bwps", "scJ5ACj2keRfI^")
+client.on_message = on_message
+
+client.connect("54.36.188.119", 1883, 60)
+client.subscribe("Module_01/#")  # S'abonner à tous les topics commençant par Saclay
+
+client.loop_forever()  # Rester connecté en continu pour écouter les messages
diff --git a/Fichiers restaurés/Chat-Id.py b/Fichiers restaurés/Chat-Id.py
new file mode 100644
index 0000000..a5bd401
--- /dev/null
+++ b/Fichiers restaurés/Chat-Id.py	
@@ -0,0 +1,36 @@
+import requests
+import json
+
+# Remplace par ton token de bot Telegram
+token = "8128378340:AAF2sO3gaH1XpMNya_pEslzerqokoCiFRGs"
+
+url = f"https://api.telegram.org/bot{token}/getUpdates"
+
+try:
+    response = requests.get(url)
+    data = response.json()
+
+    print("🔍 Récupération des chats Telegram récents...\n")
+
+    if "result" in data:
+        chats = set()
+
+        for update in data["result"]:
+            message = update.get("message") or update.get("edited_message")
+            if not message:
+                continue
+
+            chat = message["chat"]
+            chat_id = chat["id"]
+            chat_title = chat.get("title") or chat.get("username") or chat.get("first_name") or "Inconnu"
+
+            if chat_id not in chats:
+                chats.add(chat_id)
+                print(f"➡️  Chat : {chat_title} | ID : {chat_id}")
+
+        if not chats:
+            print("⚠️ Aucun chat trouvé. Envoie un message depuis un groupe ou une discussion avec le bot.")
+    else:
+        print("❌ Erreur : aucune donnée 'result' trouvée dans la réponse.")
+except Exception as e:
+    print(f"Erreur lors de la récupération des chats : {e}")
diff --git a/Fichiers restaurés/Chaufferie.py b/Fichiers restaurés/Chaufferie.py
new file mode 100644
index 0000000..73eab00
--- /dev/null
+++ b/Fichiers restaurés/Chaufferie.py	
@@ -0,0 +1,30 @@
+import paho.mqtt.client as mqtt
+import mysql.connector
+
+# Configuration de la connexion MySQL
+mydb = mysql.connector.connect(
+  host="54.36.188.119",
+  user="michel",
+  password="#SO2&1nf%mZ@jfh",
+  database="Sondes"
+)
+
+# Fonction de callback quand un message est reçu
+def on_message(_client, _userdata, msg):
+    print(f"Message reçu sur {msg.topic}: {msg.payload.decode()}")
+    cursor = mydb.cursor()
+    frigo_name = msg.topic.split('/')[-1]  # Prend la dernière partie après le "/"
+    sql = "INSERT INTO Chaufferie (Sonde, Temperature) VALUES (%s, %s)"
+    val = (frigo_name, msg.payload.decode())
+    cursor.execute(sql, val)
+    mydb.commit()
+
+# Configuration du client MQTT
+client = mqtt.Client()
+client.username_pw_set("Bwps", "scJ5ACj2keRfI^")
+client.on_message = on_message
+
+client.connect("54.36.188.119", 1883, 60)
+client.subscribe("Module_01/#")  # S'abonner à tous les topics commençant par Saclay
+
+client.loop_forever()  # Rester connecté en continu pour écouter les messages
diff --git a/Fichiers restaurés/Purge_Alertes_saclay.py b/Fichiers restaurés/Purge_Alertes_saclay.py
new file mode 100644
index 0000000..83f89e2
--- /dev/null
+++ b/Fichiers restaurés/Purge_Alertes_saclay.py	
@@ -0,0 +1,18 @@
+# Purge de la table Sondes.Alertes_Saclay.
+import mysql.connector
+
+config = {
+    "host": "54.36.188.119",
+    "user": "michel",
+    "password": "#SO2&1nf%mZ@jfh",
+    "database": "Sondes"
+}
+
+conn = mysql.connector.connect(**config)
+cursor = conn.cursor()
+cursor.execute("DELETE FROM Alertes_Saclay WHERE Debut_defaut < NOW() - INTERVAL 7 DAY")
+conn.commit()
+cursor.close()
+conn.close()
+
+print("✅ Alertes de plus de 7 jours supprimées.")
diff --git a/Fichiers restaurés/README.md b/Fichiers restaurés/README.md
new file mode 100644
index 0000000..d91c980
--- /dev/null
+++ b/Fichiers restaurés/README.md	
@@ -0,0 +1,52 @@
+# 🌡️ Gestion des sondes domotiques
+
+[![Version Python](https://img.shields.io/badge/Python-3.10-blue)](https://python.org)
+[![Licence](https://img.shields.io/badge/Licence-Propriétaire-orange)](https://mj91.fr:448/michel/Gestion_sondes)
+[![Gitea](https://img.shields.io/badge/Gitea-auto--hébergé-green)](https://mj91.fr:448)
+
+Application de **surveillance des températures** avec alertes, visualisation Streamlit, et déploiement automatisé via Gitea + Supervisor.
+
+---
+
+## 🧩 Fonctionnalités principales
+
+- 🔍 Lecture de capteurs **DS18B20** et **DHT22**
+- 📨 Transmission via **MQTT**
+- 📊 Interface **Streamlit** (app.domo91.fr)
+- 🔔 Alertes **email / Telegram** si dépassement > 30 minutes
+- 🧠 Déploiement auto avec **`deploy.sh`**
+- 🧾 Stockage SQL sur **MySQL (VPS)**
+
+---
+
+## 📊 Exemple de visualisation
+
+Voici un aperçu d’un graphique dans l’interface Streamlit :
+
+![Exemple de graphique Streamlit](https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Matplotlib_figure.svg/800px-Matplotlib_figure.svg.png)
+
+---
+
+## 🗂️ Structure du projet
+
+| Fichier                      | Description                                                        |
+|-----------------------------|---------------------------------------------------------------------|
+| `Monitor.py`                | Analyse de température et alertes                                 |
+| `Streamlit.py`              | Interface graphique web                                           |
+| `Cuisine_saclay.py`         | Script capteur pour le site de Saclay                            |
+| `Cuisine_meudon.py`         | Script capteur pour Meudon                                        |
+| `check_supervisor.py`       | Vérifie l’état des scripts supervisés                            |
+| `deploy.sh`                 | Déploiement auto depuis Gitea (branche `product`)                 |
+| `requirements.txt`          | Dépendances Python                                                |
+
+---
+
+## 🧪 Installation locale
+
+```bash
+git clone https://mj91.fr:448/michel/Gestion_sondes.git
+cd Gestion_sondes
+python -m venv .venv
+source .venv/bin/activate  # Linux/macOS
+.venv\Scripts\activate     # Windows
+pip install -r requirements.txt
diff --git a/Fichiers restaurés/Societe_Generale.py b/Fichiers restaurés/Societe_Generale.py
new file mode 100644
index 0000000..88c100c
--- /dev/null
+++ b/Fichiers restaurés/Societe_Generale.py	
@@ -0,0 +1,107 @@
+# Insertion de données da l'app SG.
+import streamlit as st
+import mysql.connector
+from dotenv import load_dotenv
+import os
+from datetime import datetime
+
+load_dotenv()
+
+st.set_page_config(page_title="Insertion Mysql", layout="centered")
+st.title("🗓️ Insertion dans une base MySQL")
+
+# Charger les identifiants
+DB_HOST = os.getenv("DB_HOST")
+DB_USER = os.getenv("DB_USER")
+DB_PASSWORD = os.getenv("DB_PASSWORD")
+
+# Connexion sans DB initiale pour lister les bases
+@st.cache_data
+def get_databases():
+    conn = mysql.connector.connect(
+        host=DB_HOST,
+        user=DB_USER,
+        password=DB_PASSWORD
+    )
+    cursor = conn.cursor()
+    cursor.execute("SHOW DATABASES")
+    bases = [db[0] for db in cursor.fetchall()]
+    conn.close()
+    return bases
+
+# Connexion avec DB sélectionnée
+def connect_to_db(db_name):
+    return mysql.connector.connect(
+        host=DB_HOST,
+        user=DB_USER,
+        password=DB_PASSWORD,
+        database=db_name
+    )
+
+# --- Interface principale ---
+
+base = st.selectbox("Choisir une base de données", get_databases())
+if base:
+    conn = connect_to_db(base)
+    cursor = conn.cursor()
+
+    cursor.execute("SHOW TABLES")
+    tables = [table[0] for table in cursor.fetchall()]
+    table = st.selectbox("Choisir une table", tables)
+
+    if table:
+        cursor.execute(f"DESCRIBE {table}")
+        colonnes = cursor.fetchall()
+
+        # Détection clé primaire
+        cursor.execute(f"SHOW INDEX FROM {table} WHERE Key_name = 'PRIMARY'")
+        pk = cursor.fetchone()
+        primary_key = pk[4] if pk else None
+
+        champ_date_candidates = [col[0] for col in colonnes if "date" in col[1].lower()]
+        champ_date = st.selectbox("Champ de date", champ_date_candidates)
+
+        nb_mois = st.number_input("Nombre d'insertions mensuelles", 1, 36, 6)
+        date_depart = st.date_input("Date de départ des insertions", value=datetime.today().date())
+        st.subheader("Champs à insérer (hors clé primaire et champ de date)")
+        champs_choisis = []
+        champs_editables = [col for col in colonnes if col[0] != primary_key and col[0] != champ_date]
+        for col in champs_editables:
+            if st.checkbox(f"{col[0]} ({col[1]})", value=True):
+                champs_choisis.append(col[0])
+
+        with st.form("formulaire_insertion"):
+            st.markdown("**Valeurs fixes pour les champs cochés**")
+            valeurs_fixes = {}
+            for nom in champs_choisis:
+                val = st.text_input(nom)
+                valeurs_fixes[nom] = val if val != "" else None
+
+            submit = st.form_submit_button("Insérer")
+
+            try:
+                cursor = conn.cursor()
+                insert_count = 0
+
+                for i in range(nb_mois):
+                    year = date_depart.year + (date_depart.month + i - 1) // 12
+                    month = (date_depart.month + i - 1) % 12 + 1
+                    day = min(date_depart.day, 28)
+                    date_cible = datetime(year, month, day).date()
+
+                    champs = [champ_date] + list(valeurs_fixes.keys())
+                    valeurs = [date_cible] + list(valeurs_fixes.values())
+                    sql = f"INSERT INTO {table} ({', '.join(champs)}) VALUES ({', '.join(['%s'] * len(valeurs))})"
+
+                    cursor.execute(sql, valeurs)
+                    insert_count += 1
+
+                conn.commit()
+                st.success(f"{insert_count} lignes insérées avec succès dans `{table}`.")
+
+            except Exception as e:
+                st.error(f"❌ Erreur lors de l’insertion : {e}")
+
+                conn.commit()
+                st.success(f"{insert_count} lignes insérées avec succès dans `{table}`.")
+st.success(f"{insert_count} lignes insérées avec succès.")
\ No newline at end of file
diff --git a/Fichiers restaurés/Telegram_sondes.py b/Fichiers restaurés/Telegram_sondes.py
new file mode 100644
index 0000000..3077d92
--- /dev/null
+++ b/Fichiers restaurés/Telegram_sondes.py	
@@ -0,0 +1,324 @@
+# Gestion des chambres froides & alertes Telegram
+import requests
+import mysql.connector
+from datetime import datetime, timedelta
+import time
+import sys
+import os
+import schedule
+
+def connect_db():
+    return mysql.connector.connect(
+        host="54.36.188.119",
+        user="michel",
+        password="#SO2&1nf%mZ@jfh",
+        database="Sondes"
+    )
+
+def envoi_etat_quotidien(cursor, site):
+    token = "8128378340:AAF2sO3gaH1XpMNya_pEslzerqokoCiFRGs"
+    chat_id = get_chat_id(cursor, site)
+    etat_sondes(cursor, site, chat_id, token)
+    print(f"[INFO] État des sondes envoyé pour le site {site}.")
+
+def get_active_sondes(cursor, site):
+    query = "SELECT Sonde, Temp_Max FROM Chambres_froides WHERE Lieu = %s AND Etat = 'On';"
+    cursor.execute(query, (site,))
+    result = cursor.fetchall()
+    return {row[0]: float(row[1]) for row in result}
+
+
+def check_temperature_limits(cursor, table_historique, sonde, limite, duree=30):
+    temps_limite = datetime.now() - timedelta(minutes=duree)
+    query = f"""
+    SELECT Temperature 
+    FROM {table_historique}
+    WHERE Sonde = %s AND Date >= %s 
+    ORDER BY Date DESC LIMIT 6;
+    """
+    cursor.execute(query, (sonde, temps_limite))
+    result = cursor.fetchall()
+    if len(result) == 6 and all(float(temp[0]) > limite for temp in result):
+        return True, float(result[0][0])
+    return False, None
+
+def simulate_alert(db, cursor, site, sonde, chat_id, token):
+    table_alertes = f"Alertes_{site}"
+    print(f"[TEST] tentative d'insertion de sonde : {sonde} dans table {table_alertes}")
+
+    try:
+        query = f"""
+        INSERT INTO {table_alertes} (Sonde, Debut_defaut, Status)
+        VALUES (%s, NOW(), 'test')
+        ON DUPLICATE KEY UPDATE Debut_defaut = NOW(), Status = 'test';
+        """
+        cursor.execute(query, (sonde,))
+        db.commit()
+        print(f"[TEST] insertion ou mise à jour réussie pour {sonde}.")
+    except Exception as e:
+        print(f"[ERREUR] lors de l'insertion test : {e}")
+
+    message = f"⚠️ TEST ALERTE : Simulation d'une alerte pour la sonde {sonde}."
+    url = f"https://api.telegram.org/bot{token}/sendMessage"
+    try:
+        requests.get(url, params={'chat_id': chat_id, 'text': message})
+    except Exception as e:
+        print(f"[ERREUR] lors de l'envoi Telegram : {e}")
+
+def create_alert(db, cursor, table_alertes, sonde, temperature):
+    query = f"""
+    INSERT INTO {table_alertes} (Sonde, Debut_defaut, Status) 
+    VALUES (%s, NOW(), 'en cours');
+    """
+    cursor.execute(query, (sonde,))
+    send_telegram_message(sonde, temperature)
+    print(f"Alerte créée pour la sonde {sonde}")
+    db.commit()
+
+def resolve_alert(cursor, table_alertes, sonde):
+    query = f"""
+    UPDATE {table_alertes}
+    SET Status = 'résolu' 
+    WHERE Sonde = %s AND Status = 'en cours';
+    """
+    cursor.execute(query, (sonde,))
+    print(f"Alerte résolue pour la sonde {sonde}")
+
+def acquitter_alerte(cursor, site, sonde, chat_id, token):
+    table_alertes = f"Alertes_{site}"
+    query = f"""
+    UPDATE {table_alertes}
+    SET Status = 'acquittée'
+    WHERE Sonde = %s AND Status IN ('en cours', 'test');
+    """
+    cursor.execute(query, (sonde,))
+    lignes_modifiees = cursor.rowcount
+
+    if lignes_modifiees > 0:
+        message = f"✅ Alerte acquittée pour la sonde {sonde} par commande Telegram."
+    else:
+        message = f"ℹ️ Aucune alerte active à acquitter pour la sonde {sonde}."
+
+    url = f"https://api.telegram.org/bot{token}/sendMessage"
+    try:
+        requests.get(url, params={'chat_id': chat_id, 'text': message})
+    except Exception as e:
+        print(f"[ERREUR] envoi message Telegram : {e}")
+
+def send_telegram_message(sonde, temperature):
+    token = "5714323406:AAGSj9jrfBHbfxubz3ooabPEizI8aBOLnvE"
+    chat_id = "-1002442631825"
+    message = f"⚠️ Alerte température : La sonde {sonde} dépasse la limite avec une température de {temperature}°C."
+    url = f"https://api.telegram.org/bot{token}/sendMessage"
+    params = {'chat_id': chat_id, 'text': message}
+    try:
+        response = requests.get(url, params=params)
+        if response.status_code == 200:
+            print(f"Message envoyé via Telegram pour la sonde {sonde}.")
+        else:
+            print(f"Erreur lors de l'envoi du message Telegram : {response.status_code}")
+    except Exception as e:
+        print(f"Erreur lors de l'envoi du message Telegram : {e}")
+
+
+def get_chat_id(cursor, site):
+    cursor.execute("SELECT Chat_ID FROM Sites WHERE Nom = %s;", (site,))
+    result = cursor.fetchone()
+    if result:
+        return result[0]
+    else:
+        print(f"Aucun Chat_ID trouvé pour le site {site}")
+        return None
+
+def passer_en_maintenance(cursor, site, sonde, chat_id, token):
+    try:
+        query = """
+        UPDATE Chambres_froides
+        SET Etat = 'Off'
+        WHERE Lieu = %s AND Sonde = %s;
+        """
+        cursor.execute(query, (site, sonde))
+        lignes_modifiees = cursor.rowcount
+
+        if lignes_modifiees > 0:
+            message = f"🛠️ La sonde {sonde} a été passée en mode maintenance (OFF)."
+        else:
+            message = f"⚠️ Sonde {sonde} introuvable pour le site {site}."
+
+        url = f"https://api.telegram.org/bot{token}/sendMessage"
+        requests.get(url, params={'chat_id': chat_id, 'text': message})
+
+    except Exception as e:
+        print(f"[ERREUR] lors du passage en maintenance : {e}")
+
+def reactiver_sonde(cursor, site, sonde, chat_id, token):
+    try:
+        query = """
+        UPDATE Chambres_froides
+        SET Etat = 'On'
+        WHERE Lieu = %s AND Sonde = %s;
+        """
+        cursor.execute(query, (site, sonde))
+        lignes_modifiees = cursor.rowcount
+
+        if lignes_modifiees > 0:
+            message = f"✅ La sonde {sonde} a été réactivée (ON)."
+        else:
+            message = f"⚠️ Sonde {sonde} introuvable pour le site {site}."
+
+        url = f"https://api.telegram.org/bot{token}/sendMessage"
+        requests.get(url, params={'chat_id': chat_id, 'text': message})
+
+    except Exception as e:
+        print(f"[ERREUR] lors de la réactivation : {e}")
+
+def etat_sondes(cursor, site, chat_id, token):
+    query = "SELECT Sonde, Etat FROM Chambres_froides WHERE Lieu = %s ORDER BY Sonde;"
+    cursor.execute(query, (site,))
+    result = cursor.fetchall()
+
+    message = f"📊 État des sondes - {site} :\n"
+    for sonde, etat in result:
+        symbole = "🟢" if etat.upper() == "ON" else "🔴"
+        message += f"{symbole} {sonde} ({etat.upper()})\n"
+
+    url = f"https://api.telegram.org/bot{token}/sendMessage"
+    requests.get(url, params={'chat_id': chat_id, 'text': message})
+
+def monitor_temperatures_simple(site, db, cursor):
+    table_historique = site
+    table_alertes = f"Alertes_{site}"
+    sondes = get_active_sondes(cursor, site)
+    print(f"[MONITORING] Sondes actives pour {site} : {sondes}")
+
+    for sonde, limite in sondes.items():
+        alert_needed, temperature = check_temperature_limits(cursor, table_historique, sonde, limite)
+        if alert_needed:
+            create_alert(db, cursor, table_alertes, sonde, temperature)
+        else:
+            resolve_alert(cursor, table_alertes, sonde)
+
+    db.commit()
+    print("[MONITORING] Vérification des sondes terminée.")
+
+def monitor_temperatures(site):
+    db = connect_db()
+    cursor = db.cursor()
+
+    table_historique = site  # Ex: Saclay
+    table_alertes = f"Alertes_{site}"  # Ex: Alertes_Saclay
+
+    sondes = get_active_sondes(cursor, site)
+    print(f"Sondes actives pour le site {site} :", sondes)
+
+    for sonde, limite in sondes.items():
+        alert_needed, temperature = check_temperature_limits(cursor, table_historique, sonde, limite)
+        if alert_needed:
+            create_alert(db, cursor, table_alertes, sonde, temperature)
+        else:
+            resolve_alert(cursor, table_alertes, sonde)
+
+    db.commit()
+    listen_for_commands(db, cursor, site)
+    cursor.close()
+    db.close()
+
+def listen_for_commands(db, cursor, site):
+    token = "5714323406:AAGSj9jrfBHbfxubz3ooabPEizI8aBOLnvE"
+    chat_id = get_chat_id(cursor, site)
+    offset_file = os.path.join(os.path.dirname(__file__), f"last_update_id_{site}.txt")
+
+    try:
+        with open(offset_file, 'r') as f:
+            last_update_id = int(f.read().strip())
+    except FileNotFoundError:
+        last_update_id = None
+
+    url = f"https://api.telegram.org/bot{token}/getUpdates"
+    if last_update_id is not None:
+        url += f"?offset={last_update_id + 1}"
+
+    try:
+        response = requests.get(url)
+        data = response.json()
+
+        if "result" in data:
+            for update in data["result"]:
+                update_id = update["update_id"]
+
+                if "message" in update:
+                    message = update["message"]["text"]
+                    print(f"[CMD] Message reçu : {message}")
+
+                    if message.lower().startswith("/etat"):
+                        etat_sondes(cursor, site, chat_id, token)
+
+                    elif message.lower().startswith("/acquitter"):
+                        parts = message.strip().split(" ", 1)
+                        if len(parts) == 2 and parts[1].strip():
+                            sonde = parts[1].strip()
+                            acquitter_alerte(cursor, site, sonde, chat_id, token)
+                            db.commit()
+                        else:
+                            erreur_msg = "❌ Utilisation incorrecte. Format attendu : /acquitter <nom_sonde>"
+                            requests.get(f"https://api.telegram.org/bot{token}/sendMessage",
+                                         params={'chat_id': chat_id, 'text': erreur_msg})
+                    elif message.lower().startswith("/maintenance"):
+                        parts = message.strip().split(" ", 1)
+                        if len(parts) == 2 and parts[1].strip():
+                            sonde = parts[1].strip()
+                            passer_en_maintenance(cursor, site, sonde, chat_id, token)
+                            db.commit()
+                        else:
+                            erreur_msg = "❌ Utilisation incorrecte. Format attendu : /maintenance <nom_sonde>"
+                            requests.get(f"https://api.telegram.org/bot{token}/sendMessage",
+                                         params={'chat_id': chat_id, 'text': erreur_msg})
+                    elif message.lower().startswith("/reactiver"):
+                        parts = message.strip().split(" ", 1)
+                        if len(parts) == 2 and parts[1].strip():
+                            sonde = parts[1].strip()
+                            reactiver_sonde(cursor, site, sonde, chat_id, token)
+                            db.commit()
+                        else:
+                            erreur_msg = "❌ Utilisation incorrecte. Format attendu : /reactiver <nom_sonde>"
+                            requests.get(f"https://api.telegram.org/bot{token}/sendMessage",
+                                         params={'chat_id': chat_id, 'text': erreur_msg})
+                    elif message.lower().startswith("/test"):
+                        parts = message.strip().split(" ", 1)
+                        if len(parts) == 2 and parts[1].strip():
+                            sonde = parts[1].strip()
+                            simulate_alert(db, cursor, site, sonde, chat_id, token)
+                        else:
+                            erreur_msg = "❌ Utilisation incorrecte. Format attendu : /test <nom_sonde>"
+                            requests.get(f"https://api.telegram.org/bot{token}/sendMessage",
+                                         params={'chat_id': chat_id, 'text': erreur_msg})
+
+                with open(offset_file, 'w') as f:
+                    f.write(str(update_id))
+
+    except Exception as e:
+        print(f"Erreur lors de la lecture des commandes Telegram : {e}")
+
+
+def main():
+    site = sys.argv[1] if len(sys.argv) > 1 else "Saclay"
+    db = connect_db()
+    cursor = db.cursor()
+
+    # ✅ Planification : tous les jours à 07:00 → état des sondes
+    schedule.every().day.at("07:00").do(envoi_etat_quotidien, cursor=cursor, site=site)
+
+    # ✅ Planification : toutes les 2m30 → surveillance
+    schedule.every(2).minutes.do(monitor_temperatures_simple, site=site, db=db, cursor=cursor)
+
+    try:
+        while True:
+            schedule.run_pending()
+            listen_for_commands(db, cursor, site)
+            time.sleep(2)  # petite pause pour ne pas surcharger Telegram
+    finally:
+        cursor.close()
+        db.close()
+
+if __name__ == "__main__":
+    main()
diff --git a/Fichiers restaurés/Test_mail.py b/Fichiers restaurés/Test_mail.py
new file mode 100644
index 0000000..7a37988
--- /dev/null
+++ b/Fichiers restaurés/Test_mail.py	
@@ -0,0 +1,24 @@
+# Programme de test de la BAL alertes_saclay@domo91.fr.
+import smtplib
+from email.mime.text import MIMEText
+
+def envoyer_mail(sujet, message, destinataires):
+    msg = MIMEText(message)
+    msg['Subject'] = sujet
+    msg['From'] = 'alertes_saclay@domo91.fr'
+    msg['To'] = ', '.join(destinataires)
+
+    try:
+        with smtplib.SMTP_SSL('smtp.mail.ovh.net', 465) as server:
+            server.login('alertes_saclay@domo91.fr', 'Kdpke674y23Feq^H')
+            server.sendmail(msg['From'], destinataires, msg.as_string())
+            print(f"📧 Mail envoyé à {destinataires}")
+    except Exception as e:
+        print(f"Erreur envoi mail : {e}")
+
+# --- Test d'envoi ---
+envoyer_mail(
+    sujet="🧪 Test d'envoi d'alerte",
+    message="Ceci est un test de l'envoi d'e-mail via alertes_saclay@domo91.fr.",
+    destinataires=["services@domo91.fr"]
+)
diff --git a/Fichiers restaurés/Tracker.py b/Fichiers restaurés/Tracker.py
new file mode 100644
index 0000000..6d47f1f
--- /dev/null
+++ b/Fichiers restaurés/Tracker.py	
@@ -0,0 +1,106 @@
+# Programme de récupération des adresses de sondes DS18B20 et envoie dans table Sondes.Tracker.
+import paho.mqtt.client as mqtt
+import mysql.connector
+import re  # Import de la bibliothèque des expressions régulières
+
+# Configuration de la base de données MySQL
+db_config = {
+    'user': 'superviseur',  # Remplacez par votre utilisateur MySQL
+    'password': 'Bto7Lm_z]m!BFH!*',  # Remplacez par votre mot de passe MySQL
+    'host': '54.36.188.119',  # Adresse de votre serveur MySQL (localhost si en local)
+    'database': 'Sondes'  # Nom de la base de données MySQL
+}
+
+
+def convertir_rom_id_en_hexa(rom_id):
+    # On découpe la chaîne rom_id en paires de deux caractères
+    hex_parts = [f"0x{rom_id[i:i + 2]}" for i in range(0, len(rom_id), 2)]
+    return ",".join(hex_parts)
+
+
+# Connexion à la base de données MySQL
+def connect_db():
+    return mysql.connector.connect(**db_config)
+
+
+# Fonction pour vérifier si la sonde est déjà présente dans la base
+def sonde_deja_presente(rom_id):
+    conn = connect_db()
+    cursor = conn.cursor()
+    try:
+        # Vérifier si la sonde existe déjà dans la base
+        cursor.execute("SELECT COUNT(*) FROM Tracker WHERE rom_id = %s", (rom_id,))
+        result = cursor.fetchone()
+        return result[0] > 0  # Si le nombre est supérieur à 0, la sonde est déjà présente
+
+    except mysql.connector.Error as err:
+        print(f"Erreur MySQL lors de la vérification de la sonde : {err}")
+        return False
+
+    finally:
+        cursor.close()
+        conn.close()
+
+
+# Fonction pour insérer les sondes dans la base de données
+def inserer_sonde(rom_id):
+    if sonde_deja_presente(rom_id):
+        print(f"Sonde {rom_id} déjà présente dans la base de données. Aucune insertion effectuée.")
+        return
+
+    conn = connect_db()
+    cursor = conn.cursor()
+    try:
+        # Conversion en hexadécimal
+        rom_id_hexa = convertir_rom_id_en_hexa(rom_id)
+
+        # Insertion de rom_id et de sa version hexa dans la base
+        cursor.execute("INSERT INTO Tracker (rom_id, hexa) VALUES (%s, %s)", (rom_id, rom_id_hexa))
+        conn.commit()
+        print(f"Sonde {rom_id} insérée dans la base de données avec son format hexa {rom_id_hexa}.")
+
+    except mysql.connector.Error as err:
+        print(f"Erreur MySQL : {err}")
+
+    finally:
+        cursor.close()
+        conn.close()
+
+
+# Fonction de callback pour gérer les messages MQTT
+def on_message(_client, _userdata, message):
+    payload = message.payload.decode()
+    print(f"Message reçu : {payload}")
+
+    # Utilisation de re pour extraire les ROM IDs (Sonde [rom_id])
+    rom_ids = re.findall(r"[0-9a-fA-F]{16}", payload)  # Capturer les IDs de 16 caractères
+    if rom_ids:
+        for rom_id in rom_ids:
+            inserer_sonde(rom_id)
+    else:
+        print("Aucun ROM ID trouvé dans le message.")
+
+
+# Configuration du client MQTT
+mqtt_broker = "46.105.92.116"
+mqtt_port = 1883  # Vérifiez si votre broker utilise un autre port
+mqtt_user = "Bwps"
+mqtt_password = "scJ5ACj2keRfI^"
+mqtt_topic = "Tracker/sondes"
+
+client = mqtt.Client()
+
+# Authentification MQTT
+client.username_pw_set(mqtt_user, mqtt_password)
+
+# Configuration du callback pour les messages MQTT
+client.on_message = on_message
+
+# Connexion au broker MQTT
+client.connect(mqtt_broker, mqtt_port, 60)
+
+# Souscription au topic Tracker/sondes
+client.subscribe(mqtt_topic)
+
+# Démarrer la boucle MQTT
+client.loop_forever()
diff --git a/Fichiers restaurés/logs_analyse.py b/Fichiers restaurés/logs_analyse.py
new file mode 100644
index 0000000..5630e30
--- /dev/null
+++ b/Fichiers restaurés/logs_analyse.py	
@@ -0,0 +1,39 @@
+import streamlit as st
+import pandas as pd
+import matplotlib.pyplot as plt
+
+# --- Chargement des données ---
+try:
+    df = pd.read_csv("/home/debian/travail/logs_monitor.csv", sep=";", parse_dates=["Date"])
+except FileNotFoundError:
+    st.error("📂 Le fichier de log n'a pas été trouvé.")
+    st.stop()
+
+st.title("🧾 Analyse des scans Monitor.py")
+
+# --- Filtres ---
+df["Date_str"] = df["Date"].dt.date
+dates_dispo = sorted(df["Date_str"].unique(), reverse=True)
+date_selection = st.selectbox("📅 Sélectionnez une date :", dates_dispo)
+
+lieux = sorted(df["Lieu"].unique())
+lieu_selection = st.selectbox("📍 Site :", lieux)
+
+df_filtré = df[(df["Date_str"] == date_selection) & (df["Lieu"] == lieu_selection)]
+
+sondes = sorted(df_filtré["Sonde"].unique())
+sonde_selection = st.selectbox("🧪 Sonde :", sondes)
+
+df_sonde = df_filtré[df_filtré["Sonde"] == sonde_selection]
+
+# --- Graphique température ---
+fig, ax = plt.subplots(figsize=(10, 4))
+ax.plot(df_sonde["Date"], df_sonde["Température"], marker='o')
+ax.set_title(f"Évolution de la température - {sonde_selection}")
+ax.set_xlabel("Heure")
+ax.set_ylabel("Température (°C)")
+st.pyplot(fig)
+
+# --- Tableau complet du jour/sonde sélectionnés ---
+st.markdown("### 📋 Détail des scans")
+st.dataframe(df_sonde[["Date", "Sonde", "Température", "Seuil", "État"]], use_container_width=True)
diff --git a/Fichiers restaurés/supervisor_watchdog.py b/Fichiers restaurés/supervisor_watchdog.py
new file mode 100644
index 0000000..76a7834
--- /dev/null
+++ b/Fichiers restaurés/supervisor_watchdog.py	
@@ -0,0 +1,47 @@
+# Controle des services supervisor envoi en cas de disfonction et tous les jours à sept heures
+# a faire tourner avec crontb -e en sudo
+#   */30 * * * * /home/debian/travail/myenv/bin/python3 /home/debian/travail/Scripts/supervisor_watchdog.py
+import subprocess
+import smtplib
+from email.mime.text import MIMEText
+from datetime import datetime
+
+heure_actuelle = datetime.now().strftime("%H:%M")
+etat_services = []
+anomalies = []
+
+try:
+    output = subprocess.check_output("/usr/bin/supervisorctl status", shell=True, text=True)
+    for line in output.splitlines():
+        parts = line.split()
+        if len(parts) >= 2:
+            nom, statut = parts[0], parts[1]
+            etat_services.append(f"{nom} ➤ {statut}")
+            if statut != "RUNNING":
+                anomalies.append(f"{nom} ➤ {statut}")
+except Exception as e:
+    etat_services.append("❌ Impossible d'exécuter supervisorctl")
+    anomalies.append(f"Erreur : {e}")
+
+# Déclenchement mail si anomalie ou à 07:00
+envoyer_mail = bool(anomalies) or heure_actuelle == "07:00"
+
+if envoyer_mail:
+    sujet = "⚠️ Alerte Supervisor" if anomalies else "✅ Rapport quotidien Supervisor"
+    intro = "🛑 Les services suivants ne sont pas en RUNNING :" if anomalies else "✅ Tous les services supervisés sont en RUNNING."
+    contenu = f"{intro}\n\n" + "\n".join(etat_services)
+
+    msg = MIMEText(contenu)
+    msg["Subject"] = sujet
+    msg["From"] = "alertes_saclay@domo91.fr"
+    msg["To"] = "services@domo91.fr"
+
+    try:
+        with smtplib.SMTP_SSL("smtp.mail.ovh.net", 465) as server:
+            server.login("alertes_saclay@domo91.fr", "Kdpke674y23Feq^H")
+            server.sendmail(msg["From"], [msg["To"]], msg.as_string())
+            print("📧 Mail envoyé.")
+    except Exception as e:
+        print(f"Erreur envoi mail : {e}")
+else:
+    print("🕖 Aucun mail envoyé (tout est OK et ce n’est pas l’heure du rapport).")
diff --git a/Purge_Alertes_saclay.py b/Purge_Alertes_saclay.py
new file mode 100644
index 0000000..83f89e2
--- /dev/null
+++ b/Purge_Alertes_saclay.py
@@ -0,0 +1,18 @@
+# Purge de la table Sondes.Alertes_Saclay.
+import mysql.connector
+
+config = {
+    "host": "54.36.188.119",
+    "user": "michel",
+    "password": "#SO2&1nf%mZ@jfh",
+    "database": "Sondes"
+}
+
+conn = mysql.connector.connect(**config)
+cursor = conn.cursor()
+cursor.execute("DELETE FROM Alertes_Saclay WHERE Debut_defaut < NOW() - INTERVAL 7 DAY")
+conn.commit()
+cursor.close()
+conn.close()
+
+print("✅ Alertes de plus de 7 jours supprimées.")
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..d91c980
--- /dev/null
+++ b/README.md
@@ -0,0 +1,52 @@
+# 🌡️ Gestion des sondes domotiques
+
+[![Version Python](https://img.shields.io/badge/Python-3.10-blue)](https://python.org)
+[![Licence](https://img.shields.io/badge/Licence-Propriétaire-orange)](https://mj91.fr:448/michel/Gestion_sondes)
+[![Gitea](https://img.shields.io/badge/Gitea-auto--hébergé-green)](https://mj91.fr:448)
+
+Application de **surveillance des températures** avec alertes, visualisation Streamlit, et déploiement automatisé via Gitea + Supervisor.
+
+---
+
+## 🧩 Fonctionnalités principales
+
+- 🔍 Lecture de capteurs **DS18B20** et **DHT22**
+- 📨 Transmission via **MQTT**
+- 📊 Interface **Streamlit** (app.domo91.fr)
+- 🔔 Alertes **email / Telegram** si dépassement > 30 minutes
+- 🧠 Déploiement auto avec **`deploy.sh`**
+- 🧾 Stockage SQL sur **MySQL (VPS)**
+
+---
+
+## 📊 Exemple de visualisation
+
+Voici un aperçu d’un graphique dans l’interface Streamlit :
+
+![Exemple de graphique Streamlit](https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Matplotlib_figure.svg/800px-Matplotlib_figure.svg.png)
+
+---
+
+## 🗂️ Structure du projet
+
+| Fichier                      | Description                                                        |
+|-----------------------------|---------------------------------------------------------------------|
+| `Monitor.py`                | Analyse de température et alertes                                 |
+| `Streamlit.py`              | Interface graphique web                                           |
+| `Cuisine_saclay.py`         | Script capteur pour le site de Saclay                            |
+| `Cuisine_meudon.py`         | Script capteur pour Meudon                                        |
+| `check_supervisor.py`       | Vérifie l’état des scripts supervisés                            |
+| `deploy.sh`                 | Déploiement auto depuis Gitea (branche `product`)                 |
+| `requirements.txt`          | Dépendances Python                                                |
+
+---
+
+## 🧪 Installation locale
+
+```bash
+git clone https://mj91.fr:448/michel/Gestion_sondes.git
+cd Gestion_sondes
+python -m venv .venv
+source .venv/bin/activate  # Linux/macOS
+.venv\Scripts\activate     # Windows
+pip install -r requirements.txt
diff --git a/Societe_Generale.py b/Societe_Generale.py
new file mode 100644
index 0000000..88c100c
--- /dev/null
+++ b/Societe_Generale.py
@@ -0,0 +1,107 @@
+# Insertion de données da l'app SG.
+import streamlit as st
+import mysql.connector
+from dotenv import load_dotenv
+import os
+from datetime import datetime
+
+load_dotenv()
+
+st.set_page_config(page_title="Insertion Mysql", layout="centered")
+st.title("🗓️ Insertion dans une base MySQL")
+
+# Charger les identifiants
+DB_HOST = os.getenv("DB_HOST")
+DB_USER = os.getenv("DB_USER")
+DB_PASSWORD = os.getenv("DB_PASSWORD")
+
+# Connexion sans DB initiale pour lister les bases
+@st.cache_data
+def get_databases():
+    conn = mysql.connector.connect(
+        host=DB_HOST,
+        user=DB_USER,
+        password=DB_PASSWORD
+    )
+    cursor = conn.cursor()
+    cursor.execute("SHOW DATABASES")
+    bases = [db[0] for db in cursor.fetchall()]
+    conn.close()
+    return bases
+
+# Connexion avec DB sélectionnée
+def connect_to_db(db_name):
+    return mysql.connector.connect(
+        host=DB_HOST,
+        user=DB_USER,
+        password=DB_PASSWORD,
+        database=db_name
+    )
+
+# --- Interface principale ---
+
+base = st.selectbox("Choisir une base de données", get_databases())
+if base:
+    conn = connect_to_db(base)
+    cursor = conn.cursor()
+
+    cursor.execute("SHOW TABLES")
+    tables = [table[0] for table in cursor.fetchall()]
+    table = st.selectbox("Choisir une table", tables)
+
+    if table:
+        cursor.execute(f"DESCRIBE {table}")
+        colonnes = cursor.fetchall()
+
+        # Détection clé primaire
+        cursor.execute(f"SHOW INDEX FROM {table} WHERE Key_name = 'PRIMARY'")
+        pk = cursor.fetchone()
+        primary_key = pk[4] if pk else None
+
+        champ_date_candidates = [col[0] for col in colonnes if "date" in col[1].lower()]
+        champ_date = st.selectbox("Champ de date", champ_date_candidates)
+
+        nb_mois = st.number_input("Nombre d'insertions mensuelles", 1, 36, 6)
+        date_depart = st.date_input("Date de départ des insertions", value=datetime.today().date())
+        st.subheader("Champs à insérer (hors clé primaire et champ de date)")
+        champs_choisis = []
+        champs_editables = [col for col in colonnes if col[0] != primary_key and col[0] != champ_date]
+        for col in champs_editables:
+            if st.checkbox(f"{col[0]} ({col[1]})", value=True):
+                champs_choisis.append(col[0])
+
+        with st.form("formulaire_insertion"):
+            st.markdown("**Valeurs fixes pour les champs cochés**")
+            valeurs_fixes = {}
+            for nom in champs_choisis:
+                val = st.text_input(nom)
+                valeurs_fixes[nom] = val if val != "" else None
+
+            submit = st.form_submit_button("Insérer")
+
+            try:
+                cursor = conn.cursor()
+                insert_count = 0
+
+                for i in range(nb_mois):
+                    year = date_depart.year + (date_depart.month + i - 1) // 12
+                    month = (date_depart.month + i - 1) % 12 + 1
+                    day = min(date_depart.day, 28)
+                    date_cible = datetime(year, month, day).date()
+
+                    champs = [champ_date] + list(valeurs_fixes.keys())
+                    valeurs = [date_cible] + list(valeurs_fixes.values())
+                    sql = f"INSERT INTO {table} ({', '.join(champs)}) VALUES ({', '.join(['%s'] * len(valeurs))})"
+
+                    cursor.execute(sql, valeurs)
+                    insert_count += 1
+
+                conn.commit()
+                st.success(f"{insert_count} lignes insérées avec succès dans `{table}`.")
+
+            except Exception as e:
+                st.error(f"❌ Erreur lors de l’insertion : {e}")
+
+                conn.commit()
+                st.success(f"{insert_count} lignes insérées avec succès dans `{table}`.")
+st.success(f"{insert_count} lignes insérées avec succès.")
\ No newline at end of file
diff --git a/Telegram_sondes.py b/Telegram_sondes.py
new file mode 100644
index 0000000..3077d92
--- /dev/null
+++ b/Telegram_sondes.py
@@ -0,0 +1,324 @@
+# Gestion des chambres froides & alertes Telegram
+import requests
+import mysql.connector
+from datetime import datetime, timedelta
+import time
+import sys
+import os
+import schedule
+
+def connect_db():
+    return mysql.connector.connect(
+        host="54.36.188.119",
+        user="michel",
+        password="#SO2&1nf%mZ@jfh",
+        database="Sondes"
+    )
+
+def envoi_etat_quotidien(cursor, site):
+    token = "8128378340:AAF2sO3gaH1XpMNya_pEslzerqokoCiFRGs"
+    chat_id = get_chat_id(cursor, site)
+    etat_sondes(cursor, site, chat_id, token)
+    print(f"[INFO] État des sondes envoyé pour le site {site}.")
+
+def get_active_sondes(cursor, site):
+    query = "SELECT Sonde, Temp_Max FROM Chambres_froides WHERE Lieu = %s AND Etat = 'On';"
+    cursor.execute(query, (site,))
+    result = cursor.fetchall()
+    return {row[0]: float(row[1]) for row in result}
+
+
+def check_temperature_limits(cursor, table_historique, sonde, limite, duree=30):
+    temps_limite = datetime.now() - timedelta(minutes=duree)
+    query = f"""
+    SELECT Temperature 
+    FROM {table_historique}
+    WHERE Sonde = %s AND Date >= %s 
+    ORDER BY Date DESC LIMIT 6;
+    """
+    cursor.execute(query, (sonde, temps_limite))
+    result = cursor.fetchall()
+    if len(result) == 6 and all(float(temp[0]) > limite for temp in result):
+        return True, float(result[0][0])
+    return False, None
+
+def simulate_alert(db, cursor, site, sonde, chat_id, token):
+    table_alertes = f"Alertes_{site}"
+    print(f"[TEST] tentative d'insertion de sonde : {sonde} dans table {table_alertes}")
+
+    try:
+        query = f"""
+        INSERT INTO {table_alertes} (Sonde, Debut_defaut, Status)
+        VALUES (%s, NOW(), 'test')
+        ON DUPLICATE KEY UPDATE Debut_defaut = NOW(), Status = 'test';
+        """
+        cursor.execute(query, (sonde,))
+        db.commit()
+        print(f"[TEST] insertion ou mise à jour réussie pour {sonde}.")
+    except Exception as e:
+        print(f"[ERREUR] lors de l'insertion test : {e}")
+
+    message = f"⚠️ TEST ALERTE : Simulation d'une alerte pour la sonde {sonde}."
+    url = f"https://api.telegram.org/bot{token}/sendMessage"
+    try:
+        requests.get(url, params={'chat_id': chat_id, 'text': message})
+    except Exception as e:
+        print(f"[ERREUR] lors de l'envoi Telegram : {e}")
+
+def create_alert(db, cursor, table_alertes, sonde, temperature):
+    query = f"""
+    INSERT INTO {table_alertes} (Sonde, Debut_defaut, Status) 
+    VALUES (%s, NOW(), 'en cours');
+    """
+    cursor.execute(query, (sonde,))
+    send_telegram_message(sonde, temperature)
+    print(f"Alerte créée pour la sonde {sonde}")
+    db.commit()
+
+def resolve_alert(cursor, table_alertes, sonde):
+    query = f"""
+    UPDATE {table_alertes}
+    SET Status = 'résolu' 
+    WHERE Sonde = %s AND Status = 'en cours';
+    """
+    cursor.execute(query, (sonde,))
+    print(f"Alerte résolue pour la sonde {sonde}")
+
+def acquitter_alerte(cursor, site, sonde, chat_id, token):
+    table_alertes = f"Alertes_{site}"
+    query = f"""
+    UPDATE {table_alertes}
+    SET Status = 'acquittée'
+    WHERE Sonde = %s AND Status IN ('en cours', 'test');
+    """
+    cursor.execute(query, (sonde,))
+    lignes_modifiees = cursor.rowcount
+
+    if lignes_modifiees > 0:
+        message = f"✅ Alerte acquittée pour la sonde {sonde} par commande Telegram."
+    else:
+        message = f"ℹ️ Aucune alerte active à acquitter pour la sonde {sonde}."
+
+    url = f"https://api.telegram.org/bot{token}/sendMessage"
+    try:
+        requests.get(url, params={'chat_id': chat_id, 'text': message})
+    except Exception as e:
+        print(f"[ERREUR] envoi message Telegram : {e}")
+
+def send_telegram_message(sonde, temperature):
+    token = "5714323406:AAGSj9jrfBHbfxubz3ooabPEizI8aBOLnvE"
+    chat_id = "-1002442631825"
+    message = f"⚠️ Alerte température : La sonde {sonde} dépasse la limite avec une température de {temperature}°C."
+    url = f"https://api.telegram.org/bot{token}/sendMessage"
+    params = {'chat_id': chat_id, 'text': message}
+    try:
+        response = requests.get(url, params=params)
+        if response.status_code == 200:
+            print(f"Message envoyé via Telegram pour la sonde {sonde}.")
+        else:
+            print(f"Erreur lors de l'envoi du message Telegram : {response.status_code}")
+    except Exception as e:
+        print(f"Erreur lors de l'envoi du message Telegram : {e}")
+
+
+def get_chat_id(cursor, site):
+    cursor.execute("SELECT Chat_ID FROM Sites WHERE Nom = %s;", (site,))
+    result = cursor.fetchone()
+    if result:
+        return result[0]
+    else:
+        print(f"Aucun Chat_ID trouvé pour le site {site}")
+        return None
+
+def passer_en_maintenance(cursor, site, sonde, chat_id, token):
+    try:
+        query = """
+        UPDATE Chambres_froides
+        SET Etat = 'Off'
+        WHERE Lieu = %s AND Sonde = %s;
+        """
+        cursor.execute(query, (site, sonde))
+        lignes_modifiees = cursor.rowcount
+
+        if lignes_modifiees > 0:
+            message = f"🛠️ La sonde {sonde} a été passée en mode maintenance (OFF)."
+        else:
+            message = f"⚠️ Sonde {sonde} introuvable pour le site {site}."
+
+        url = f"https://api.telegram.org/bot{token}/sendMessage"
+        requests.get(url, params={'chat_id': chat_id, 'text': message})
+
+    except Exception as e:
+        print(f"[ERREUR] lors du passage en maintenance : {e}")
+
+def reactiver_sonde(cursor, site, sonde, chat_id, token):
+    try:
+        query = """
+        UPDATE Chambres_froides
+        SET Etat = 'On'
+        WHERE Lieu = %s AND Sonde = %s;
+        """
+        cursor.execute(query, (site, sonde))
+        lignes_modifiees = cursor.rowcount
+
+        if lignes_modifiees > 0:
+            message = f"✅ La sonde {sonde} a été réactivée (ON)."
+        else:
+            message = f"⚠️ Sonde {sonde} introuvable pour le site {site}."
+
+        url = f"https://api.telegram.org/bot{token}/sendMessage"
+        requests.get(url, params={'chat_id': chat_id, 'text': message})
+
+    except Exception as e:
+        print(f"[ERREUR] lors de la réactivation : {e}")
+
+def etat_sondes(cursor, site, chat_id, token):
+    query = "SELECT Sonde, Etat FROM Chambres_froides WHERE Lieu = %s ORDER BY Sonde;"
+    cursor.execute(query, (site,))
+    result = cursor.fetchall()
+
+    message = f"📊 État des sondes - {site} :\n"
+    for sonde, etat in result:
+        symbole = "🟢" if etat.upper() == "ON" else "🔴"
+        message += f"{symbole} {sonde} ({etat.upper()})\n"
+
+    url = f"https://api.telegram.org/bot{token}/sendMessage"
+    requests.get(url, params={'chat_id': chat_id, 'text': message})
+
+def monitor_temperatures_simple(site, db, cursor):
+    table_historique = site
+    table_alertes = f"Alertes_{site}"
+    sondes = get_active_sondes(cursor, site)
+    print(f"[MONITORING] Sondes actives pour {site} : {sondes}")
+
+    for sonde, limite in sondes.items():
+        alert_needed, temperature = check_temperature_limits(cursor, table_historique, sonde, limite)
+        if alert_needed:
+            create_alert(db, cursor, table_alertes, sonde, temperature)
+        else:
+            resolve_alert(cursor, table_alertes, sonde)
+
+    db.commit()
+    print("[MONITORING] Vérification des sondes terminée.")
+
+def monitor_temperatures(site):
+    db = connect_db()
+    cursor = db.cursor()
+
+    table_historique = site  # Ex: Saclay
+    table_alertes = f"Alertes_{site}"  # Ex: Alertes_Saclay
+
+    sondes = get_active_sondes(cursor, site)
+    print(f"Sondes actives pour le site {site} :", sondes)
+
+    for sonde, limite in sondes.items():
+        alert_needed, temperature = check_temperature_limits(cursor, table_historique, sonde, limite)
+        if alert_needed:
+            create_alert(db, cursor, table_alertes, sonde, temperature)
+        else:
+            resolve_alert(cursor, table_alertes, sonde)
+
+    db.commit()
+    listen_for_commands(db, cursor, site)
+    cursor.close()
+    db.close()
+
+def listen_for_commands(db, cursor, site):
+    token = "5714323406:AAGSj9jrfBHbfxubz3ooabPEizI8aBOLnvE"
+    chat_id = get_chat_id(cursor, site)
+    offset_file = os.path.join(os.path.dirname(__file__), f"last_update_id_{site}.txt")
+
+    try:
+        with open(offset_file, 'r') as f:
+            last_update_id = int(f.read().strip())
+    except FileNotFoundError:
+        last_update_id = None
+
+    url = f"https://api.telegram.org/bot{token}/getUpdates"
+    if last_update_id is not None:
+        url += f"?offset={last_update_id + 1}"
+
+    try:
+        response = requests.get(url)
+        data = response.json()
+
+        if "result" in data:
+            for update in data["result"]:
+                update_id = update["update_id"]
+
+                if "message" in update:
+                    message = update["message"]["text"]
+                    print(f"[CMD] Message reçu : {message}")
+
+                    if message.lower().startswith("/etat"):
+                        etat_sondes(cursor, site, chat_id, token)
+
+                    elif message.lower().startswith("/acquitter"):
+                        parts = message.strip().split(" ", 1)
+                        if len(parts) == 2 and parts[1].strip():
+                            sonde = parts[1].strip()
+                            acquitter_alerte(cursor, site, sonde, chat_id, token)
+                            db.commit()
+                        else:
+                            erreur_msg = "❌ Utilisation incorrecte. Format attendu : /acquitter <nom_sonde>"
+                            requests.get(f"https://api.telegram.org/bot{token}/sendMessage",
+                                         params={'chat_id': chat_id, 'text': erreur_msg})
+                    elif message.lower().startswith("/maintenance"):
+                        parts = message.strip().split(" ", 1)
+                        if len(parts) == 2 and parts[1].strip():
+                            sonde = parts[1].strip()
+                            passer_en_maintenance(cursor, site, sonde, chat_id, token)
+                            db.commit()
+                        else:
+                            erreur_msg = "❌ Utilisation incorrecte. Format attendu : /maintenance <nom_sonde>"
+                            requests.get(f"https://api.telegram.org/bot{token}/sendMessage",
+                                         params={'chat_id': chat_id, 'text': erreur_msg})
+                    elif message.lower().startswith("/reactiver"):
+                        parts = message.strip().split(" ", 1)
+                        if len(parts) == 2 and parts[1].strip():
+                            sonde = parts[1].strip()
+                            reactiver_sonde(cursor, site, sonde, chat_id, token)
+                            db.commit()
+                        else:
+                            erreur_msg = "❌ Utilisation incorrecte. Format attendu : /reactiver <nom_sonde>"
+                            requests.get(f"https://api.telegram.org/bot{token}/sendMessage",
+                                         params={'chat_id': chat_id, 'text': erreur_msg})
+                    elif message.lower().startswith("/test"):
+                        parts = message.strip().split(" ", 1)
+                        if len(parts) == 2 and parts[1].strip():
+                            sonde = parts[1].strip()
+                            simulate_alert(db, cursor, site, sonde, chat_id, token)
+                        else:
+                            erreur_msg = "❌ Utilisation incorrecte. Format attendu : /test <nom_sonde>"
+                            requests.get(f"https://api.telegram.org/bot{token}/sendMessage",
+                                         params={'chat_id': chat_id, 'text': erreur_msg})
+
+                with open(offset_file, 'w') as f:
+                    f.write(str(update_id))
+
+    except Exception as e:
+        print(f"Erreur lors de la lecture des commandes Telegram : {e}")
+
+
+def main():
+    site = sys.argv[1] if len(sys.argv) > 1 else "Saclay"
+    db = connect_db()
+    cursor = db.cursor()
+
+    # ✅ Planification : tous les jours à 07:00 → état des sondes
+    schedule.every().day.at("07:00").do(envoi_etat_quotidien, cursor=cursor, site=site)
+
+    # ✅ Planification : toutes les 2m30 → surveillance
+    schedule.every(2).minutes.do(monitor_temperatures_simple, site=site, db=db, cursor=cursor)
+
+    try:
+        while True:
+            schedule.run_pending()
+            listen_for_commands(db, cursor, site)
+            time.sleep(2)  # petite pause pour ne pas surcharger Telegram
+    finally:
+        cursor.close()
+        db.close()
+
+if __name__ == "__main__":
+    main()
diff --git a/Test_mail.py b/Test_mail.py
new file mode 100644
index 0000000..7a37988
--- /dev/null
+++ b/Test_mail.py
@@ -0,0 +1,24 @@
+# Programme de test de la BAL alertes_saclay@domo91.fr.
+import smtplib
+from email.mime.text import MIMEText
+
+def envoyer_mail(sujet, message, destinataires):
+    msg = MIMEText(message)
+    msg['Subject'] = sujet
+    msg['From'] = 'alertes_saclay@domo91.fr'
+    msg['To'] = ', '.join(destinataires)
+
+    try:
+        with smtplib.SMTP_SSL('smtp.mail.ovh.net', 465) as server:
+            server.login('alertes_saclay@domo91.fr', 'Kdpke674y23Feq^H')
+            server.sendmail(msg['From'], destinataires, msg.as_string())
+            print(f"📧 Mail envoyé à {destinataires}")
+    except Exception as e:
+        print(f"Erreur envoi mail : {e}")
+
+# --- Test d'envoi ---
+envoyer_mail(
+    sujet="🧪 Test d'envoi d'alerte",
+    message="Ceci est un test de l'envoi d'e-mail via alertes_saclay@domo91.fr.",
+    destinataires=["services@domo91.fr"]
+)
diff --git a/Tracker.py b/Tracker.py
new file mode 100644
index 0000000..6d47f1f
--- /dev/null
+++ b/Tracker.py
@@ -0,0 +1,106 @@
+# Programme de récupération des adresses de sondes DS18B20 et envoie dans table Sondes.Tracker.
+import paho.mqtt.client as mqtt
+import mysql.connector
+import re  # Import de la bibliothèque des expressions régulières
+
+# Configuration de la base de données MySQL
+db_config = {
+    'user': 'superviseur',  # Remplacez par votre utilisateur MySQL
+    'password': 'Bto7Lm_z]m!BFH!*',  # Remplacez par votre mot de passe MySQL
+    'host': '54.36.188.119',  # Adresse de votre serveur MySQL (localhost si en local)
+    'database': 'Sondes'  # Nom de la base de données MySQL
+}
+
+
+def convertir_rom_id_en_hexa(rom_id):
+    # On découpe la chaîne rom_id en paires de deux caractères
+    hex_parts = [f"0x{rom_id[i:i + 2]}" for i in range(0, len(rom_id), 2)]
+    return ",".join(hex_parts)
+
+
+# Connexion à la base de données MySQL
+def connect_db():
+    return mysql.connector.connect(**db_config)
+
+
+# Fonction pour vérifier si la sonde est déjà présente dans la base
+def sonde_deja_presente(rom_id):
+    conn = connect_db()
+    cursor = conn.cursor()
+    try:
+        # Vérifier si la sonde existe déjà dans la base
+        cursor.execute("SELECT COUNT(*) FROM Tracker WHERE rom_id = %s", (rom_id,))
+        result = cursor.fetchone()
+        return result[0] > 0  # Si le nombre est supérieur à 0, la sonde est déjà présente
+
+    except mysql.connector.Error as err:
+        print(f"Erreur MySQL lors de la vérification de la sonde : {err}")
+        return False
+
+    finally:
+        cursor.close()
+        conn.close()
+
+
+# Fonction pour insérer les sondes dans la base de données
+def inserer_sonde(rom_id):
+    if sonde_deja_presente(rom_id):
+        print(f"Sonde {rom_id} déjà présente dans la base de données. Aucune insertion effectuée.")
+        return
+
+    conn = connect_db()
+    cursor = conn.cursor()
+    try:
+        # Conversion en hexadécimal
+        rom_id_hexa = convertir_rom_id_en_hexa(rom_id)
+
+        # Insertion de rom_id et de sa version hexa dans la base
+        cursor.execute("INSERT INTO Tracker (rom_id, hexa) VALUES (%s, %s)", (rom_id, rom_id_hexa))
+        conn.commit()
+        print(f"Sonde {rom_id} insérée dans la base de données avec son format hexa {rom_id_hexa}.")
+
+    except mysql.connector.Error as err:
+        print(f"Erreur MySQL : {err}")
+
+    finally:
+        cursor.close()
+        conn.close()
+
+
+# Fonction de callback pour gérer les messages MQTT
+def on_message(_client, _userdata, message):
+    payload = message.payload.decode()
+    print(f"Message reçu : {payload}")
+
+    # Utilisation de re pour extraire les ROM IDs (Sonde [rom_id])
+    rom_ids = re.findall(r"[0-9a-fA-F]{16}", payload)  # Capturer les IDs de 16 caractères
+    if rom_ids:
+        for rom_id in rom_ids:
+            inserer_sonde(rom_id)
+    else:
+        print("Aucun ROM ID trouvé dans le message.")
+
+
+# Configuration du client MQTT
+mqtt_broker = "46.105.92.116"
+mqtt_port = 1883  # Vérifiez si votre broker utilise un autre port
+mqtt_user = "Bwps"
+mqtt_password = "scJ5ACj2keRfI^"
+mqtt_topic = "Tracker/sondes"
+
+client = mqtt.Client()
+
+# Authentification MQTT
+client.username_pw_set(mqtt_user, mqtt_password)
+
+# Configuration du callback pour les messages MQTT
+client.on_message = on_message
+
+# Connexion au broker MQTT
+client.connect(mqtt_broker, mqtt_port, 60)
+
+# Souscription au topic Tracker/sondes
+client.subscribe(mqtt_topic)
+
+# Démarrer la boucle MQTT
+client.loop_forever()
diff --git a/logs_analyse.py b/logs_analyse.py
new file mode 100644
index 0000000..5630e30
--- /dev/null
+++ b/logs_analyse.py
@@ -0,0 +1,39 @@
+import streamlit as st
+import pandas as pd
+import matplotlib.pyplot as plt
+
+# --- Chargement des données ---
+try:
+    df = pd.read_csv("/home/debian/travail/logs_monitor.csv", sep=";", parse_dates=["Date"])
+except FileNotFoundError:
+    st.error("📂 Le fichier de log n'a pas été trouvé.")
+    st.stop()
+
+st.title("🧾 Analyse des scans Monitor.py")
+
+# --- Filtres ---
+df["Date_str"] = df["Date"].dt.date
+dates_dispo = sorted(df["Date_str"].unique(), reverse=True)
+date_selection = st.selectbox("📅 Sélectionnez une date :", dates_dispo)
+
+lieux = sorted(df["Lieu"].unique())
+lieu_selection = st.selectbox("📍 Site :", lieux)
+
+df_filtré = df[(df["Date_str"] == date_selection) & (df["Lieu"] == lieu_selection)]
+
+sondes = sorted(df_filtré["Sonde"].unique())
+sonde_selection = st.selectbox("🧪 Sonde :", sondes)
+
+df_sonde = df_filtré[df_filtré["Sonde"] == sonde_selection]
+
+# --- Graphique température ---
+fig, ax = plt.subplots(figsize=(10, 4))
+ax.plot(df_sonde["Date"], df_sonde["Température"], marker='o')
+ax.set_title(f"Évolution de la température - {sonde_selection}")
+ax.set_xlabel("Heure")
+ax.set_ylabel("Température (°C)")
+st.pyplot(fig)
+
+# --- Tableau complet du jour/sonde sélectionnés ---
+st.markdown("### 📋 Détail des scans")
+st.dataframe(df_sonde[["Date", "Sonde", "Température", "Seuil", "État"]], use_container_width=True)
diff --git a/supervisor_watchdog.py b/supervisor_watchdog.py
new file mode 100644
index 0000000..76a7834
--- /dev/null
+++ b/supervisor_watchdog.py
@@ -0,0 +1,47 @@
+# Controle des services supervisor envoi en cas de disfonction et tous les jours à sept heures
+# a faire tourner avec crontb -e en sudo
+#   */30 * * * * /home/debian/travail/myenv/bin/python3 /home/debian/travail/Scripts/supervisor_watchdog.py
+import subprocess
+import smtplib
+from email.mime.text import MIMEText
+from datetime import datetime
+
+heure_actuelle = datetime.now().strftime("%H:%M")
+etat_services = []
+anomalies = []
+
+try:
+    output = subprocess.check_output("/usr/bin/supervisorctl status", shell=True, text=True)
+    for line in output.splitlines():
+        parts = line.split()
+        if len(parts) >= 2:
+            nom, statut = parts[0], parts[1]
+            etat_services.append(f"{nom} ➤ {statut}")
+            if statut != "RUNNING":
+                anomalies.append(f"{nom} ➤ {statut}")
+except Exception as e:
+    etat_services.append("❌ Impossible d'exécuter supervisorctl")
+    anomalies.append(f"Erreur : {e}")
+
+# Déclenchement mail si anomalie ou à 07:00
+envoyer_mail = bool(anomalies) or heure_actuelle == "07:00"
+
+if envoyer_mail:
+    sujet = "⚠️ Alerte Supervisor" if anomalies else "✅ Rapport quotidien Supervisor"
+    intro = "🛑 Les services suivants ne sont pas en RUNNING :" if anomalies else "✅ Tous les services supervisés sont en RUNNING."
+    contenu = f"{intro}\n\n" + "\n".join(etat_services)
+
+    msg = MIMEText(contenu)
+    msg["Subject"] = sujet
+    msg["From"] = "alertes_saclay@domo91.fr"
+    msg["To"] = "services@domo91.fr"
+
+    try:
+        with smtplib.SMTP_SSL("smtp.mail.ovh.net", 465) as server:
+            server.login("alertes_saclay@domo91.fr", "Kdpke674y23Feq^H")
+            server.sendmail(msg["From"], [msg["To"]], msg.as_string())
+            print("📧 Mail envoyé.")
+    except Exception as e:
+        print(f"Erreur envoi mail : {e}")
+else:
+    print("🕖 Aucun mail envoyé (tout est OK et ce n’est pas l’heure du rapport).")

From 546c850bdaeab118f5aba21b541325b827f5a2bd Mon Sep 17 00:00:00 2001
From: Michel <michel@mj91.fr>
Date: Fri, 18 Apr 2025 08:10:39 +0200
Subject: [PATCH 03/12] =?UTF-8?q?"Ajout=20entr=C3=A9es=20au=20fichier=20Gi?=
 =?UTF-8?q?tignore"?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.gitignore b/.gitignore
index cedf7ec..1a9ae9c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -29,3 +29,4 @@ __pycache__/
 
 # 👉 Dossiers spécifiques ou essais
 essai/
+Fichiers restaurés/

From 3e0e172d35c29364e9ff47d484735b050539ab87 Mon Sep 17 00:00:00 2001
From: Michel <michel@mj91.fr>
Date: Fri, 18 Apr 2025 08:12:01 +0200
Subject: [PATCH 04/12] =?UTF-8?q?Supprimer=20Fichiers=20restaur=C3=A9s=20d?=
 =?UTF-8?q?u=20suivi=20Git?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 Fichiers restaurés/Chat-Id.py              |  36 ---
 Fichiers restaurés/Chaufferie.py           |  30 --
 Fichiers restaurés/Purge_Alertes_saclay.py |  18 --
 Fichiers restaurés/README.md               |  52 ----
 Fichiers restaurés/Societe_Generale.py     | 107 -------
 Fichiers restaurés/Telegram_sondes.py      | 324 ---------------------
 Fichiers restaurés/Test_mail.py            |  24 --
 Fichiers restaurés/Tracker.py              | 106 -------
 Fichiers restaurés/logs_analyse.py         |  39 ---
 Fichiers restaurés/supervisor_watchdog.py  |  47 ---
 10 files changed, 783 deletions(-)
 delete mode 100644 Fichiers restaurés/Chat-Id.py
 delete mode 100644 Fichiers restaurés/Chaufferie.py
 delete mode 100644 Fichiers restaurés/Purge_Alertes_saclay.py
 delete mode 100644 Fichiers restaurés/README.md
 delete mode 100644 Fichiers restaurés/Societe_Generale.py
 delete mode 100644 Fichiers restaurés/Telegram_sondes.py
 delete mode 100644 Fichiers restaurés/Test_mail.py
 delete mode 100644 Fichiers restaurés/Tracker.py
 delete mode 100644 Fichiers restaurés/logs_analyse.py
 delete mode 100644 Fichiers restaurés/supervisor_watchdog.py

diff --git a/Fichiers restaurés/Chat-Id.py b/Fichiers restaurés/Chat-Id.py
deleted file mode 100644
index a5bd401..0000000
--- a/Fichiers restaurés/Chat-Id.py	
+++ /dev/null
@@ -1,36 +0,0 @@
-import requests
-import json
-
-# Remplace par ton token de bot Telegram
-token = "8128378340:AAF2sO3gaH1XpMNya_pEslzerqokoCiFRGs"
-
-url = f"https://api.telegram.org/bot{token}/getUpdates"
-
-try:
-    response = requests.get(url)
-    data = response.json()
-
-    print("🔍 Récupération des chats Telegram récents...\n")
-
-    if "result" in data:
-        chats = set()
-
-        for update in data["result"]:
-            message = update.get("message") or update.get("edited_message")
-            if not message:
-                continue
-
-            chat = message["chat"]
-            chat_id = chat["id"]
-            chat_title = chat.get("title") or chat.get("username") or chat.get("first_name") or "Inconnu"
-
-            if chat_id not in chats:
-                chats.add(chat_id)
-                print(f"➡️  Chat : {chat_title} | ID : {chat_id}")
-
-        if not chats:
-            print("⚠️ Aucun chat trouvé. Envoie un message depuis un groupe ou une discussion avec le bot.")
-    else:
-        print("❌ Erreur : aucune donnée 'result' trouvée dans la réponse.")
-except Exception as e:
-    print(f"Erreur lors de la récupération des chats : {e}")
diff --git a/Fichiers restaurés/Chaufferie.py b/Fichiers restaurés/Chaufferie.py
deleted file mode 100644
index 73eab00..0000000
--- a/Fichiers restaurés/Chaufferie.py	
+++ /dev/null
@@ -1,30 +0,0 @@
-import paho.mqtt.client as mqtt
-import mysql.connector
-
-# Configuration de la connexion MySQL
-mydb = mysql.connector.connect(
-  host="54.36.188.119",
-  user="michel",
-  password="#SO2&1nf%mZ@jfh",
-  database="Sondes"
-)
-
-# Fonction de callback quand un message est reçu
-def on_message(_client, _userdata, msg):
-    print(f"Message reçu sur {msg.topic}: {msg.payload.decode()}")
-    cursor = mydb.cursor()
-    frigo_name = msg.topic.split('/')[-1]  # Prend la dernière partie après le "/"
-    sql = "INSERT INTO Chaufferie (Sonde, Temperature) VALUES (%s, %s)"
-    val = (frigo_name, msg.payload.decode())
-    cursor.execute(sql, val)
-    mydb.commit()
-
-# Configuration du client MQTT
-client = mqtt.Client()
-client.username_pw_set("Bwps", "scJ5ACj2keRfI^")
-client.on_message = on_message
-
-client.connect("54.36.188.119", 1883, 60)
-client.subscribe("Module_01/#")  # S'abonner à tous les topics commençant par Saclay
-
-client.loop_forever()  # Rester connecté en continu pour écouter les messages
diff --git a/Fichiers restaurés/Purge_Alertes_saclay.py b/Fichiers restaurés/Purge_Alertes_saclay.py
deleted file mode 100644
index 83f89e2..0000000
--- a/Fichiers restaurés/Purge_Alertes_saclay.py	
+++ /dev/null
@@ -1,18 +0,0 @@
-# Purge de la table Sondes.Alertes_Saclay.
-import mysql.connector
-
-config = {
-    "host": "54.36.188.119",
-    "user": "michel",
-    "password": "#SO2&1nf%mZ@jfh",
-    "database": "Sondes"
-}
-
-conn = mysql.connector.connect(**config)
-cursor = conn.cursor()
-cursor.execute("DELETE FROM Alertes_Saclay WHERE Debut_defaut < NOW() - INTERVAL 7 DAY")
-conn.commit()
-cursor.close()
-conn.close()
-
-print("✅ Alertes de plus de 7 jours supprimées.")
diff --git a/Fichiers restaurés/README.md b/Fichiers restaurés/README.md
deleted file mode 100644
index d91c980..0000000
--- a/Fichiers restaurés/README.md	
+++ /dev/null
@@ -1,52 +0,0 @@
-# 🌡️ Gestion des sondes domotiques
-
-[![Version Python](https://img.shields.io/badge/Python-3.10-blue)](https://python.org)
-[![Licence](https://img.shields.io/badge/Licence-Propriétaire-orange)](https://mj91.fr:448/michel/Gestion_sondes)
-[![Gitea](https://img.shields.io/badge/Gitea-auto--hébergé-green)](https://mj91.fr:448)
-
-Application de **surveillance des températures** avec alertes, visualisation Streamlit, et déploiement automatisé via Gitea + Supervisor.
-
----
-
-## 🧩 Fonctionnalités principales
-
-- 🔍 Lecture de capteurs **DS18B20** et **DHT22**
-- 📨 Transmission via **MQTT**
-- 📊 Interface **Streamlit** (app.domo91.fr)
-- 🔔 Alertes **email / Telegram** si dépassement > 30 minutes
-- 🧠 Déploiement auto avec **`deploy.sh`**
-- 🧾 Stockage SQL sur **MySQL (VPS)**
-
----
-
-## 📊 Exemple de visualisation
-
-Voici un aperçu d’un graphique dans l’interface Streamlit :
-
-![Exemple de graphique Streamlit](https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Matplotlib_figure.svg/800px-Matplotlib_figure.svg.png)
-
----
-
-## 🗂️ Structure du projet
-
-| Fichier                      | Description                                                        |
-|-----------------------------|---------------------------------------------------------------------|
-| `Monitor.py`                | Analyse de température et alertes                                 |
-| `Streamlit.py`              | Interface graphique web                                           |
-| `Cuisine_saclay.py`         | Script capteur pour le site de Saclay                            |
-| `Cuisine_meudon.py`         | Script capteur pour Meudon                                        |
-| `check_supervisor.py`       | Vérifie l’état des scripts supervisés                            |
-| `deploy.sh`                 | Déploiement auto depuis Gitea (branche `product`)                 |
-| `requirements.txt`          | Dépendances Python                                                |
-
----
-
-## 🧪 Installation locale
-
-```bash
-git clone https://mj91.fr:448/michel/Gestion_sondes.git
-cd Gestion_sondes
-python -m venv .venv
-source .venv/bin/activate  # Linux/macOS
-.venv\Scripts\activate     # Windows
-pip install -r requirements.txt
diff --git a/Fichiers restaurés/Societe_Generale.py b/Fichiers restaurés/Societe_Generale.py
deleted file mode 100644
index 88c100c..0000000
--- a/Fichiers restaurés/Societe_Generale.py	
+++ /dev/null
@@ -1,107 +0,0 @@
-# Insertion de données da l'app SG.
-import streamlit as st
-import mysql.connector
-from dotenv import load_dotenv
-import os
-from datetime import datetime
-
-load_dotenv()
-
-st.set_page_config(page_title="Insertion Mysql", layout="centered")
-st.title("🗓️ Insertion dans une base MySQL")
-
-# Charger les identifiants
-DB_HOST = os.getenv("DB_HOST")
-DB_USER = os.getenv("DB_USER")
-DB_PASSWORD = os.getenv("DB_PASSWORD")
-
-# Connexion sans DB initiale pour lister les bases
-@st.cache_data
-def get_databases():
-    conn = mysql.connector.connect(
-        host=DB_HOST,
-        user=DB_USER,
-        password=DB_PASSWORD
-    )
-    cursor = conn.cursor()
-    cursor.execute("SHOW DATABASES")
-    bases = [db[0] for db in cursor.fetchall()]
-    conn.close()
-    return bases
-
-# Connexion avec DB sélectionnée
-def connect_to_db(db_name):
-    return mysql.connector.connect(
-        host=DB_HOST,
-        user=DB_USER,
-        password=DB_PASSWORD,
-        database=db_name
-    )
-
-# --- Interface principale ---
-
-base = st.selectbox("Choisir une base de données", get_databases())
-if base:
-    conn = connect_to_db(base)
-    cursor = conn.cursor()
-
-    cursor.execute("SHOW TABLES")
-    tables = [table[0] for table in cursor.fetchall()]
-    table = st.selectbox("Choisir une table", tables)
-
-    if table:
-        cursor.execute(f"DESCRIBE {table}")
-        colonnes = cursor.fetchall()
-
-        # Détection clé primaire
-        cursor.execute(f"SHOW INDEX FROM {table} WHERE Key_name = 'PRIMARY'")
-        pk = cursor.fetchone()
-        primary_key = pk[4] if pk else None
-
-        champ_date_candidates = [col[0] for col in colonnes if "date" in col[1].lower()]
-        champ_date = st.selectbox("Champ de date", champ_date_candidates)
-
-        nb_mois = st.number_input("Nombre d'insertions mensuelles", 1, 36, 6)
-        date_depart = st.date_input("Date de départ des insertions", value=datetime.today().date())
-        st.subheader("Champs à insérer (hors clé primaire et champ de date)")
-        champs_choisis = []
-        champs_editables = [col for col in colonnes if col[0] != primary_key and col[0] != champ_date]
-        for col in champs_editables:
-            if st.checkbox(f"{col[0]} ({col[1]})", value=True):
-                champs_choisis.append(col[0])
-
-        with st.form("formulaire_insertion"):
-            st.markdown("**Valeurs fixes pour les champs cochés**")
-            valeurs_fixes = {}
-            for nom in champs_choisis:
-                val = st.text_input(nom)
-                valeurs_fixes[nom] = val if val != "" else None
-
-            submit = st.form_submit_button("Insérer")
-
-            try:
-                cursor = conn.cursor()
-                insert_count = 0
-
-                for i in range(nb_mois):
-                    year = date_depart.year + (date_depart.month + i - 1) // 12
-                    month = (date_depart.month + i - 1) % 12 + 1
-                    day = min(date_depart.day, 28)
-                    date_cible = datetime(year, month, day).date()
-
-                    champs = [champ_date] + list(valeurs_fixes.keys())
-                    valeurs = [date_cible] + list(valeurs_fixes.values())
-                    sql = f"INSERT INTO {table} ({', '.join(champs)}) VALUES ({', '.join(['%s'] * len(valeurs))})"
-
-                    cursor.execute(sql, valeurs)
-                    insert_count += 1
-
-                conn.commit()
-                st.success(f"{insert_count} lignes insérées avec succès dans `{table}`.")
-
-            except Exception as e:
-                st.error(f"❌ Erreur lors de l’insertion : {e}")
-
-                conn.commit()
-                st.success(f"{insert_count} lignes insérées avec succès dans `{table}`.")
-st.success(f"{insert_count} lignes insérées avec succès.")
\ No newline at end of file
diff --git a/Fichiers restaurés/Telegram_sondes.py b/Fichiers restaurés/Telegram_sondes.py
deleted file mode 100644
index 3077d92..0000000
--- a/Fichiers restaurés/Telegram_sondes.py	
+++ /dev/null
@@ -1,324 +0,0 @@
-# Gestion des chambres froides & alertes Telegram
-import requests
-import mysql.connector
-from datetime import datetime, timedelta
-import time
-import sys
-import os
-import schedule
-
-def connect_db():
-    return mysql.connector.connect(
-        host="54.36.188.119",
-        user="michel",
-        password="#SO2&1nf%mZ@jfh",
-        database="Sondes"
-    )
-
-def envoi_etat_quotidien(cursor, site):
-    token = "8128378340:AAF2sO3gaH1XpMNya_pEslzerqokoCiFRGs"
-    chat_id = get_chat_id(cursor, site)
-    etat_sondes(cursor, site, chat_id, token)
-    print(f"[INFO] État des sondes envoyé pour le site {site}.")
-
-def get_active_sondes(cursor, site):
-    query = "SELECT Sonde, Temp_Max FROM Chambres_froides WHERE Lieu = %s AND Etat = 'On';"
-    cursor.execute(query, (site,))
-    result = cursor.fetchall()
-    return {row[0]: float(row[1]) for row in result}
-
-
-def check_temperature_limits(cursor, table_historique, sonde, limite, duree=30):
-    temps_limite = datetime.now() - timedelta(minutes=duree)
-    query = f"""
-    SELECT Temperature 
-    FROM {table_historique}
-    WHERE Sonde = %s AND Date >= %s 
-    ORDER BY Date DESC LIMIT 6;
-    """
-    cursor.execute(query, (sonde, temps_limite))
-    result = cursor.fetchall()
-    if len(result) == 6 and all(float(temp[0]) > limite for temp in result):
-        return True, float(result[0][0])
-    return False, None
-
-def simulate_alert(db, cursor, site, sonde, chat_id, token):
-    table_alertes = f"Alertes_{site}"
-    print(f"[TEST] tentative d'insertion de sonde : {sonde} dans table {table_alertes}")
-
-    try:
-        query = f"""
-        INSERT INTO {table_alertes} (Sonde, Debut_defaut, Status)
-        VALUES (%s, NOW(), 'test')
-        ON DUPLICATE KEY UPDATE Debut_defaut = NOW(), Status = 'test';
-        """
-        cursor.execute(query, (sonde,))
-        db.commit()
-        print(f"[TEST] insertion ou mise à jour réussie pour {sonde}.")
-    except Exception as e:
-        print(f"[ERREUR] lors de l'insertion test : {e}")
-
-    message = f"⚠️ TEST ALERTE : Simulation d'une alerte pour la sonde {sonde}."
-    url = f"https://api.telegram.org/bot{token}/sendMessage"
-    try:
-        requests.get(url, params={'chat_id': chat_id, 'text': message})
-    except Exception as e:
-        print(f"[ERREUR] lors de l'envoi Telegram : {e}")
-
-def create_alert(db, cursor, table_alertes, sonde, temperature):
-    query = f"""
-    INSERT INTO {table_alertes} (Sonde, Debut_defaut, Status) 
-    VALUES (%s, NOW(), 'en cours');
-    """
-    cursor.execute(query, (sonde,))
-    send_telegram_message(sonde, temperature)
-    print(f"Alerte créée pour la sonde {sonde}")
-    db.commit()
-
-def resolve_alert(cursor, table_alertes, sonde):
-    query = f"""
-    UPDATE {table_alertes}
-    SET Status = 'résolu' 
-    WHERE Sonde = %s AND Status = 'en cours';
-    """
-    cursor.execute(query, (sonde,))
-    print(f"Alerte résolue pour la sonde {sonde}")
-
-def acquitter_alerte(cursor, site, sonde, chat_id, token):
-    table_alertes = f"Alertes_{site}"
-    query = f"""
-    UPDATE {table_alertes}
-    SET Status = 'acquittée'
-    WHERE Sonde = %s AND Status IN ('en cours', 'test');
-    """
-    cursor.execute(query, (sonde,))
-    lignes_modifiees = cursor.rowcount
-
-    if lignes_modifiees > 0:
-        message = f"✅ Alerte acquittée pour la sonde {sonde} par commande Telegram."
-    else:
-        message = f"ℹ️ Aucune alerte active à acquitter pour la sonde {sonde}."
-
-    url = f"https://api.telegram.org/bot{token}/sendMessage"
-    try:
-        requests.get(url, params={'chat_id': chat_id, 'text': message})
-    except Exception as e:
-        print(f"[ERREUR] envoi message Telegram : {e}")
-
-def send_telegram_message(sonde, temperature):
-    token = "5714323406:AAGSj9jrfBHbfxubz3ooabPEizI8aBOLnvE"
-    chat_id = "-1002442631825"
-    message = f"⚠️ Alerte température : La sonde {sonde} dépasse la limite avec une température de {temperature}°C."
-    url = f"https://api.telegram.org/bot{token}/sendMessage"
-    params = {'chat_id': chat_id, 'text': message}
-    try:
-        response = requests.get(url, params=params)
-        if response.status_code == 200:
-            print(f"Message envoyé via Telegram pour la sonde {sonde}.")
-        else:
-            print(f"Erreur lors de l'envoi du message Telegram : {response.status_code}")
-    except Exception as e:
-        print(f"Erreur lors de l'envoi du message Telegram : {e}")
-
-
-def get_chat_id(cursor, site):
-    cursor.execute("SELECT Chat_ID FROM Sites WHERE Nom = %s;", (site,))
-    result = cursor.fetchone()
-    if result:
-        return result[0]
-    else:
-        print(f"Aucun Chat_ID trouvé pour le site {site}")
-        return None
-
-def passer_en_maintenance(cursor, site, sonde, chat_id, token):
-    try:
-        query = """
-        UPDATE Chambres_froides
-        SET Etat = 'Off'
-        WHERE Lieu = %s AND Sonde = %s;
-        """
-        cursor.execute(query, (site, sonde))
-        lignes_modifiees = cursor.rowcount
-
-        if lignes_modifiees > 0:
-            message = f"🛠️ La sonde {sonde} a été passée en mode maintenance (OFF)."
-        else:
-            message = f"⚠️ Sonde {sonde} introuvable pour le site {site}."
-
-        url = f"https://api.telegram.org/bot{token}/sendMessage"
-        requests.get(url, params={'chat_id': chat_id, 'text': message})
-
-    except Exception as e:
-        print(f"[ERREUR] lors du passage en maintenance : {e}")
-
-def reactiver_sonde(cursor, site, sonde, chat_id, token):
-    try:
-        query = """
-        UPDATE Chambres_froides
-        SET Etat = 'On'
-        WHERE Lieu = %s AND Sonde = %s;
-        """
-        cursor.execute(query, (site, sonde))
-        lignes_modifiees = cursor.rowcount
-
-        if lignes_modifiees > 0:
-            message = f"✅ La sonde {sonde} a été réactivée (ON)."
-        else:
-            message = f"⚠️ Sonde {sonde} introuvable pour le site {site}."
-
-        url = f"https://api.telegram.org/bot{token}/sendMessage"
-        requests.get(url, params={'chat_id': chat_id, 'text': message})
-
-    except Exception as e:
-        print(f"[ERREUR] lors de la réactivation : {e}")
-
-def etat_sondes(cursor, site, chat_id, token):
-    query = "SELECT Sonde, Etat FROM Chambres_froides WHERE Lieu = %s ORDER BY Sonde;"
-    cursor.execute(query, (site,))
-    result = cursor.fetchall()
-
-    message = f"📊 État des sondes - {site} :\n"
-    for sonde, etat in result:
-        symbole = "🟢" if etat.upper() == "ON" else "🔴"
-        message += f"{symbole} {sonde} ({etat.upper()})\n"
-
-    url = f"https://api.telegram.org/bot{token}/sendMessage"
-    requests.get(url, params={'chat_id': chat_id, 'text': message})
-
-def monitor_temperatures_simple(site, db, cursor):
-    table_historique = site
-    table_alertes = f"Alertes_{site}"
-    sondes = get_active_sondes(cursor, site)
-    print(f"[MONITORING] Sondes actives pour {site} : {sondes}")
-
-    for sonde, limite in sondes.items():
-        alert_needed, temperature = check_temperature_limits(cursor, table_historique, sonde, limite)
-        if alert_needed:
-            create_alert(db, cursor, table_alertes, sonde, temperature)
-        else:
-            resolve_alert(cursor, table_alertes, sonde)
-
-    db.commit()
-    print("[MONITORING] Vérification des sondes terminée.")
-
-def monitor_temperatures(site):
-    db = connect_db()
-    cursor = db.cursor()
-
-    table_historique = site  # Ex: Saclay
-    table_alertes = f"Alertes_{site}"  # Ex: Alertes_Saclay
-
-    sondes = get_active_sondes(cursor, site)
-    print(f"Sondes actives pour le site {site} :", sondes)
-
-    for sonde, limite in sondes.items():
-        alert_needed, temperature = check_temperature_limits(cursor, table_historique, sonde, limite)
-        if alert_needed:
-            create_alert(db, cursor, table_alertes, sonde, temperature)
-        else:
-            resolve_alert(cursor, table_alertes, sonde)
-
-    db.commit()
-    listen_for_commands(db, cursor, site)
-    cursor.close()
-    db.close()
-
-def listen_for_commands(db, cursor, site):
-    token = "5714323406:AAGSj9jrfBHbfxubz3ooabPEizI8aBOLnvE"
-    chat_id = get_chat_id(cursor, site)
-    offset_file = os.path.join(os.path.dirname(__file__), f"last_update_id_{site}.txt")
-
-    try:
-        with open(offset_file, 'r') as f:
-            last_update_id = int(f.read().strip())
-    except FileNotFoundError:
-        last_update_id = None
-
-    url = f"https://api.telegram.org/bot{token}/getUpdates"
-    if last_update_id is not None:
-        url += f"?offset={last_update_id + 1}"
-
-    try:
-        response = requests.get(url)
-        data = response.json()
-
-        if "result" in data:
-            for update in data["result"]:
-                update_id = update["update_id"]
-
-                if "message" in update:
-                    message = update["message"]["text"]
-                    print(f"[CMD] Message reçu : {message}")
-
-                    if message.lower().startswith("/etat"):
-                        etat_sondes(cursor, site, chat_id, token)
-
-                    elif message.lower().startswith("/acquitter"):
-                        parts = message.strip().split(" ", 1)
-                        if len(parts) == 2 and parts[1].strip():
-                            sonde = parts[1].strip()
-                            acquitter_alerte(cursor, site, sonde, chat_id, token)
-                            db.commit()
-                        else:
-                            erreur_msg = "❌ Utilisation incorrecte. Format attendu : /acquitter <nom_sonde>"
-                            requests.get(f"https://api.telegram.org/bot{token}/sendMessage",
-                                         params={'chat_id': chat_id, 'text': erreur_msg})
-                    elif message.lower().startswith("/maintenance"):
-                        parts = message.strip().split(" ", 1)
-                        if len(parts) == 2 and parts[1].strip():
-                            sonde = parts[1].strip()
-                            passer_en_maintenance(cursor, site, sonde, chat_id, token)
-                            db.commit()
-                        else:
-                            erreur_msg = "❌ Utilisation incorrecte. Format attendu : /maintenance <nom_sonde>"
-                            requests.get(f"https://api.telegram.org/bot{token}/sendMessage",
-                                         params={'chat_id': chat_id, 'text': erreur_msg})
-                    elif message.lower().startswith("/reactiver"):
-                        parts = message.strip().split(" ", 1)
-                        if len(parts) == 2 and parts[1].strip():
-                            sonde = parts[1].strip()
-                            reactiver_sonde(cursor, site, sonde, chat_id, token)
-                            db.commit()
-                        else:
-                            erreur_msg = "❌ Utilisation incorrecte. Format attendu : /reactiver <nom_sonde>"
-                            requests.get(f"https://api.telegram.org/bot{token}/sendMessage",
-                                         params={'chat_id': chat_id, 'text': erreur_msg})
-                    elif message.lower().startswith("/test"):
-                        parts = message.strip().split(" ", 1)
-                        if len(parts) == 2 and parts[1].strip():
-                            sonde = parts[1].strip()
-                            simulate_alert(db, cursor, site, sonde, chat_id, token)
-                        else:
-                            erreur_msg = "❌ Utilisation incorrecte. Format attendu : /test <nom_sonde>"
-                            requests.get(f"https://api.telegram.org/bot{token}/sendMessage",
-                                         params={'chat_id': chat_id, 'text': erreur_msg})
-
-                with open(offset_file, 'w') as f:
-                    f.write(str(update_id))
-
-    except Exception as e:
-        print(f"Erreur lors de la lecture des commandes Telegram : {e}")
-
-
-def main():
-    site = sys.argv[1] if len(sys.argv) > 1 else "Saclay"
-    db = connect_db()
-    cursor = db.cursor()
-
-    # ✅ Planification : tous les jours à 07:00 → état des sondes
-    schedule.every().day.at("07:00").do(envoi_etat_quotidien, cursor=cursor, site=site)
-
-    # ✅ Planification : toutes les 2m30 → surveillance
-    schedule.every(2).minutes.do(monitor_temperatures_simple, site=site, db=db, cursor=cursor)
-
-    try:
-        while True:
-            schedule.run_pending()
-            listen_for_commands(db, cursor, site)
-            time.sleep(2)  # petite pause pour ne pas surcharger Telegram
-    finally:
-        cursor.close()
-        db.close()
-
-if __name__ == "__main__":
-    main()
diff --git a/Fichiers restaurés/Test_mail.py b/Fichiers restaurés/Test_mail.py
deleted file mode 100644
index 7a37988..0000000
--- a/Fichiers restaurés/Test_mail.py	
+++ /dev/null
@@ -1,24 +0,0 @@
-# Programme de test de la BAL alertes_saclay@domo91.fr.
-import smtplib
-from email.mime.text import MIMEText
-
-def envoyer_mail(sujet, message, destinataires):
-    msg = MIMEText(message)
-    msg['Subject'] = sujet
-    msg['From'] = 'alertes_saclay@domo91.fr'
-    msg['To'] = ', '.join(destinataires)
-
-    try:
-        with smtplib.SMTP_SSL('smtp.mail.ovh.net', 465) as server:
-            server.login('alertes_saclay@domo91.fr', 'Kdpke674y23Feq^H')
-            server.sendmail(msg['From'], destinataires, msg.as_string())
-            print(f"📧 Mail envoyé à {destinataires}")
-    except Exception as e:
-        print(f"Erreur envoi mail : {e}")
-
-# --- Test d'envoi ---
-envoyer_mail(
-    sujet="🧪 Test d'envoi d'alerte",
-    message="Ceci est un test de l'envoi d'e-mail via alertes_saclay@domo91.fr.",
-    destinataires=["services@domo91.fr"]
-)
diff --git a/Fichiers restaurés/Tracker.py b/Fichiers restaurés/Tracker.py
deleted file mode 100644
index 6d47f1f..0000000
--- a/Fichiers restaurés/Tracker.py	
+++ /dev/null
@@ -1,106 +0,0 @@
-# Programme de récupération des adresses de sondes DS18B20 et envoie dans table Sondes.Tracker.
-import paho.mqtt.client as mqtt
-import mysql.connector
-import re  # Import de la bibliothèque des expressions régulières
-
-# Configuration de la base de données MySQL
-db_config = {
-    'user': 'superviseur',  # Remplacez par votre utilisateur MySQL
-    'password': 'Bto7Lm_z]m!BFH!*',  # Remplacez par votre mot de passe MySQL
-    'host': '54.36.188.119',  # Adresse de votre serveur MySQL (localhost si en local)
-    'database': 'Sondes'  # Nom de la base de données MySQL
-}
-
-
-def convertir_rom_id_en_hexa(rom_id):
-    # On découpe la chaîne rom_id en paires de deux caractères
-    hex_parts = [f"0x{rom_id[i:i + 2]}" for i in range(0, len(rom_id), 2)]
-    return ",".join(hex_parts)
-
-
-# Connexion à la base de données MySQL
-def connect_db():
-    return mysql.connector.connect(**db_config)
-
-
-# Fonction pour vérifier si la sonde est déjà présente dans la base
-def sonde_deja_presente(rom_id):
-    conn = connect_db()
-    cursor = conn.cursor()
-    try:
-        # Vérifier si la sonde existe déjà dans la base
-        cursor.execute("SELECT COUNT(*) FROM Tracker WHERE rom_id = %s", (rom_id,))
-        result = cursor.fetchone()
-        return result[0] > 0  # Si le nombre est supérieur à 0, la sonde est déjà présente
-
-    except mysql.connector.Error as err:
-        print(f"Erreur MySQL lors de la vérification de la sonde : {err}")
-        return False
-
-    finally:
-        cursor.close()
-        conn.close()
-
-
-# Fonction pour insérer les sondes dans la base de données
-def inserer_sonde(rom_id):
-    if sonde_deja_presente(rom_id):
-        print(f"Sonde {rom_id} déjà présente dans la base de données. Aucune insertion effectuée.")
-        return
-
-    conn = connect_db()
-    cursor = conn.cursor()
-    try:
-        # Conversion en hexadécimal
-        rom_id_hexa = convertir_rom_id_en_hexa(rom_id)
-
-        # Insertion de rom_id et de sa version hexa dans la base
-        cursor.execute("INSERT INTO Tracker (rom_id, hexa) VALUES (%s, %s)", (rom_id, rom_id_hexa))
-        conn.commit()
-        print(f"Sonde {rom_id} insérée dans la base de données avec son format hexa {rom_id_hexa}.")
-
-    except mysql.connector.Error as err:
-        print(f"Erreur MySQL : {err}")
-
-    finally:
-        cursor.close()
-        conn.close()
-
-
-# Fonction de callback pour gérer les messages MQTT
-def on_message(_client, _userdata, message):
-    payload = message.payload.decode()
-    print(f"Message reçu : {payload}")
-
-    # Utilisation de re pour extraire les ROM IDs (Sonde [rom_id])
-    rom_ids = re.findall(r"[0-9a-fA-F]{16}", payload)  # Capturer les IDs de 16 caractères
-    if rom_ids:
-        for rom_id in rom_ids:
-            inserer_sonde(rom_id)
-    else:
-        print("Aucun ROM ID trouvé dans le message.")
-
-
-# Configuration du client MQTT
-mqtt_broker = "46.105.92.116"
-mqtt_port = 1883  # Vérifiez si votre broker utilise un autre port
-mqtt_user = "Bwps"
-mqtt_password = "scJ5ACj2keRfI^"
-mqtt_topic = "Tracker/sondes"
-
-client = mqtt.Client()
-
-# Authentification MQTT
-client.username_pw_set(mqtt_user, mqtt_password)
-
-# Configuration du callback pour les messages MQTT
-client.on_message = on_message
-
-# Connexion au broker MQTT
-client.connect(mqtt_broker, mqtt_port, 60)
-
-# Souscription au topic Tracker/sondes
-client.subscribe(mqtt_topic)
-
-# Démarrer la boucle MQTT
-client.loop_forever()
diff --git a/Fichiers restaurés/logs_analyse.py b/Fichiers restaurés/logs_analyse.py
deleted file mode 100644
index 5630e30..0000000
--- a/Fichiers restaurés/logs_analyse.py	
+++ /dev/null
@@ -1,39 +0,0 @@
-import streamlit as st
-import pandas as pd
-import matplotlib.pyplot as plt
-
-# --- Chargement des données ---
-try:
-    df = pd.read_csv("/home/debian/travail/logs_monitor.csv", sep=";", parse_dates=["Date"])
-except FileNotFoundError:
-    st.error("📂 Le fichier de log n'a pas été trouvé.")
-    st.stop()
-
-st.title("🧾 Analyse des scans Monitor.py")
-
-# --- Filtres ---
-df["Date_str"] = df["Date"].dt.date
-dates_dispo = sorted(df["Date_str"].unique(), reverse=True)
-date_selection = st.selectbox("📅 Sélectionnez une date :", dates_dispo)
-
-lieux = sorted(df["Lieu"].unique())
-lieu_selection = st.selectbox("📍 Site :", lieux)
-
-df_filtré = df[(df["Date_str"] == date_selection) & (df["Lieu"] == lieu_selection)]
-
-sondes = sorted(df_filtré["Sonde"].unique())
-sonde_selection = st.selectbox("🧪 Sonde :", sondes)
-
-df_sonde = df_filtré[df_filtré["Sonde"] == sonde_selection]
-
-# --- Graphique température ---
-fig, ax = plt.subplots(figsize=(10, 4))
-ax.plot(df_sonde["Date"], df_sonde["Température"], marker='o')
-ax.set_title(f"Évolution de la température - {sonde_selection}")
-ax.set_xlabel("Heure")
-ax.set_ylabel("Température (°C)")
-st.pyplot(fig)
-
-# --- Tableau complet du jour/sonde sélectionnés ---
-st.markdown("### 📋 Détail des scans")
-st.dataframe(df_sonde[["Date", "Sonde", "Température", "Seuil", "État"]], use_container_width=True)
diff --git a/Fichiers restaurés/supervisor_watchdog.py b/Fichiers restaurés/supervisor_watchdog.py
deleted file mode 100644
index 76a7834..0000000
--- a/Fichiers restaurés/supervisor_watchdog.py	
+++ /dev/null
@@ -1,47 +0,0 @@
-# Controle des services supervisor envoi en cas de disfonction et tous les jours à sept heures
-# a faire tourner avec crontb -e en sudo
-#   */30 * * * * /home/debian/travail/myenv/bin/python3 /home/debian/travail/Scripts/supervisor_watchdog.py
-import subprocess
-import smtplib
-from email.mime.text import MIMEText
-from datetime import datetime
-
-heure_actuelle = datetime.now().strftime("%H:%M")
-etat_services = []
-anomalies = []
-
-try:
-    output = subprocess.check_output("/usr/bin/supervisorctl status", shell=True, text=True)
-    for line in output.splitlines():
-        parts = line.split()
-        if len(parts) >= 2:
-            nom, statut = parts[0], parts[1]
-            etat_services.append(f"{nom} ➤ {statut}")
-            if statut != "RUNNING":
-                anomalies.append(f"{nom} ➤ {statut}")
-except Exception as e:
-    etat_services.append("❌ Impossible d'exécuter supervisorctl")
-    anomalies.append(f"Erreur : {e}")
-
-# Déclenchement mail si anomalie ou à 07:00
-envoyer_mail = bool(anomalies) or heure_actuelle == "07:00"
-
-if envoyer_mail:
-    sujet = "⚠️ Alerte Supervisor" if anomalies else "✅ Rapport quotidien Supervisor"
-    intro = "🛑 Les services suivants ne sont pas en RUNNING :" if anomalies else "✅ Tous les services supervisés sont en RUNNING."
-    contenu = f"{intro}\n\n" + "\n".join(etat_services)
-
-    msg = MIMEText(contenu)
-    msg["Subject"] = sujet
-    msg["From"] = "alertes_saclay@domo91.fr"
-    msg["To"] = "services@domo91.fr"
-
-    try:
-        with smtplib.SMTP_SSL("smtp.mail.ovh.net", 465) as server:
-            server.login("alertes_saclay@domo91.fr", "Kdpke674y23Feq^H")
-            server.sendmail(msg["From"], [msg["To"]], msg.as_string())
-            print("📧 Mail envoyé.")
-    except Exception as e:
-        print(f"Erreur envoi mail : {e}")
-else:
-    print("🕖 Aucun mail envoyé (tout est OK et ce n’est pas l’heure du rapport).")

From 36dd41b17cde01aba5ca5a1b0fff89c2eab60682 Mon Sep 17 00:00:00 2001
From: Michel <michel@mj91.fr>
Date: Fri, 18 Apr 2025 10:12:52 +0200
Subject: [PATCH 05/12] Ignore workspace.xml (fichier config PyCharm local)

---
 .idea/workspace.xml | 323 --------------------------------------------
 1 file changed, 323 deletions(-)
 delete mode 100644 .idea/workspace.xml

diff --git a/.idea/workspace.xml b/.idea/workspace.xml
deleted file mode 100644
index 6354e07..0000000
--- a/.idea/workspace.xml
+++ /dev/null
@@ -1,323 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="AutoImportSettings">
-    <option name="autoReloadType" value="SELECTIVE" />
-  </component>
-  <component name="ChangeListManager">
-    <list default="true" id="a12d9762-568e-4ace-91c1-148c598387a7" name="Changes" comment="&quot;Ajout entrées au fichier Gitignore&quot;">
-      <change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
-    </list>
-    <option name="SHOW_DIALOG" value="false" />
-    <option name="HIGHLIGHT_CONFLICTS" value="true" />
-    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
-    <option name="LAST_RESOLUTION" value="IGNORE" />
-  </component>
-  <component name="FileTemplateManagerImpl">
-    <option name="RECENT_TEMPLATES">
-      <list>
-        <option value="Python Script" />
-      </list>
-    </option>
-  </component>
-  <component name="Git.Merge.Settings">
-    <option name="BRANCH" value="develop" />
-  </component>
-  <component name="Git.Settings">
-    <option name="RECENT_BRANCH_BY_REPOSITORY">
-      <map>
-        <entry key="$PROJECT_DIR$" value="f136d15975db2b292a408727f76b3fce1b3f1351" />
-      </map>
-    </option>
-    <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
-  </component>
-  <component name="ProblemsViewState">
-    <option name="selectedTabId" value="CurrentFile" />
-    <option name="showPreview" value="true" />
-  </component>
-  <component name="ProjectColorInfo">{
-  &quot;associatedIndex&quot;: 5
-}</component>
-  <component name="ProjectId" id="2nIN6lkmtfcgr9VNmeRIwomh3Vr" />
-  <component name="ProjectLevelVcsManager">
-    <ConfirmationsSetting value="2" id="Add" />
-  </component>
-  <component name="ProjectViewState">
-    <option name="hideEmptyMiddlePackages" value="true" />
-    <option name="showExcludedFiles" value="false" />
-    <option name="showLibraryContents" value="true" />
-    <option name="showScratchesAndConsoles" value="false" />
-  </component>
-  <component name="PropertiesComponent">{
-  &quot;keyToString&quot;: {
-    &quot;Python.AlerteMonitoring.executor&quot;: &quot;Run&quot;,
-    &quot;Python.Alerte_journalière.executor&quot;: &quot;Run&quot;,
-    &quot;Python.AlertesSondesSaclay.executor&quot;: &quot;Run&quot;,
-    &quot;Python.Alertes_Saclay.executor&quot;: &quot;Run&quot;,
-    &quot;Python.Alertes_Telegram.executor&quot;: &quot;Run&quot;,
-    &quot;Python.Alertes_saclay.executor&quot;: &quot;Run&quot;,
-    &quot;Python.Alertes_telegram.executor&quot;: &quot;Run&quot;,
-    &quot;Python.Base.executor&quot;: &quot;Run&quot;,
-    &quot;Python.Base2.executor&quot;: &quot;Run&quot;,
-    &quot;Python.Chat-Id.executor&quot;: &quot;Run&quot;,
-    &quot;Python.Chaufferie.executor&quot;: &quot;Run&quot;,
-    &quot;Python.Code_général.executor&quot;: &quot;Run&quot;,
-    &quot;Python.Connexion_mysql.executor&quot;: &quot;Run&quot;,
-    &quot;Python.Cuisine_meudon.executor&quot;: &quot;Run&quot;,
-    &quot;Python.Cuisine_saclay.executor&quot;: &quot;Run&quot;,
-    &quot;Python.Général.executor&quot;: &quot;Run&quot;,
-    &quot;Python.Insertion_tables_Msql.executor&quot;: &quot;Run&quot;,
-    &quot;Python.Lecture_tableau_frigos.executor&quot;: &quot;Run&quot;,
-    &quot;Python.Monitor.executor&quot;: &quot;Run&quot;,
-    &quot;Python.Saclay.executor&quot;: &quot;Run&quot;,
-    &quot;Python.Saclay_buffer.executor&quot;: &quot;Run&quot;,
-    &quot;Python.Sondes tracker.executor&quot;: &quot;Run&quot;,
-    &quot;Python.Streamlit.executor&quot;: &quot;Run&quot;,
-    &quot;Python.Streamlit_Saaclay.executor&quot;: &quot;Run&quot;,
-    &quot;Python.Streamlit_Saclay.executor&quot;: &quot;Run&quot;,
-    &quot;Python.Telegram_sondes.executor&quot;: &quot;Run&quot;,
-    &quot;Python.Test Tables MYSQL.executor&quot;: &quot;Run&quot;,
-    &quot;Python.Test Tables Sondes.executor&quot;: &quot;Run&quot;,
-    &quot;Python.Test table Meudon.executor&quot;: &quot;Run&quot;,
-    &quot;Python.Test table Saclay.executor&quot;: &quot;Run&quot;,
-    &quot;Python.Test.executor&quot;: &quot;Run&quot;,
-    &quot;Python.Test_mail.executor&quot;: &quot;Run&quot;,
-    &quot;Python.Tracker.executor&quot;: &quot;Run&quot;,
-    &quot;Python.Vérification Triggers.executor&quot;: &quot;Run&quot;,
-    &quot;Python.Vérification_temperatures_alertes_mail.executor&quot;: &quot;Run&quot;,
-    &quot;Python.domo91.executor&quot;: &quot;Run&quot;,
-    &quot;Python.logs_analyses.executor&quot;: &quot;Run&quot;,
-    &quot;Python.test.executor&quot;: &quot;Run&quot;,
-    &quot;RunOnceActivity.ShowReadmeOnStart&quot;: &quot;true&quot;,
-    &quot;RunOnceActivity.git.unshallow&quot;: &quot;true&quot;,
-    &quot;git-widget-placeholder&quot;: &quot;develop&quot;,
-    &quot;ignore.virus.scanning.warn.message&quot;: &quot;true&quot;,
-    &quot;last_opened_file_path&quot;: &quot;C:/Users/miche/PycharmProjects/Gestion sondes&quot;,
-    &quot;settings.editor.selected.configurable&quot;: &quot;vcs.Git&quot;,
-    &quot;settings.editor.splitter.proportion&quot;: &quot;0.28861153&quot;
-  }
-}</component>
-  <component name="RecentsManager">
-    <key name="CopyFile.RECENT_KEYS">
-      <recent name="C:\Users\miche\PycharmProjects\Gestion sondes" />
-    </key>
-    <key name="MoveFile.RECENT_KEYS">
-      <recent name="C:\Users\miche\PycharmProjects\Gestion sondes\Scripts" />
-      <recent name="C:\Users\miche\PycharmProjects\Gestion sondes" />
-    </key>
-  </component>
-  <component name="RunManager">
-    <configuration name="domo91" type="PythonConfigurationType" factoryName="Python" temporary="true" nameIsGenerated="true">
-      <module name="Gestion sondes" />
-      <option name="ENV_FILES" value="" />
-      <option name="INTERPRETER_OPTIONS" value="" />
-      <option name="PARENT_ENVS" value="true" />
-      <envs>
-        <env name="PYTHONUNBUFFERED" value="1" />
-      </envs>
-      <option name="SDK_HOME" value="" />
-      <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$" />
-      <option name="IS_MODULE_SDK" value="true" />
-      <option name="ADD_CONTENT_ROOTS" value="true" />
-      <option name="ADD_SOURCE_ROOTS" value="true" />
-      <option name="SCRIPT_NAME" value="C:\Users\miche\PycharmProjects\Gestion sondes\domo91.py" />
-      <option name="PARAMETERS" value="" />
-      <option name="SHOW_COMMAND_LINE" value="false" />
-      <option name="EMULATE_TERMINAL" value="false" />
-      <option name="MODULE_MODE" value="false" />
-      <option name="REDIRECT_INPUT" value="false" />
-      <option name="INPUT_FILE" value="" />
-      <method v="2" />
-    </configuration>
-    <recent_temporary>
-      <list>
-        <item itemvalue="Python.domo91" />
-        <item itemvalue="Python.domo91" />
-        <item itemvalue="Python.domo91" />
-        <item itemvalue="Python.domo91" />
-        <item itemvalue="Python.domo91" />
-      </list>
-    </recent_temporary>
-  </component>
-  <component name="SharedIndexes">
-    <attachedChunks>
-      <set>
-        <option value="bundled-python-sdk-348a24fa61fa-5312c7369657-com.jetbrains.pycharm.community.sharedIndexes.bundled-PC-251.23774.444" />
-      </set>
-    </attachedChunks>
-  </component>
-  <component name="SpellCheckerSettings" RuntimeDictionaries="0" Folders="0" CustomDictionaries="0" DefaultDictionary="application-level" UseSingleDictionary="true" transferred="true" />
-  <component name="SvnConfiguration">
-    <configuration>C:\Users\miche\AppData\Roaming\Subversion</configuration>
-  </component>
-  <component name="TaskManager">
-    <task active="true" id="Default" summary="Default task">
-      <changelist id="a12d9762-568e-4ace-91c1-148c598387a7" name="Changes" comment="" />
-      <created>1728656456324</created>
-      <option name="number" value="Default" />
-      <option name="presentableId" value="Default" />
-      <updated>1728656456324</updated>
-    </task>
-    <task id="LOCAL-00001" summary="Ajout README Complet">
-      <option name="closed" value="true" />
-      <created>1744174026980</created>
-      <option name="number" value="00001" />
-      <option name="presentableId" value="LOCAL-00001" />
-      <option name="project" value="LOCAL" />
-      <updated>1744174026980</updated>
-    </task>
-    <task id="LOCAL-00002" summary="Ajout README Complet">
-      <option name="closed" value="true" />
-      <created>1744174083792</created>
-      <option name="number" value="00002" />
-      <option name="presentableId" value="LOCAL-00002" />
-      <option name="project" value="LOCAL" />
-      <updated>1744174083792</updated>
-    </task>
-    <task id="LOCAL-00003" summary="Ajout README Complet">
-      <option name="closed" value="true" />
-      <created>1744174834295</created>
-      <option name="number" value="00003" />
-      <option name="presentableId" value="LOCAL-00003" />
-      <option name="project" value="LOCAL" />
-      <updated>1744174834295</updated>
-    </task>
-    <task id="LOCAL-00004" summary=".gitignore">
-      <option name="closed" value="true" />
-      <created>1744198339815</created>
-      <option name="number" value="00004" />
-      <option name="presentableId" value="LOCAL-00004" />
-      <option name="project" value="LOCAL" />
-      <updated>1744198339815</updated>
-    </task>
-    <task id="LOCAL-00005" summary="Streamlit.py">
-      <option name="closed" value="true" />
-      <created>1744202721873</created>
-      <option name="number" value="00005" />
-      <option name="presentableId" value="LOCAL-00005" />
-      <option name="project" value="LOCAL" />
-      <updated>1744202721873</updated>
-    </task>
-    <task id="LOCAL-00006" summary="Streamlit.py">
-      <option name="closed" value="true" />
-      <created>1744223219809</created>
-      <option name="number" value="00006" />
-      <option name="presentableId" value="LOCAL-00006" />
-      <option name="project" value="LOCAL" />
-      <updated>1744223219809</updated>
-    </task>
-    <task id="LOCAL-00007" summary="Streamlit.py">
-      <option name="closed" value="true" />
-      <created>1744453875125</created>
-      <option name="number" value="00007" />
-      <option name="presentableId" value="LOCAL-00007" />
-      <option name="project" value="LOCAL" />
-      <updated>1744453875125</updated>
-    </task>
-    <task id="LOCAL-00008" summary="Base de données SG">
-      <option name="closed" value="true" />
-      <created>1744454480848</created>
-      <option name="number" value="00008" />
-      <option name="presentableId" value="LOCAL-00008" />
-      <option name="project" value="LOCAL" />
-      <updated>1744454480848</updated>
-    </task>
-    <task id="LOCAL-00009" summary="Base de données SG">
-      <option name="closed" value="true" />
-      <created>1744457082014</created>
-      <option name="number" value="00009" />
-      <option name="presentableId" value="LOCAL-00009" />
-      <option name="project" value="LOCAL" />
-      <updated>1744457082014</updated>
-    </task>
-    <task id="LOCAL-00010" summary="&quot;Injection données dans Tables Meudon et Roissy&quot;">
-      <option name="closed" value="true" />
-      <created>1744472289925</created>
-      <option name="number" value="00010" />
-      <option name="presentableId" value="LOCAL-00010" />
-      <option name="project" value="LOCAL" />
-      <updated>1744472289925</updated>
-    </task>
-    <task id="LOCAL-00011" summary="&quot;Injection données dans Tables Meudon et Roissy&quot;">
-      <option name="closed" value="true" />
-      <created>1744515782743</created>
-      <option name="number" value="00011" />
-      <option name="presentableId" value="LOCAL-00011" />
-      <option name="project" value="LOCAL" />
-      <updated>1744515782743</updated>
-    </task>
-    <task id="LOCAL-00012" summary="&quot;Injection données dans Tables Meudon et Roissy&quot;">
-      <option name="closed" value="true" />
-      <created>1744519840546</created>
-      <option name="number" value="00012" />
-      <option name="presentableId" value="LOCAL-00012" />
-      <option name="project" value="LOCAL" />
-      <updated>1744519840546</updated>
-    </task>
-    <task id="LOCAL-00013" summary="&quot;Ajout bt impression rapports et dossier PDF crée&quot;">
-      <option name="closed" value="true" />
-      <created>1744891048964</created>
-      <option name="number" value="00013" />
-      <option name="presentableId" value="LOCAL-00013" />
-      <option name="project" value="LOCAL" />
-      <updated>1744891048964</updated>
-    </task>
-    <task id="LOCAL-00014" summary="&quot;Ajout entrées au fichier Gitignore&quot;">
-      <option name="closed" value="true" />
-      <created>1744951733528</created>
-      <option name="number" value="00014" />
-      <option name="presentableId" value="LOCAL-00014" />
-      <option name="project" value="LOCAL" />
-      <updated>1744951733528</updated>
-    </task>
-    <option name="localTasksCounter" value="15" />
-    <servers />
-  </component>
-  <component name="Vcs.Log.Tabs.Properties">
-    <option name="RECENT_FILTERS">
-      <map>
-        <entry key="Branch">
-          <value>
-            <list>
-              <RecentGroup>
-                <option name="FILTER_VALUES">
-                  <option value="develop" />
-                </option>
-              </RecentGroup>
-            </list>
-          </value>
-        </entry>
-      </map>
-    </option>
-    <option name="TAB_STATES">
-      <map>
-        <entry key="MAIN">
-          <value>
-            <State>
-              <option name="FILTERS">
-                <map>
-                  <entry key="branch">
-                    <value>
-                      <list>
-                        <option value="develop" />
-                      </list>
-                    </value>
-                  </entry>
-                </map>
-              </option>
-            </State>
-          </value>
-        </entry>
-      </map>
-    </option>
-  </component>
-  <component name="VcsManagerConfiguration">
-    <MESSAGE value="Ajout README Complet" />
-    <MESSAGE value=".gitignore" />
-    <MESSAGE value="Streamlit.py" />
-    <MESSAGE value="Base de données SG" />
-    <MESSAGE value="&quot;Injection données dans Tables Meudon et Roissy&quot;" />
-    <MESSAGE value="&quot;Ajout bt impression rapports et dossier PDF crée&quot;" />
-    <MESSAGE value="&quot;Ajout entrées au fichier Gitignore&quot;" />
-    <option name="LAST_COMMIT_MESSAGE" value="&quot;Ajout entrées au fichier Gitignore&quot;" />
-  </component>
-</project>
\ No newline at end of file

From 5268fe664ec2b82778c71cf79bff96885c1f7ad9 Mon Sep 17 00:00:00 2001
From: Michel <michel@mj91.fr>
Date: Fri, 18 Apr 2025 10:36:37 +0200
Subject: [PATCH 06/12] MAJ du 18-04-2025

---
 domo91.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/domo91.py b/domo91.py
index 660249d..0bdbbe0 100644
--- a/domo91.py
+++ b/domo91.py
@@ -171,10 +171,10 @@ if st.session_state["authenticated"]:
             sonde_choisie = st.selectbox("🧪 Choisissez une sonde :", sondes)
             df_sonde = df[df["Sonde"] == sonde_choisie]
 
-            # Ajouter une colonne Heure pour faciliter les filtres
+# Ajouter une colonne Heure pour faciliter les filtres
             df_sonde["Heure"] = df_sonde["Date"].dt.hour
 
-            # Filtrage par tranche horaire
+# Filtrage par tranche horaire
             tranche = st.radio("🕒 Tranche horaire :",
                                ["Toute la journée", "Matin (6h-12h)", "Après-midi (12h-18h)", "Nuit (18h-6h)"])
 
@@ -203,7 +203,7 @@ if st.session_state["authenticated"]:
                 return ""
 
 
-            # Appliquer le style uniquement à la colonne "Temperature"
+# Appliquer le style uniquement à la colonne "Temperature"
             styled_df = df_filtré.style.applymap(surlignage_temp, subset=["Temperature"])
 
             st.dataframe(styled_df, use_container_width=True)
@@ -218,7 +218,7 @@ if st.session_state["authenticated"]:
             ax.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M'))
             ax.legend()
             st.pyplot(fig)
-        # --- Affichage des alertes du jour ---
+# --- Affichage des alertes du jour ---
         afficher_alertes = st.toggle("🚨 Afficher les alertes du jour")
 
         if afficher_alertes:

From 6e45094a25a5d7bf3c87e984e8fe5675cb251b3e Mon Sep 17 00:00:00 2001
From: Michel <michel@mj91.fr>
Date: Fri, 18 Apr 2025 10:53:15 +0200
Subject: [PATCH 07/12] "Version corrigee"

---
 domo91.py | 48 +++++++++++++++++++-----------------------------
 1 file changed, 19 insertions(+), 29 deletions(-)

diff --git a/domo91.py b/domo91.py
index 0bdbbe0..bca5b50 100644
--- a/domo91.py
+++ b/domo91.py
@@ -218,38 +218,28 @@ if st.session_state["authenticated"]:
             ax.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M'))
             ax.legend()
             st.pyplot(fig)
-# --- Affichage des alertes du jour ---
-        afficher_alertes = st.toggle("🚨 Afficher les alertes du jour")
+# --- Affichage automatique des alertes non acquittées ---
+        try:
+            conn = mysql.connector.connect(**db_config)
+            cursor = conn.cursor(dictionary=True)
 
-        if afficher_alertes:
-            try:
-                conn = mysql.connector.connect(**db_config)
-                cursor = conn.cursor(dictionary=True)
+            table_alertes = f"Alertes_{site_selectionne}"
+            cursor.execute(
+                f"SELECT Sonde, Debut_defaut, Status FROM `{table_alertes}` WHERE Status != 'Acquitté' ORDER BY Debut_defaut DESC"
+            )
+            alertes = cursor.fetchall()
 
-                table_alertes = f"Alertes_{site_selectionne}"
-                cursor.execute(
-                    f"SELECT Sonde, Debut_defaut, Status FROM `{table_alertes}` WHERE DATE(Debut_defaut) = %s",
-                    (selected_date.strftime("%Y-%m-%d"),)
-                )
-                alertes = cursor.fetchall()
+            if alertes:
+                df_alertes = pd.DataFrame(alertes)
+                st.subheader("🚨 Alertes non acquittées")
+                st.dataframe(df_alertes, use_container_width=True)
+            else:
+                st.success("✅ Aucune alerte en cours.")
 
-                if alertes:
-                    df_alertes = pd.DataFrame(alertes)
-                    st.subheader("🚨 Alertes enregistrées")
-                    st.dataframe(df_alertes, use_container_width=True)
-                else:
-                    st.info("Aucune alerte enregistrée pour cette date.")
-
-                cursor.close()
-                conn.close()
-            except Exception as e:
-                st.error(f"Erreur lors de la récupération des alertes : {e}")
-
-        else:
-            st.warning("Aucune donnée trouvée pour cette date.")
-
-        cursor.close()
-        conn.close()
+            cursor.close()
+            conn.close()
+        except Exception as e:
+            st.error(f"Erreur lors de la récupération des alertes : {e}")
 
     except Exception as e:
         st.error(f"Erreur MySQL : {e}")

From 56435e9019ed3fd6da829550e1e1f49fc8cfc5b4 Mon Sep 17 00:00:00 2001
From: Michel <michel@mj91.fr>
Date: Fri, 18 Apr 2025 11:30:15 +0200
Subject: [PATCH 08/12] "Rectif "

---
 domo91.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/domo91.py b/domo91.py
index bca5b50..67b79a5 100644
--- a/domo91.py
+++ b/domo91.py
@@ -172,7 +172,7 @@ if st.session_state["authenticated"]:
             df_sonde = df[df["Sonde"] == sonde_choisie]
 
 # Ajouter une colonne Heure pour faciliter les filtres
-            df_sonde["Heure"] = df_sonde["Date"].dt.hour
+            df_sonde.loc[:, "Heure"] = df_sonde["Date"].dt.hour
 
 # Filtrage par tranche horaire
             tranche = st.radio("🕒 Tranche horaire :",
@@ -204,7 +204,7 @@ if st.session_state["authenticated"]:
 
 
 # Appliquer le style uniquement à la colonne "Temperature"
-            styled_df = df_filtré.style.applymap(surlignage_temp, subset=["Temperature"])
+            styled_df = df_filtré.style.map(surlignage_temp, subset=["Temperature"])
 
             st.dataframe(styled_df, use_container_width=True)
 

From 8c91ef3885925a78e30cbc28e3cc0da24442e5a2 Mon Sep 17 00:00:00 2001
From: Michel <michel@mj91.fr>
Date: Fri, 18 Apr 2025 11:45:54 +0200
Subject: [PATCH 09/12] "11:45"

---
 domo91.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/domo91.py b/domo91.py
index 67b79a5..dbddaa6 100644
--- a/domo91.py
+++ b/domo91.py
@@ -184,6 +184,7 @@ if st.session_state["authenticated"]:
                 df_sonde = df_sonde[(df_sonde["Heure"] >= 12) & (df_sonde["Heure"] < 18)]
             elif tranche == "Nuit (18h-6h)":
                 df_sonde = df_sonde[(df_sonde["Heure"] >= 18) | (df_sonde["Heure"] < 6)]
+                df_sonde = df_sonde.copy()
 
             cursor.execute("SELECT Temp_Max FROM Chambres_froides WHERE Lieu = %s AND Sonde = %s", (site_selectionne, sonde_choisie))
             seuil = cursor.fetchone()
@@ -204,7 +205,8 @@ if st.session_state["authenticated"]:
 
 
 # Appliquer le style uniquement à la colonne "Temperature"
-            styled_df = df_filtré.style.map(surlignage_temp, subset=["Temperature"])
+
+            styled_df = df_filtré.style.applymap(surlignage_temp, subset=["Temperature"])
 
             st.dataframe(styled_df, use_container_width=True)
 

From 7a3d1615bd31cb350367d4ebff3eaaa9dc50c3c5 Mon Sep 17 00:00:00 2001
From: Michel <michel@mj91.fr>
Date: Fri, 18 Apr 2025 11:49:20 +0200
Subject: [PATCH 10/12] "Process"

---
 tools/Maj_develop_sur_product | 45 +++++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 tools/Maj_develop_sur_product

diff --git a/tools/Maj_develop_sur_product b/tools/Maj_develop_sur_product
new file mode 100644
index 0000000..59a0332
--- /dev/null
+++ b/tools/Maj_develop_sur_product
@@ -0,0 +1,45 @@
+✅ Objectif : mettre à jour domo91.py de product avec la version de develop
+🧭 Étapes simples à suivre :
+1. Assure-toi d’être sur la branche product
+git checkout product
+2. Récupère seulement le fichier domo91.py depuis develop
+
+git checkout develop -- domo91.py
+💡 Cette commande signifie :
+
+"Depuis la branche develop, prends juste le fichier domo91.py et applique-le sur la branche actuelle (product)".
+
+3. Vérifie le changement
+
+git status
+Tu devrais voir :
+modified: domo91.py
+4. Commit et push la mise à jour
+git commit -am "MAJ de domo91.py depuis develop"
+git push origin product
+✅ Résultat :
+Seul le fichier domo91.py est mis à jour sur product
+
+Tu ne touches ni aux autres fichiers, ni à l’historique Git
+
+Tu peux le faire à chaque fois que tu veux "promouvoir" un seul fichier vers la version stable
+
+
+
+
+
+a arranger
+
+
+(.venv) PS C:\Users\miche\PycharmProjects\Gestion sondes> git status
+On branch product
+Your branch is up to date with 'origin/product'.
+
+Changes to be committed:
+  (use "git restore --staged <file>..." to unstage)
+        modified:   domo91.py
+
+Changes not staged for commit:
+  (use "git add <file>..." to update what will be committed)
+  (use "git restore <file>..." to discard changes in working directory)
+        modified:   .idea/workspace.xml

From e536ab738d431513f958df458093da863aeeb390 Mon Sep 17 00:00:00 2001
From: Michel <michel@mj91.fr>
Date: Fri, 18 Apr 2025 11:56:23 +0200
Subject: [PATCH 11/12] =?UTF-8?q?Maj=20fichiers=20product=20=C3=A0=20parti?=
 =?UTF-8?q?r=20de=20develop?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...ur_product => MAJ_develop_sur_product.txt} | 24 +------------------
 1 file changed, 1 insertion(+), 23 deletions(-)
 rename tools/{Maj_develop_sur_product => MAJ_develop_sur_product.txt} (51%)

diff --git a/tools/Maj_develop_sur_product b/tools/MAJ_develop_sur_product.txt
similarity index 51%
rename from tools/Maj_develop_sur_product
rename to tools/MAJ_develop_sur_product.txt
index 59a0332..49ac08a 100644
--- a/tools/Maj_develop_sur_product
+++ b/tools/MAJ_develop_sur_product.txt
@@ -20,26 +20,4 @@ git push origin product
 ✅ Résultat :
 Seul le fichier domo91.py est mis à jour sur product
 
-Tu ne touches ni aux autres fichiers, ni à l’historique Git
-
-Tu peux le faire à chaque fois que tu veux "promouvoir" un seul fichier vers la version stable
-
-
-
-
-
-a arranger
-
-
-(.venv) PS C:\Users\miche\PycharmProjects\Gestion sondes> git status
-On branch product
-Your branch is up to date with 'origin/product'.
-
-Changes to be committed:
-  (use "git restore --staged <file>..." to unstage)
-        modified:   domo91.py
-
-Changes not staged for commit:
-  (use "git add <file>..." to update what will be committed)
-  (use "git restore <file>..." to discard changes in working directory)
-        modified:   .idea/workspace.xml
+Tu ne touches ni aux autres fichiers, ni à l’historique Git
\ No newline at end of file

From 91ccfda03f3d4ca25cd917b8d459015837654243 Mon Sep 17 00:00:00 2001
From: Michel <michel@mj91.fr>
Date: Fri, 18 Apr 2025 16:01:37 +0200
Subject: [PATCH 12/12] =?UTF-8?q?Nouvelle=20version=20avec=20cr=C3=A9ation?=
 =?UTF-8?q?=20de=20sondes,=20gestion=20des=20temp=5Fmax=20seulement=20en?=
 =?UTF-8?q?=20admin?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 domo91.py | 82 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 82 insertions(+)

diff --git a/domo91.py b/domo91.py
index dbddaa6..6df5cd9 100644
--- a/domo91.py
+++ b/domo91.py
@@ -7,6 +7,7 @@ import matplotlib.pyplot as plt
 import matplotlib.dates as mdates
 from fpdf import FPDF
 import os
+import random
 
 st.set_page_config(page_title="Domo91 - Surveillance", layout="wide")
 st.title("📡 Supervision Températures")
@@ -156,6 +157,7 @@ if st.session_state["authenticated"]:
             site_selectionne = st.session_state["lieu_autorise"]
             st.info(f"Site imposé : {site_selectionne}")
 
+
         selected_date = st.date_input("📅 Date du relevé", value=date.today())
         st.session_state["selected_date"] = selected_date
 
@@ -245,5 +247,85 @@ if st.session_state["authenticated"]:
 
     except Exception as e:
         st.error(f"Erreur MySQL : {e}")
+if st.session_state["role"] == "superviseur":
+    with st.expander("➕ Ajouter une nouvelle chambre froide", expanded=False):
+        with st.form("ajout_sonde"):
+            nouvelle_sonde = st.text_input("Nom de la sonde")
+            temp_max = st.number_input("Température maximale autorisée (°C)", value=4)
+            etat_on = st.checkbox("État actif (ON)", value=True)
+
+            submitted = st.form_submit_button("✅ Ajouter")
+            if submitted:
+                try:
+                    conn_add = mysql.connector.connect(**db_config)
+                    cursor_add = conn_add.cursor()
+
+                    cursor_add.execute(
+                        "INSERT INTO Chambres_froides (Lieu, Sonde, Temp_Max, Etat) VALUES (%s, %s, %s, %s)",
+                        (site_selectionne, nouvelle_sonde, temp_max, "ON" if etat_on else "OFF")
+                    )
+                    conn_add.commit()
+                    cursor_add.close()
+                    conn_add.close()
+
+                    st.success(f"Sonde '{nouvelle_sonde}' ajoutée avec succès au site {site_selectionne} 🎉")
+
+                    # Refresh immédiat
+                    st.session_state["refresh_admin"] = random.randint(1000, 9999)
+
+                except Exception as e:
+                    st.error(f"Erreur lors de l'ajout : {e}")
+    with st.expander("🛠️ Gestion des chambres froides (administrateur)", expanded=True):
+
+        # Bouton d'actualisation
+        if st.button("🔄 Actualiser la liste"):
+            st.session_state["refresh_admin"] = random.randint(0, 9999)  # Force le rerun
+
+        try:
+            conn_admin = mysql.connector.connect(**db_config)
+            cursor_admin = conn_admin.cursor(dictionary=True)
+
+            cursor_admin.execute("SELECT * FROM Chambres_froides WHERE Lieu = %s", (site_selectionne,))
+            chambres = cursor_admin.fetchall()
+
+            if not chambres:
+                st.warning("Aucune chambre froide pour ce site.")
+            else:
+                for chambre in chambres:
+                    col1, col2, col3 = st.columns([3, 1, 2])
+                    with col1:
+                        st.markdown(f"**{chambre['Sonde']}**")
+
+                    with col2:
+                        etat = st.checkbox("ON", value=(chambre["Etat"] == "ON"),
+                                           key=f"etat_{chambre['Id']}_{st.session_state.get('refresh_admin', 0)}")
+                        new_etat = "ON" if etat else "OFF"
+
+                    with col3:
+                        temp_max = chambre["Temp_Max"]
+                        moins, val, plus = st.columns([1, 2, 1])
+                        with moins:
+                            if st.button("➖", key=f"moins_{chambre['Id']}"):
+                                temp_max -= 1
+                        with val:
+                            st.markdown(f"<div style='text-align:center;font-size:20px'>{temp_max}°C</div>",
+                                        unsafe_allow_html=True)
+                        with plus:
+                            if st.button("➕", key=f"plus_{chambre['Id']}"):
+                                temp_max += 1
+
+                    if new_etat != chambre["Etat"] or temp_max != chambre["Temp_Max"]:
+                        cursor_admin.execute(
+                            "UPDATE Chambres_froides SET Etat = %s, Temp_Max = %s WHERE Id = %s",
+                            (new_etat, temp_max, chambre["Id"])
+                        )
+                        conn_admin.commit()
+                        st.success(f"{chambre['Sonde']} mise à jour")
+
+            cursor_admin.close()
+            conn_admin.close()
+
+        except Exception as e:
+            st.error(f"Erreur SQL (admin) : {e}")