**Refactor scheduling mechanism to use `schedule` library**

- Replace `APScheduler` with `schedule` for task scheduling
- Implement a background thread to run the scheduler
- Add utility functions to manage and clear scheduled tasks
- Update task planning functions to use the new scheduling approach
- Improve error handling and logging for task scheduling

app.py

@@ -199,7 +199,8 @@ stylekit = {
 
 if __name__ == "__main__":
     planning()
-    apsched.start()
+    scheduler_thread = threading.Thread(target=run_scheduler, daemon=True)
+    scheduler_thread.start()
     gui = Gui(pages=pages)
     gui.run(
         debug=True,

functi.py

@@ -12,16 +12,27 @@ from gradio_client import Client
 import pandas as pd
 from requests_oauthlib import OAuth2Session
 import requests
-
+import schedule
+import threading
 from timing_lin import *
 from apscheduler.schedulers.background import BackgroundScheduler
 from apscheduler.triggers.cron import CronTrigger
 from functools import partial
 
-# Create the scheduler globally (start it once)
-apsched = BackgroundScheduler()
+active_jobs = {}
+
+def run_scheduler():
+    """Fonction pour faire tourner le scheduler en arrière-plan"""
+    while True:
+        schedule.run_pending()
+        time.sleep(1)
 
 
+def clear_all_schedules():
+    """Fonction utilitaire pour supprimer toutes les tâches planifiées"""
+    schedule.clear()
+    print("🧹 Toutes les tâches ont été supprimées", flush=True)
+
 Linked_account_name = " "
 Linked_social_network = " "
 data_schedule ={}
@@ -74,12 +85,18 @@ def wait(delay):
     time.sleep(delay)
 
 def replanifier_toutes_les_tâches(df):
-     # Efface toutes les anciennes tâches
+    # Efface toutes les anciennes tâches
+    clear_all_schedules()
     df.apply(
-        lambda r: planifier_ligne(r["id"],r["id_social"], r["user_id"], r["schedule_time"],r["social_network"],r["adjusted_time"]),
+        lambda r: planifier_ligne_pub(r["id"],r["id_social"], r["user_id"], r["schedule_time"],r["social_network"],r["adjusted_time"]),
         axis=1
     )
 
+    df.apply(
+        lambda r: planifier_ligne_gen(r["id"],r["id_social"], r["user_id"], r["schedule_time"],r["social_network"],r["adjusted_time"]),
+        axis=1
+    )
+    
 def post_generation_for_robot(id,social,idd) :
     try :
         print("⏳ Tâche planifizzzzzzzzzzzzzzzée pour",flush = True)
@@ -190,7 +207,7 @@ def post_publishing_for_robot(id_social,id_user,idd,ss) :
 
 
 
-def planifier_ligne(id_schedule, id_social, user_id, schedule_time_str, ss, adjusted_time):
+def planifier_ligne_pub(id_schedule, id_social, user_id, schedule_time_str, ss, adjusted_time):
     # Parse schedule_time_str and adjusted_time
     parts = schedule_time_str.strip().split()
     part_adj = adjusted_time.strip().split()
@@ -211,15 +228,15 @@ def planifier_ligne(id_schedule, id_social, user_id, schedule_time_str, ss, adju
         print(f"❌ Heure invalide : {hm}", flush=True)
         return
 
-    # Map day names to APScheduler format
+    # Map day names to schedule format
     day_map = {
-        "monday": "mon",
-        "tuesday": "tue",
-        "wednesday": "wed",
-        "thursday": "thu",
-        "friday": "fri",
-        "saturday": "sat",
-        "sunday": "sun",
+        "monday": schedule.every().monday,
+        "tuesday": schedule.every().tuesday,
+        "wednesday": schedule.every().wednesday,
+        "thursday": schedule.every().thursday,
+        "friday": schedule.every().friday,
+        "saturday": schedule.every().saturday,
+        "sunday": schedule.every().sunday,
     }
 
     jour_key = jour.lower()
@@ -229,28 +246,109 @@ def planifier_ligne(id_schedule, id_social, user_id, schedule_time_str, ss, adju
         print(f"❌ Jour non reconnu : {jour}/{jour_adj}", flush=True)
         return
 
-    # Remove previous jobs for this schedule (optional, if you want to avoid duplicates)
-    try :
-        apsched.remove_job(f"pub-{id_schedule}-{schedule_time_str}--{id_social}", jobstore=None)
-        apsched.remove_job(f"gen-{id_schedule}-{schedule_time_str}--{id_social}", jobstore=None)
+    # Remove previous jobs for this schedule
+    pub_job_id = f"publop-{id_schedule}-{schedule_time_str}--{id_social}"
+    gen_job_id = f"gen-{id_schedule}-{schedule_time_str}--{id_social}"
+    
+    try:
+        # Supprimer les anciennes tâches si elles existent
+        if pub_job_id in active_jobs:
+            schedule.cancel_job(active_jobs[pub_job_id])
+            del active_jobs[pub_job_id]
+        
+        if gen_job_id in active_jobs:
+            schedule.cancel_job(active_jobs[gen_job_id])
+            del active_jobs[gen_job_id]
     except Exception as e:
         print(f"❌ Erreur lors de la suppression des tâches : {e}", flush=True)
 
     # Schedule publishing
-    apsched.add_job(
-        partial(post_publishing_for_robot, id_social, user_id, id_schedule, ss),
-        CronTrigger(day_of_week=day_map[jour_key], hour=hour, minute=minute),
-        id=f"pub-{id_schedule}-{schedule_time_str}--{id_social}"
+    pub_job = day_map[jour_key].at(f"{hour:02d}:{minute:02d}").do(
+        post_publishing_for_robot, id_social, user_id, id_schedule, ss
     )
+    pub_job.tag = pub_job_id
+    # active_jobs[pub_job_id] = pub_job
+
+    # Schedule generation
+    # gen_job = day_map[jour_key_adj].at(f"{hour_adj:02d}:{minute_adj:02d}").do(
+    #     post_generation_for_robot, user_id, id_social, id_schedule
+    # )
+    # gen_job.tag = gen_job_id
+    # active_jobs[gen_job_id] = gen_job
+    print(f"⏳ Scheduler: Tâche planifiée pour {pub_job.tag} ", flush=True)
+
+
+
+def planifier_ligne_gen(id_schedule, id_social, user_id, schedule_time_str, ss, adjusted_time):
+    # Parse schedule_time_str and adjusted_time
+    parts = schedule_time_str.strip().split()
+    part_adj = adjusted_time.strip().split()
+    if len(parts) != 2 or ':' not in parts[1]:
+        print(f"❌ Format invalide : {schedule_time_str}", flush=True)
+        return
+    if len(part_adj) != 2 or ':' not in part_adj[1]:
+        print(f"❌ Format invalide : {adjusted_time}", flush=True)
+        return
+
+    jour, hm = parts
+    jour_adj, hm_adj = part_adj
+
+    try:
+        hour, minute = map(int, hm.split(':'))
+        hour_adj, minute_adj = map(int, hm_adj.split(':'))
+    except ValueError:
+        print(f"❌ Heure invalide : {hm}", flush=True)
+        return
+
+    # Map day names to schedule format
+    day_map = {
+        "monday": schedule.every().monday,
+        "tuesday": schedule.every().tuesday,
+        "wednesday": schedule.every().wednesday,
+        "thursday": schedule.every().thursday,
+        "friday": schedule.every().friday,
+        "saturday": schedule.every().saturday,
+        "sunday": schedule.every().sunday,
+    }
+
+    jour_key = jour.lower()
+    jour_key_adj = jour_adj.lower()
+
+    if jour_key not in day_map or jour_key_adj not in day_map:
+        print(f"❌ Jour non reconnu : {jour}/{jour_adj}", flush=True)
+        return
+
+    # Remove previous jobs for this schedule
+    pub_job_id = f"publop-{id_schedule}-{schedule_time_str}--{id_social}"
+    gen_job_id = f"gen-{id_schedule}-{schedule_time_str}--{id_social}"
+    
+    try:
+        # Supprimer les anciennes tâches si elles existent
+        if pub_job_id in active_jobs:
+            schedule.cancel_job(active_jobs[pub_job_id])
+            del active_jobs[pub_job_id]
+        
+        if gen_job_id in active_jobs:
+            schedule.cancel_job(active_jobs[gen_job_id])
+            del active_jobs[gen_job_id]
+    except Exception as e:
+        print(f"❌ Erreur lors de la suppression des tâches : {e}", flush=True)
+
+    # # Schedule publishing
+    # pub_job = day_map[jour_key].at(f"{hour:02d}:{minute:02d}").do(
+    #     post_publishing_for_robot, id_social, user_id, id_schedule, ss
+    # )
+    # pub_job.tag = pub_job_id
+    # # active_jobs[pub_job_id] = pub_job
 
     # Schedule generation
-    apsched.add_job(
-        partial(post_generation_for_robot, user_id, id_social, id_schedule),
-        CronTrigger(day_of_week=day_map[jour_key_adj], hour=hour_adj, minute=minute_adj),
-        id=f"gen-{id_schedule}-{schedule_time_str}--{id_social}"
+    gen_job = day_map[jour_key_adj].at(f"{hour_adj:02d}:{minute_adj:02d}").do(
+        post_generation_for_robot, user_id, id_social, id_schedule
     )
+    gen_job.tag = gen_job_id
+    active_jobs[gen_job_id] = gen_job
 
-    print(f"⏳ APScheduler: Tâche planifiée pour {id_social} ({user_id}) le {jour} à {hour:02d}:{minute:02d} et {jour_adj} à {hour_adj:02d}:{minute_adj:02d}", flush=True)
+    print(f"⏳ Scheduler: Tâche planifiée pour {gen_job.tag} ", flush=True)
 
 def add_scheduling(state):
     """Add new scheduling with thread safety"""