Update app.py

app.py

@@ -2,88 +2,134 @@ import gradio as gr
 import threading
 import time
 from datetime import datetime
-from report_generator import generate_csv_report, generate_xlsx_report, generate_pdf_report
+from report_generator import (
+    generate_csv_report,
+    generate_xlsx_report,
+    generate_pdf_report,
+    generate_diagram_report,
+)
 
-def background_heartbeat():
-    """A continuous background task that logs a heartbeat every 60 seconds."""
+# Global containers for pending tasks and generated files.
+task_bucket = []
+generated_files = []
+
+# Lock for thread-safe updates.
+bucket_lock = threading.Lock()
+
+def background_task_processor():
+    """Background thread that processes tasks from the bucket every few seconds."""
     while True:
-        print(f"[{datetime.now()}] Heartbeat: background task active.")
-        time.sleep(60)
+        time.sleep(2)  # Check for tasks every 2 seconds.
+        with bucket_lock:
+            if task_bucket:
+                # Pop the first task and simulate processing delay.
+                task = task_bucket.pop(0)
+        if task:
+            print(f"[{datetime.now()}] Processing task: {task['command']}")
+            # Simulate timer countdown for processing (optimized delay)
+            for remaining in range(5, 0, -1):
+                task["timer"] = remaining
+                time.sleep(1)
+            # Process task based on command keywords.
+            cmd = task["command"].lower()
+            if "csv" in cmd:
+                filename = generate_csv_report()
+                task["result"] = "CSV report generated."
+            elif "xlsx" in cmd:
+                filename = generate_xlsx_report()
+                task["result"] = "XLSX report generated."
+            elif "pdf" in cmd:
+                filename = generate_pdf_report()
+                task["result"] = "PDF report generated."
+            elif "diagram" in cmd:
+                filename = generate_diagram_report()
+                task["result"] = "Diagram generated."
+            else:
+                # For unrecognized commands, simply echo back.
+                filename = None
+                task["result"] = f"Unrecognized command: {task['command']}"
+            if filename:
+                task["file"] = filename
+                generated_files.append(filename)
+            # Update the task status.
+            task["completed_at"] = datetime.now().strftime("%H:%M:%S")
+            # Signal the change (in a real app you might use websockets or polling)
+            print(f"[{datetime.now()}] Task completed: {task}")
+        # Clear the local variable so we don’t reprocess the same task.
+        task = None
 
-def process_command(user_input, chat_history):
+def submit_task(command, current_bucket):
     """
-    Process the user command and perform tasks accordingly.
-    
-    Commands:
-      - If the text includes 'csv', generate a CSV report.
-      - If the text includes 'xlsx', generate an XLSX report.
-      - If the text includes 'pdf', generate a PDF report.
-      - Otherwise, echo the user's input with a friendly response.
-    
-    Returns:
-      - Updated chat history (list of tuples).
-      - A list of generated file paths (if any).
+    Called when the user clicks Submit.
+    Adds the command to the task bucket along with a timestamp.
     """
-    response = ""
-    file_links = []
-    lower_input = user_input.lower()
-    if "csv" in lower_input:
-        filename = generate_csv_report()
-        response = "CSV report generated."
-        file_links.append(filename)
-    elif "xlsx" in lower_input:
-        filename = generate_xlsx_report()
-        response = "XLSX report generated."
-        file_links.append(filename)
-    elif "pdf" in lower_input:
-        filename = generate_pdf_report()
-        response = "PDF report generated."
-        file_links.append(filename)
-    else:
-        response = f"You said: {user_input}. How can I help further?"
-
-    chat_history.append((user_input, response))
-    return chat_history, file_links
+    if command.strip() == "":
+        return current_bucket, generated_files, ""
+    new_task = {
+        "command": command,
+        "submitted_at": datetime.now().strftime("%H:%M:%S"),
+        "timer": None,
+        "result": None,
+        "file": None,
+        "completed_at": None,
+    }
+    with bucket_lock:
+        task_bucket.append(new_task)
+        current_bucket.append(new_task)
+    return current_bucket, generated_files, ""
 
-def chat_interface(user_input, history):
+def refresh_status(bucket_state, file_state):
     """
-    The main function that gets called when the user submits a command.
-    It updates the conversation history and returns any generated files.
+    Returns updated task bucket and file list.
+    This function can be bound to an interval to update the UI.
     """
-    chat_history, file_links = process_command(user_input, history)
-    # Return updated conversation, the generated file(s), and update the state.
-    return chat_history, file_links, chat_history
+    return bucket_state, file_state
 
 def main():
-    # Start the background heartbeat thread (daemonized so it exits when the main app stops)
-    heartbeat_thread = threading.Thread(target=background_heartbeat, daemon=True)
-    heartbeat_thread.start()
+    # Start the background processor thread.
+    processor_thread = threading.Thread(target=background_task_processor, daemon=True)
+    processor_thread.start()
 
     with gr.Blocks() as demo:
-        gr.Markdown("# Interactive Chatbot and Report Generator")
+        gr.Markdown("# Advanced Task & Report Generator")
         gr.Markdown(
-            "Type commands into the textbox below. For example, try: "
-            "`generate csv report`, `generate xlsx report`, or `generate pdf report`."
+            "Submit your tasks (e.g., `generate csv report`, `generate diagram`, `generate pdf report`) "
+            "via the text input below. Tasks are added to the bucket, processed with an optimization timer, "
+            "and completed tasks generate downloadable files."
         )
         
         with gr.Row():
-            chatbot = gr.Chatbot(label="Chatbot Conversation")
-        with gr.Row():
-            txt = gr.Textbox(label="Enter Command", placeholder="Type your command here...")
-        with gr.Row():
-            # This component will display generated files as downloadable links.
-            file_output = gr.File(label="Generated Files", file_count="multiple")
+            with gr.Column(scale=8):
+                command_input = gr.Textbox(label="Enter Task Command", placeholder="e.g. generate xlsx report")
+            with gr.Column(scale=2):
+                submit_btn = gr.Button("Submit")
         
-        # A hidden state to store conversation history.
-        state = gr.State([])
-
-        # When the user submits a command, update the chatbot, file output, and state.
-        txt.submit(
-            chat_interface,
-            inputs=[txt, state],
-            outputs=[chatbot, file_output, state]
-        ).then(lambda _: "", None, txt)
+        # Display for task bucket.
+        bucket_output = gr.Dataframe(
+            headers=["submitted_at", "command", "timer", "result", "completed_at"],
+            label="Task Bucket",
+            interactive=False,
+        )
+        
+        # Timer display (this can show the global last task timer if needed)
+        timer_display = gr.Textbox(label="Latest Task Timer", interactive=False)
+        
+        # File output area: show downloadable files.
+        file_output = gr.Files(label="Generated Files", file_count="multiple")
+        
+        # Hidden states for tasks and file list.
+        bucket_state = gr.State([])
+        file_state = gr.State([])
 
+        # Define interactions:
+        submit_btn.click(
+            submit_task,
+            inputs=[command_input, bucket_state],
+            outputs=[bucket_output, file_output, command_input],
+        )
+        # Refresh status every few seconds (simulate a timer update).
+        demo.load(refresh_status, inputs=[bucket_state, file_state], outputs=[bucket_output, file_output])
+        
     demo.launch(server_name="0.0.0.0", server_port=7860)
 
 if __name__ == "__main__":