Update server.py

server.py

@@ -8,7 +8,7 @@ import sqlite3
 import time
 from dotenv import load_dotenv
 
-DEMO_MODE = os.getenv("DEMO_MODE", "true").lower() == 'true'
+DEMO_MODE = os.getenv("DEMO_MODE", "False").lower() == 'true'
 # --- Load Environment & Configuration ---
 load_dotenv()
 try:
@@ -16,9 +16,9 @@ try:
     HF_DATASETS_AVAILABLE = True
 except ImportError:
     HF_DATASETS_AVAILABLE = False
-    Features, Value = None, None  # Define placeholders if import fails
+    Features, Value = None, None
 
-STORAGE_BACKEND_CONFIG = os.getenv("STORAGE_BACKEND", "HF_DATASET").upper()
+STORAGE_BACKEND_CONFIG = os.getenv("STORAGE_BACKEND", "JSON").upper()
 HF_DATASET_REPO = os.getenv("HF_DATASET_REPO")
 HF_TOKEN = os.getenv("HF_TOKEN")
 HF_BACKUP_THRESHOLD = int(os.getenv("HF_BACKUP_THRESHOLD", 10))
@@ -33,7 +33,7 @@ dirty_operations_count = 0
 def force_persist_data():
     global dirty_operations_count
     with db_lock:
-        storage_backend = STORAGE_BACKEND_CONFIG # Use a local copy for thread safety
+        storage_backend = STORAGE_BACKEND_CONFIG
         if storage_backend == "RAM":
             return True, "RAM backend. No persistence."
         elif storage_backend == "SQLITE":
@@ -81,8 +81,7 @@ def load_data():
     global STORAGE_BACKEND_CONFIG
     storage_backend = STORAGE_BACKEND_CONFIG
     with db_lock:
-        # Default empty structures
-        users, posts, comments = {"admin": "password"}, pd.DataFrame(columns=["post_id", "username", "content", "timestamp"]), pd.DataFrame(columns=["comment_id", "post_id", "username", "content", "timestamp"])
+        users, posts, comments = {"admin": "password"}, pd.DataFrame(columns=["post_id", "username", "content", "timestamp"]), pd.DataFrame(columns=["comment_id", "post_id", "username", "content", "timestamp", "reply_to_comment_id"])
 
         if storage_backend == "SQLITE":
             try:
@@ -90,7 +89,7 @@ def load_data():
                     cursor = conn.cursor()
                     cursor.execute("CREATE TABLE IF NOT EXISTS users (username TEXT PRIMARY KEY, password TEXT NOT NULL)")
                     cursor.execute("CREATE TABLE IF NOT EXISTS posts (post_id INTEGER PRIMARY KEY, username TEXT, content TEXT, timestamp TEXT)")
-                    cursor.execute("CREATE TABLE IF NOT EXISTS comments (comment_id INTEGER PRIMARY KEY, post_id INTEGER, username TEXT, content TEXT, timestamp TEXT)")
+                    cursor.execute("CREATE TABLE IF NOT EXISTS comments (comment_id INTEGER PRIMARY KEY, post_id INTEGER, username TEXT, content TEXT, timestamp TEXT, reply_to_comment_id INTEGER)")
                     cursor.execute("INSERT OR IGNORE INTO users (username, password) VALUES (?, ?)", ("admin", "password"))
                     conn.commit()
                     users = dict(conn.execute("SELECT username, password FROM users").fetchall())
@@ -125,7 +124,7 @@ def load_data():
                     try:
                         user_features = Features({'username': Value('string'), 'password': Value('string')})
                         post_features = Features({'post_id': Value('int64'), 'username': Value('string'), 'content': Value('string'), 'timestamp': Value('string')})
-                        comment_features = Features({'comment_id': Value('int64'), 'post_id': Value('int64'), 'username': Value('string'), 'content': Value('string'), 'timestamp': Value('string')})
+                        comment_features = Features({'comment_id': Value('int64'), 'post_id': Value('int64'), 'username': Value('string'), 'content': Value('string'), 'timestamp': Value('string'), 'reply_to_comment_id': Value('int64')})
                         
                         dataset_dict = DatasetDict({
                             'users': Dataset.from_pandas(pd.DataFrame(list(users.items()), columns=['username', 'password']), features=user_features),
@@ -141,11 +140,8 @@ def load_data():
                  print("HF_DATASET backend not fully configured (check env vars and library install). Falling back to RAM for this session.")
                  STORAGE_BACKEND_CONFIG = "RAM"
 
-    # Final validation of DataFrame structures
-    if not isinstance(posts, pd.DataFrame) or "post_id" not in posts.columns:
-        posts = pd.DataFrame(columns=["post_id", "username", "content", "timestamp"])
-    if not isinstance(comments, pd.DataFrame) or "comment_id" not in comments.columns:
-        comments = pd.DataFrame(columns=["comment_id", "post_id", "username", "content", "timestamp"])
+    if "reply_to_comment_id" not in comments.columns:
+        comments["reply_to_comment_id"] = None
         
     post_counter = int(posts['post_id'].max()) if not posts.empty else 0
     comment_counter = int(comments['comment_id'].max()) if not comments.empty else 0
@@ -184,7 +180,7 @@ def api_create_post(auth_token, content):
         handle_persistence_after_change()
     return f"[Post API] Success: Post created with ID {post_counter}."
 
-def api_create_comment(auth_token, post_id, content):
+def api_create_comment(auth_token, post_id, content, reply_to_comment_id=None):
     global comments_df, comment_counter
     username = _get_user_from_token(auth_token)
     if not username: return "[Comment API] Failed: Invalid auth token."
@@ -193,19 +189,46 @@ def api_create_comment(auth_token, post_id, content):
         try: target_post_id = int(post_id)
         except (ValueError, TypeError): return f"[Comment API] Failed: Post ID must be a number."
         if target_post_id not in posts_df['post_id'].values: return f"[Comment API] Failed: Post with ID {post_id} not found."
+        
+        target_reply_id = None
+        if reply_to_comment_id is not None:
+            try: target_reply_id = int(reply_to_comment_id)
+            except (ValueError, TypeError): return "[Comment API] Failed: Reply ID must be a number."
+            if target_reply_id not in comments_df['comment_id'].values: return f"[Comment API] Failed: Comment to reply to (ID {target_reply_id}) not found."
+
         comment_counter += 1
-        new_comment = pd.DataFrame([{"comment_id": comment_counter, "post_id": target_post_id, "username": username, "content": content, "timestamp": datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")}])
+        new_comment_data = {"comment_id": comment_counter, "post_id": target_post_id, "username": username, "content": content, "timestamp": datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S"), "reply_to_comment_id": target_reply_id}
+        new_comment = pd.DataFrame([new_comment_data])
         comments_df = pd.concat([comments_df, new_comment], ignore_index=True)
         handle_persistence_after_change()
     return f"[Comment API] Success: Comment created on post {post_id}."
 
+def _format_comments_threaded(post_id, all_comments_df, parent_id=None, depth=0):
+    thread = []
+    # Match NaN correctly for top-level comments
+    if parent_id is None:
+        children = all_comments_df[(all_comments_df['post_id'] == post_id) & (all_comments_df['reply_to_comment_id'].isna())]
+    else:
+        children = all_comments_df[all_comments_df['reply_to_comment_id'] == parent_id]
+        
+    for _, comment in children.iterrows():
+        indent = "  " * depth
+        thread.append(f"{indent}  - (ID: {comment['comment_id']}) @{comment['username']}: {comment['content']}")
+        thread.extend(_format_comments_threaded(post_id, all_comments_df, parent_id=comment['comment_id'], depth=depth + 1))
+    return thread
+
 def api_get_feed(search_query: str = None):
     with db_lock:
         current_posts, current_comments = posts_df.copy(), comments_df.copy()
     if current_posts.empty: return pd.DataFrame(columns=["post_id", "username", "content", "timestamp", "comments"])
     display_posts = current_posts[current_posts['content'].str.contains(search_query, case=False, na=False)] if search_query and not search_query.isspace() else current_posts
     sorted_posts = display_posts.sort_values(by="timestamp", ascending=False)
-    feed_data = [{"post_id": post['post_id'], "username": post['username'], "content": post['content'], "timestamp": post['timestamp'], "comments": "\n".join([f"  - @{c['username']}: {c['content']}" for _, c in current_comments[current_comments['post_id'] == post['post_id']].iterrows()])} for _, post in sorted_posts.iterrows()]
+    
+    feed_data = []
+    for _, post in sorted_posts.iterrows():
+        threaded_comments = _format_comments_threaded(post['post_id'], current_comments)
+        feed_data.append({"post_id": post['post_id'], "username": post['username'], "content": post['content'], "timestamp": post['timestamp'], "comments": "\n".join(threaded_comments)})
+        
     return pd.DataFrame(feed_data) if feed_data else pd.DataFrame(columns=["post_id", "username", "content", "timestamp", "comments"])
 
 # --- UI Helper Functions ---
@@ -218,17 +241,17 @@ def ui_manual_post(username, password, content):
     result = api_create_post(auth_token, content)
     return result, api_get_feed()
 
-def ui_manual_comment(username, password, post_id, content):
+def ui_manual_comment(username, password, post_id, reply_id, content):
     if not username or not password:
         return "Username and password are required.", api_get_feed()
     auth_token = api_login(username, password)
     if "Failed" in auth_token:
         return "Login failed. Check credentials.", api_get_feed()
-    result = api_create_comment(auth_token, post_id, content)
+    result = api_create_comment(auth_token, post_id, content, reply_to_comment_id=reply_id)
     return result, api_get_feed()
 
 with gr.Blocks(theme=gr.themes.Soft(), title="Social App") as demo:
-    gr.Markdown("# iLearnHub")
+    gr.Markdown("# Dummy Social Media Platform")
     gr.Markdown(f"This app provides an API for iLearn agents to interact with. **Storage Backend: `{STORAGE_BACKEND_CONFIG}`**")
     
     with gr.Tabs():
@@ -250,6 +273,7 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Social App") as demo:
                     comment_user = gr.Textbox(label="Username", value="admin")
                     comment_pass = gr.Textbox(label="Password", type="password", value="password")
                     comment_post_id = gr.Number(label="Target Post ID", precision=0)
+                    comment_reply_id = gr.Number(label="Reply to Comment ID (optional)", precision=0)
                     comment_content = gr.Textbox(label="Comment Content", lines=2, placeholder="Add a comment...")
                     comment_button = gr.Button("Submit Comment", variant="primary")
             with gr.Group():
@@ -269,19 +293,18 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Social App") as demo:
     )
     comment_button.click(
         fn=ui_manual_comment, 
-        inputs=[comment_user, comment_pass, comment_post_id, comment_content], 
+        inputs=[comment_user, comment_pass, comment_post_id, comment_reply_id, comment_content], 
         outputs=[manual_action_status, feed_df_display]
     )
     
-    last_refresh = time.time()
+    last_refresh_time = time.time()
     def timed_feed_refresh(interval):
-        global last_refresh
-        if time.time() - last_refresh > interval:
-            last_refresh = time.time()
+        global last_refresh_time
+        if time.time() - last_refresh_time > interval:
+            last_refresh_time = time.time()
             return api_get_feed()
         return gr.update()
 
-    # A fast-ticking timer that calls our function. The function itself decides if it's time to refresh.
     gr.Timer(1).tick(
         fn=timed_feed_refresh,
         inputs=[feed_refresh_interval_slider],
@@ -299,16 +322,12 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Social App") as demo:
     
     demo.load(api_get_feed, None, feed_df_display)
 
-    # Hidden API interfaces for the agent
     with gr.Column(visible=False if DEMO_MODE else True):
-        for name, func, inputs, outputs in [
-            ("register", api_register, ["text", gr.Textbox(type="password")], "text"),
-            ("login", api_login, ["text", gr.Textbox(type="password")], "text"),
-            ("create_post", api_create_post, ["text", "text"], "text"),
-            ("create_comment", api_create_comment, ["text", "number", "text"], "text"),
-            ("get_feed", api_get_feed, ["text"], "dataframe")
-        ]:
-            gr.Interface(func, inputs, outputs, api_name=name, allow_flagging="never")
+        gr.Interface(api_register, ["text", gr.Textbox(type="password")], "text", api_name="register", allow_flagging="never")
+        gr.Interface(api_login, ["text", gr.Textbox(type="password")], "text", api_name="login", allow_flagging="never")
+        gr.Interface(api_create_post, ["text", "text"], "text", api_name="create_post", allow_flagging="never")
+        gr.Interface(api_create_comment, ["text", "number", "text", "number"], "text", api_name="create_comment", allow_flagging="never")
+        gr.Interface(api_get_feed, ["text"], "dataframe", api_name="get_feed", allow_flagging="never")
 
 if __name__ == "__main__":
     print(f"Starting Social Media App server with {STORAGE_BACKEND_CONFIG} backend.")