Refactor functi.py: Remove unused imports and flags, simplify scheduling and posting logic

- Removed unused import `invoke_long_callback` from `taipy.gui`
- Removed unused flags for various actions
- Simplified `post_generation_for_robot` function by removing unnecessary newlines and improving formatting
- Refactored `add_scheduling` function to improve readability and maintain thread safety
- Simplified LinkedIn posting logic by removing redundant code and improving formatting
- Updated LinkedIn API request to use fetched user identification data
- Removed unnecessary comments and improved code organization

functi.py

@@ -7,7 +7,7 @@ import time
 import datetime
 from line_db import DatabaseManager
 from urllib.parse import urlencode
-from taipy.gui import navigate, invoke_long_callback # type: ignore
+from taipy.gui import navigate # type: ignore
 from gradio_client import Client
 import pandas as pd
 from requests_oauthlib import OAuth2Session
@@ -21,25 +21,9 @@ from apscheduler.triggers.cron import CronTrigger
 apsched = BackgroundScheduler()
 apsched.start()
 
-# Create flags for each action
-has_on_my_clicking = False
-has_add_source = False
-has_authen = False
-has_post_generation = False
-has_post_publishing = False
-has_add_scheduling = False
-has_on_login = False
-has_on_register = False
-has_on_logout = False
-has_toggle_register = False
-has_delete_account = False
-has_delete_schedule = False
-has_delete_source = False
-
 Linked_account_name = " "
 Linked_social_network = " "
 data_schedule ={}
-
 scope = ['openid', 'profile', 'email', 'w_member_social']
 
 time_value_hour = 18
@@ -100,9 +84,8 @@ def post_generation_for_robot(id,social,idd) :
         print("⏳ Tâche planifizzzzzzzzzzzzzzzée pour",flush = True)
         generated_post = client.predict(
             code=id,
-    		api_name="/poster_linkedin"
-
-)
+            api_name="/poster_linkedin"
+        )
         db_manager.add_post(social,generated_post,idd)
     except Exception as e:
             print("Erreur dans gen():", e, flush=True)
@@ -212,69 +195,60 @@ def planifier_ligne(id_schedule, id_social, user_id, schedule_time_str, ss, adju
 
 def add_scheduling(state):
     """Add new scheduling with thread safety"""
-    if not state.has_add_scheduling:
-        state.has_add_scheduling = True
-        try:
-            if isinstance(state.day_value, list):
-                for day in state.day_value:
-                    timesche = f"{day} {int(state.time_value_hour)}:{int(state.time_value_minute)}"
-
-                    # Get current schedule
-                    df = db_manager.fetch_schedule_table()
-
-                    if not df.empty:
-                        df, final_time = add_request(df, timesche)
-                    else:
-                        jour, horaire = timesche.split()
-                        horaire = horaire.replace(';', ':')
-                        h, m = map(int, horaire.split(':'))
-                        m -= 7  # 7 minutes before for generation
-                        final_time = f"{jour} {h}:{m:02d}"
-
-                    # Add to database
-                    db_manager.create_scheduling_for_user(
-                        state.user_inf.user.id,
-                        state.Linked_social_network,
-                        timesche,
-                        final_time
-                    )
-            else:
-                timesche = f"{state.day_value} {int(state.time_value_hour)}:{int(state.time_value_minute)}"
-
-                # Get current schedule
-                df = db_manager.fetch_schedule_table()
-
-                if not df.empty:
-                    df, final_time = add_request(df, timesche)
-                else:
-                    jour, horaire = timesche.split()
-                    horaire = horaire.replace(';', ':')
-                    h, m = map(int, horaire.split(':'))
-                    m -= 7  # 7 minutes before for generation
-                    final_time = f"{jour} {h}:{m:02d}"
-
-                # Add to database
-                db_manager.create_scheduling_for_user(
-                    state.user_inf.user.id,
-                    state.Linked_social_network,
-                    timesche,
-                    final_time
-                )
-
-            # Refresh the schedule after adding
+    if isinstance(state.day_value, list):
+        for day in state.day_value:
+            timesche = f"{day} {int(state.time_value_hour)}:{int(state.time_value_minute)}"
+
+            # Get current schedule
             df = db_manager.fetch_schedule_table()
-            state.data_schedule = db_manager.fetch_schedule_table_acc(state.user_inf.user.id)
 
-            # Reschedule all tasks
-            replanifier_toutes_les_tâches(df)
+            if not df.empty:
+                df, final_time = add_request(df, timesche)
+            else:
+                jour, horaire = timesche.split()
+                horaire = horaire.replace(';', ':')
+                h, m = map(int, horaire.split(':'))
+                m -= 7  # 7 minutes before for generation
+                final_time = f"{jour} {h}:{m:02d}"
+
+            # Add to database
+            db_manager.create_scheduling_for_user(
+                state.user_inf.user.id,
+                state.Linked_social_network,
+                timesche,
+                final_time
+            )
+    else:
+        timesche = f"{state.day_value} {int(state.time_value_hour)}:{int(state.time_value_minute)}"
+
+        # Get current schedule
+        df = db_manager.fetch_schedule_table()
+
+        if not df.empty:
+            df, final_time = add_request(df, timesche)
+        else:
+            jour, horaire = timesche.split()
+            horaire = horaire.replace(';', ':')
+            h, m = map(int, horaire.split(':'))
+            m -= 7  # 7 minutes before for generation
+            final_time = f"{jour} {h}:{m:02d}"
+
+        # Add to database
+        db_manager.create_scheduling_for_user(
+            state.user_inf.user.id,
+            state.Linked_social_network,
+            timesche,
+            final_time
+        )
 
-            print(f"✅ Scheduling added successfully", flush=True)
+    # Refresh the schedule after adding
+    df = db_manager.fetch_schedule_table()
+    state.data_schedule = db_manager.fetch_schedule_table_acc(state.user_inf.user.id)
 
-        except Exception as e:
-            print(f"❌ Error in add_scheduling: {e}", flush=True)
+    # Reschedule all tasks
+    replanifier_toutes_les_tâches(df)
 
-        # Utiliser invoke_long_callback pour la réinitialisation du flag
-        invoke_long_callback(state, wait, [2.0], reset_flag, ["add_scheduling", True])
+    print(f"✅ Scheduling added successfully", flush=True)
 
 def planning():
     df = db_manager.fetch_schedule_table()
@@ -282,275 +256,185 @@ def planning():
         replanifier_toutes_les_tâches(df)
 
 def post_publishing(state) :
-    if not state.has_post_publishing:
-        state.has_post_publishing = True
-
-        resp = db_manager.fetching_user_identif(state.user_inf.user.id,state.social_network)
-        data = pd.DataFrame(resp.data)
-
-        first = data[data['social_network'] == state.social_network].iloc[0]
-        token_value = first["token"]
-        sub_value = first["sub"]
-
-        url = "https://api.linkedin.com/v2/ugcPosts"
-        headers = {
-            "Authorization": f"Bearer {token_value}",
-            "X-Restli-Protocol-Version": "2.0.0",
-            "Content-Type": "application/json"
-        }
-        body = {
-            "author": f"urn:li:person:{sub_value}",
-            "lifecycleState": "PUBLISHED",
-            "specificContent": {
-                "com.linkedin.ugc.ShareContent": {
-                    "shareCommentary": {
-                        "text": state.generated_post
-                    },
-                    "shareMediaCategory": "NONE"
-                }
-            },
-            "visibility": {
-                "com.linkedin.ugc.MemberNetworkVisibility": "PUBLIC"
+    resp = db_manager.fetching_user_identif(state.user_inf.user.id,state.social_network)
+    data = pd.DataFrame(resp.data)
+
+    first = data[data['social_network'] == state.social_network].iloc[0]
+    token_value = first["token"]
+    sub_value = first["sub"]
+
+    url = "https://api.linkedin.com/v2/ugcPosts"
+    headers = {
+        "Authorization": f"Bearer {token_value}",
+        "X-Restli-Protocol-Version": "2.0.0",
+        "Content-Type": "application/json"
+    }
+    body = {
+        "author": f"urn:li:person:{sub_value}",
+        "lifecycleState": "PUBLISHED",
+        "specificContent": {
+            "com.linkedin.ugc.ShareContent": {
+                "shareCommentary": {
+                    "text": state.generated_post
+                },
+                "shareMediaCategory": "NONE"
             }
+        },
+        "visibility": {
+            "com.linkedin.ugc.MemberNetworkVisibility": "PUBLIC"
         }
+    }
 
-        resp = requests.post(url, headers=headers, json=body)
-        print([resp.status_code, resp.text],flush = True)
-
-        # Utiliser invoke_long_callback pour la réinitialisation du flag
-        invoke_long_callback(state, wait, [2.0], reset_flag, ["post_publishing", True])
+    resp = requests.post(url, headers=headers, json=body)
+    print([resp.status_code, resp.text],flush = True)
 
 def post_generation(state) :
-    if not state.has_post_generation:
-        state.has_post_generation = True
-        state.generated_post = client.predict(
-            code=state.user_inf.user.id,
-            api_name="/poster_linkedin"
-        )
-
-        # Utiliser invoke_long_callback pour la réinitialisation du flag
-        invoke_long_callback(state, wait, [2.0], reset_flag, ["post_generation", True])
+    state.generated_post = client.predict(
+        code=state.user_inf.user.id,
+        api_name="/poster_linkedin"
+    )
 
 def authen(state) :
-    if not state.has_authen:
-        state.has_authen = True
-        if state.Linked_social_network == "Linkedin" :
-            print("jhdijb",flush = True)
-            state.urlss, state.states = linkedin.authorization_url(
+    if state.Linked_social_network == "Linkedin" :
+        print("jhdijb",flush = True)
+        state.urlss, state.states = linkedin.authorization_url(
             'https://www.linkedin.com/oauth/v2/authorization'
         )
         navigate(state, state.urlss)
 
-        # Utiliser invoke_long_callback pour la réinitialisation du flag
-        invoke_long_callback(state, wait, [2.0], reset_flag, ["authen", True])
-
-def reset_flag(state, action, success):
-    if action == "on_my_clicking":
-        state.has_on_my_clicking = False
-    elif action == "add_source":
-        state.has_add_source = False
-    elif action == "authen":
-        state.has_authen = False
-    elif action == "post_generation":
-        state.has_post_generation = False
-    elif action == "post_publishing":
-        state.has_post_publishing = False
-    elif action == "add_scheduling":
-        state.has_add_scheduling = False
-    elif action == "on_login":
-        state.has_on_login = False
-    elif action == "on_register":
-        state.has_on_register = False
-    elif action == "on_logout":
-        state.has_on_logout = False
-    elif action == "toggle_register":
-        state.has_toggle_register = False
-    elif action == "delete_account":
-        state.has_delete_account = False
-    elif action == "delete_schedule":
-        state.has_delete_schedule = False
-    elif action == "delete_source":
-        state.has_delete_source = False
-
 def on_my_clicking(state, action, payload) :
-    if not state.has_on_my_clicking:
-        state.has_on_my_clicking = True
-        print(action,flush = True)
-        print(payload["args"][0],flush = True)
-        if payload["args"][0] == "Accueil" :
-            on_logout(state)
-        navigate(state, payload["args"][0])
-        # Utiliser invoke_long_callback pour la réinitialisation du flag
-        invoke_long_callback(state, wait, [2.0], reset_flag, ["on_my_clicking", True])
+    print(action,flush = True)
+    print(payload["args"][0],flush = True)
+    if payload["args"][0] == "Accueil" :
+        on_logout(state)
+    navigate(state, payload["args"][0])
 
     return " "
 
 def add_source(state) :
-    if not state.has_add_source:
-        state.has_add_source = True
-
-        result = client.predict(
-                rss_link=state.source_ + "__thi_irrh'èçs_my_id__! "+state.user_inf.user.id,
-                api_name="/ajouter_rss"
-        )
-
-        state.source_add_message = result
-        data = db_manager.fetch_source_table(state.user_inf.user.id)
-        state.Source_table = pd.DataFrame(data)
+    result = client.predict(
+            rss_link=state.source_ + "__thi_irrh'èçs_my_id__! "+state.user_inf.user.id,
+            api_name="/ajouter_rss"
+    )
 
-        # Utiliser invoke_long_callback pour la réinitialisation du flag
-        invoke_long_callback(state, wait, [2.0], reset_flag, ["add_source", True])
+    state.source_add_message = result
+    data = db_manager.fetch_source_table(state.user_inf.user.id)
+    state.Source_table = pd.DataFrame(data)
 
 def delete_source(state, var_name: str, payload: dict) :
-    if not state.has_delete_source:
-        state.has_delete_source = True
-        state.Source_table_before = state.Source_table
-        state.get_gui().table_on_delete(state, var_name, payload)
-
-        diff = state.Source_table_before.merge(state.Source_table, how="outer", indicator=True) \
-              .query('_merge != "both"') \
-              .drop(columns='_merge')
-        valeurs = diff['id'].tolist()
-        db_manager.delete_from_table("Source",valeurs)
+    state.Source_table_before = state.Source_table
+    state.get_gui().table_on_delete(state, var_name, payload)
 
-        # Utiliser invoke_long_callback pour la réinitialisation du flag
-        invoke_long_callback(state, wait, [2.0], reset_flag, ["delete_source", True])
+    diff = state.Source_table_before.merge(state.Source_table, how="outer", indicator=True) \
+          .query('_merge != "both"') \
+          .drop(columns='_merge')
+    valeurs = diff['id'].tolist()
+    db_manager.delete_from_table("Source",valeurs)
 
 def delete_account(state, var_name: str, payload: dict) :
-    if not state.has_delete_account:
-        state.has_delete_account = True
-        state.data_account_before = state.data_account
-        state.get_gui().table_on_delete(state, var_name, payload)
+    state.data_account_before = state.data_account
+    state.get_gui().table_on_delete(state, var_name, payload)
 
-        diff = state.data_account_before.merge(state.data_account, how="outer", indicator=True) \
-              .query('_merge != "both"') \
-              .drop(columns='_merge')
-        valeurs = diff['id'].tolist()
-        db_manager.delete_from_table("Social_network",valeurs)
-
-        # Utiliser invoke_long_callback pour la réinitialisation du flag
-        invoke_long_callback(state, wait, [2.0], reset_flag, ["delete_account", True])
+    diff = state.data_account_before.merge(state.data_account, how="outer", indicator=True) \
+          .query('_merge != "both"') \
+          .drop(columns='_merge')
+    valeurs = diff['id'].tolist()
+    db_manager.delete_from_table("Social_network",valeurs)
 
 def delete_schedule(state, var_name: str, payload: dict) :
-    if not state.has_delete_schedule:
-        state.has_delete_schedule = True
-        state.data_schedule_before = state.data_schedule
-        state.get_gui().table_on_delete(state, var_name, payload)
-
-        diff = state.data_schedule_before.merge(state.data_schedule, how="outer", indicator=True) \
-              .query('_merge != "both"') \
-              .drop(columns='_merge')
-        valeurs = diff['id'].tolist()
-        db_manager.delete_from_table("Scheduling",valeurs)
+    state.data_schedule_before = state.data_schedule
+    state.get_gui().table_on_delete(state, var_name, payload)
 
-        # Utiliser invoke_long_callback pour la réinitialisation du flag
-        invoke_long_callback(state, wait, [2.0], reset_flag, ["delete_schedule", True])
+    diff = state.data_schedule_before.merge(state.data_schedule, how="outer", indicator=True) \
+          .query('_merge != "both"') \
+          .drop(columns='_merge')
+    valeurs = diff['id'].tolist()
+    db_manager.delete_from_table("Scheduling",valeurs)
 
 def on_login(state, payload):
     """Handle login form submission"""
-    if not state.has_on_login:
-        state.has_on_login = True
-        time.sleep(0.7)
-        email = state.login_email
-        password = state.login_password
-
-        if not email or not password:
-            state.message = "Please enter both email and password"
-            return
-
-        success, message, user_inf = db_manager.authenticate_user(email, password)
-
-        if user_inf is None:
-            # Handle the case when authentication fails
-            state.message = message
-            return
-
-        if success:
-            state.current_user = email
-            data = db_manager.fetch_source_table(user_inf.user.id)
-            dataac = db_manager.fetch_account_table(user_inf.user.id)
-            state.data_schedule = db_manager.fetch_schedule_table_acc(user_inf.user.id)
-            state.data_account = pd.DataFrame(dataac)
-            state.Source_table = pd.DataFrame(data)
-            navigate(state, "Source_Management")
-            state.is_logged_in = True
-            state.message = f"Welcome back, {email}!"
-            # Clear form
-            state.login_email = ""
-            state.login_password = ""
-        else:
-            if message == "Compte non confirmé":
-                state.message = "Votre compte n'est pas encore activé. Veuillez vérifier votre email pour activer votre compte."
-            elif message == "Compte non existant":
-                state.message = "Email ou mot de passe incorrect."
-            else:
-                state.message = "Email ou mot de passe incorrect."
+    time.sleep(0.7)
+    email = state.login_email
+    password = state.login_password
+
+    if not email or not password:
+        state.message = "Please enter both email and password"
+        return
 
-        # Utiliser invoke_long_callback pour la réinitialisation du flag
-        invoke_long_callback(state, wait, [2.0], reset_flag, ["on_login", True])
+    success, message, user_inf = db_manager.authenticate_user(email, password)
 
-def on_register(state):
-    """Handle registration form submission"""
-    if not state.has_on_register:
-        state.has_on_register = True
-        time.sleep(0.7)
-        email = state.register_email
-        password = state.register_password
-        confirm_password = state.confirm_password
-
-        if not email or not password or not confirm_password:
-            state.message = "Please fill in all fields"
-            return
-
-        if password != confirm_password:
-            state.message = "Passwords do not match"
-            return
-
-        if len(password) < 8:
-            state.message = "Password must be at least 8 characters long"
-            return
-
-        success, message,user_inf = db_manager.create_user(email, password) # type: ignore
-
-        if success:
-            state.message = "Un lien d'activation a été envoyé à votre adresse email. Veuillez vérifier votre boîte de réception pour activer votre compte."
-            state.show_register = False
-            # Clear form
-            state.register_email = ""
-            state.register_password = ""
-            state.confirm_password = ""
+    if user_inf is None:
+        # Handle the case when authentication fails
+        state.message = message
+        return
+
+    if success:
+        state.current_user = email
+        data = db_manager.fetch_source_table(user_inf.user.id)
+        dataac = db_manager.fetch_account_table(user_inf.user.id)
+        state.data_schedule = db_manager.fetch_schedule_table_acc(user_inf.user.id)
+        state.data_account = pd.DataFrame(dataac)
+        state.Source_table = pd.DataFrame(data)
+        navigate(state, "Source_Management")
+        state.is_logged_in = True
+        state.message = f"Welcome back, {email}!"
+        # Clear form
+        state.login_email = ""
+        state.login_password = ""
+    else:
+        if message == "Compte non confirmé":
+            state.message = "Votre compte n'est pas encore activé. Veuillez vérifier votre email pour activer votre compte."
+        elif message == "Compte non existant":
+            state.message = "Email ou mot de passe incorrect."
         else:
-            state.message = message or "Erreur lors de l'inscription. Veuillez réessayer."
+            state.message = "Email ou mot de passe incorrect."
 
-        # Utiliser invoke_long_callback pour la réinitialisation du flag
-        invoke_long_callback(state, wait, [2.0], reset_flag, ["on_register", True])
+def on_register(state):
+    """Handle registration form submission"""
+    time.sleep(0.7)
+    email = state.register_email
+    password = state.register_password
+    confirm_password = state.confirm_password
 
-def on_logout(state):
-    if not state.has_on_logout:
-        state.has_on_logout = True
+    if not email or not password or not confirm_password:
+        state.message = "Please fill in all fields"
+        return
 
-        """Handle logout"""
+    if password != confirm_password:
+        state.message = "Passwords do not match"
+        return
 
-        state.current_user = None
-        state.is_logged_in = False
-        state.message = "Logged out successfully"
-        state.login_email = ""
-        state.login_password = ""
+    if len(password) < 8:
+        state.message = "Password must be at least 8 characters long"
+        return
 
-        # Utiliser invoke_long_callback pour la réinitialisation du flag
-        invoke_long_callback(state, wait, [2.0], reset_flag, ["on_logout", True])
+    success, message,user_inf = db_manager.create_user(email, password) # type: ignore
 
-def toggle_register(state):
-    """Toggle between login and register forms"""
-    if not state.has_toggle_register:
-        state.has_toggle_register = True
-        state.show_register = not state.show_register
-        state.message = ""
-        state.login_email = ""
-        state.login_password = ""
+    if success:
+        state.message = "Un lien d'activation a été envoyé à votre adresse email. Veuillez vérifier votre boîte de réception pour activer votre compte."
+        state.show_register = False
+        # Clear form
         state.register_email = ""
         state.register_password = ""
         state.confirm_password = ""
+    else:
+        state.message = message or "Erreur lors de l'inscription. Veuillez réessayer."
 
-        # Utiliser invoke_long_callback pour la réinitialisation du flag
-        invoke_long_callback(state, wait, [2.0], reset_flag, ["toggle_register", True])
+def on_logout(state):
+    """Handle logout"""
+
+    state.current_user = None
+    state.is_logged_in = False
+    state.message = "Logged out successfully"
+    state.login_email = ""
+    state.login_password = ""
+
+def toggle_register(state):
+    """Toggle between login and register forms"""
+    state.show_register = not state.show_register
+    state.message = ""
+    state.login_email = ""
+    state.login_password = ""
+    state.register_email = ""
+    state.register_password = ""
+    state.confirm_password = ""