Update app.py

app.py

@@ -2,25 +2,23 @@ import gradio as gr
 import os
 import shutil
 import subprocess
-import pexpect
 import threading
+import time
 
-# Declare the global variable
-gradio_input_file = None
-process = None
+# Function to process the ebook and start the subprocess
+def process_ebook(ebook_file, state):
+    if not ebook_file:
+        return "No file uploaded.", state
 
-def process_ebook(ebook_file):
     # Pre-download the xtts TOS agreed file
     import download_tos_agreed_file
-    
+
     import nltk
     nltk.download('averaged_perceptron_tagger_eng')
     nltk.download('punkt_tab')
 
     # Download the en_core_web_sm spacy model
     subprocess.run(["python", "-m", "spacy", "download", "en_core_web_sm"])
-    
-    global gradio_input_file  # Use the global variable to store the ebook file path
 
     # Create input_files directory if it doesn't exist
     input_dir = "input_files"
@@ -31,45 +29,77 @@ def process_ebook(ebook_file):
     input_file_path = os.path.join(input_dir, os.path.basename(ebook_file))
     shutil.copy(ebook_file, input_file_path)
 
-    # Set the file path to the global variable
-    gradio_input_file = input_file_path
-
     # Print the name of the uploaded file
     ebook_file_name = os.path.basename(ebook_file)
-    print(f"Uploaded file: {ebook_file_name}")
-
-    # Initialize pexpect to run the subprocess and capture output
-    return run_subprocess()
-
-def run_subprocess():
-    global process
-    output = []
-
-    # Use pexpect to spawn the process and interact with it
-    process = pexpect.spawn(f"python3 Auto_VoxNovel.py {gradio_input_file}", encoding='utf-8', timeout=None)
-
-    def read_output():
-        while True:
-            try:
-                line = process.readline().strip()  # Read output from the subprocess
-                if line:  # If there's output, append it to the list
-                    output.append(line)
-                    yield "\n".join(output)  # Yield current output to display
-            except pexpect.EOF:
-                break  # End of file means the process has finished
-
-    return read_output()  # Call read_output() to return the actual generator
-
-
-
-def send_input(user_input):
-    global process
-    if process and process.isalive():
-        process.sendline(user_input)
-        return "Input sent!"
-    else:
-        return "Process is not running or already finished."
-
+    initial_output = f"Uploaded file: {ebook_file_name}\n"
+
+    # Initialize state with subprocess info
+    state = {
+        "process": None,
+        "output": initial_output,
+        "lock": threading.Lock()
+    }
+
+    # Start the subprocess in a separate thread
+    thread = threading.Thread(target=run_subprocess, args=(input_file_path, state), daemon=True)
+    thread.start()
+
+    return initial_output, state
+
+# Function to run the subprocess and capture its output
+def run_subprocess(input_file_path, state):
+    try:
+        # Start the subprocess
+        process = subprocess.Popen(
+            ["python3", "Auto_VoxNovel.py", input_file_path],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1  # Line-buffered
+        )
+
+        with state["lock"]:
+            state["process"] = process
+
+        # Continuously read the subprocess output
+        for line in iter(process.stdout.readline, ''):
+            with state["lock"]:
+                state["output"] += line
+        process.stdout.close()
+        process.wait()
+        with state["lock"]:
+            state["output"] += "\nProcess finished."
+    except Exception as e:
+        with state["lock"]:
+            state["output"] += f"\nError: {str(e)}"
+
+# Function to send user input to the subprocess
+def send_input(user_input, state):
+    if not state or "process" not in state or state["process"] is None:
+        return "Process is not running."
+
+    process = state["process"]
+    if process.poll() is not None:
+        return "Process has already finished."
+
+    try:
+        # Send the input followed by a newline
+        process.stdin.write(user_input + "\n")
+        process.stdin.flush()
+        return "Input sent successfully."
+    except Exception as e:
+        return f"Failed to send input: {str(e)}"
+
+# Function to update the output display
+def get_output(state):
+    if not state:
+        return "No process started."
+
+    with state["lock"]:
+        return state["output"]
+
+# Function to list output files for downloading
 def list_output_files():
     # List all files in the output directory for downloading
     output_dir = "output_audiobooks"
@@ -93,21 +123,17 @@ with gr.Blocks() as gui:
                 type='filepath'  # Specify that we want the file path
             )
             process_button = gr.Button("Start Processing")
-            status_output = gr.Textbox(label="Status")
-
-            # Function to update status with subprocess output
-            def update_status(ebook_input):
-                output_generator = process_ebook(ebook_input)  # Pass the file to process_ebook
-                
-                # Iterate through the generator and update status
-                for output in output_generator:
-                    status_output.value = output
-
-
+            status_output = gr.Textbox(label="Status", lines=20)
 
+            # Initialize state
+            state = gr.State()
 
             # Start processing and update status in real-time
-            process_button.click(update_status, inputs=ebook_input, outputs=status_output)
+            process_button.click(
+                process_ebook, 
+                inputs=[ebook_input, state], 
+                outputs=[status_output, state]
+            )
 
         with gr.Column():
             gr.Markdown("### Subprocess Input")
@@ -115,21 +141,34 @@ with gr.Blocks() as gui:
             # Textbox to allow user to send input to subprocess
             user_input_box = gr.Textbox(label="Send Input to Subprocess")
             submit_input_button = gr.Button("Submit Input")
-            submit_input_button.click(send_input, inputs=user_input_box, outputs=status_output)
+            submit_input_button.click(
+                send_input, 
+                inputs=[user_input_box, state], 
+                outputs="status_output"  # Optionally, you can have a separate output
+            )
 
         with gr.Column():
             gr.Markdown("### Download Generated Audiobook Files")
             download_button = gr.Button("Reload Files")
-            file_output = gr.Files(
+            file_output = gr.File(
                 label="Generated Audiobook Files",
-                type='filepath'  # Use 'filepath' type for gr.Files component
+                file_count="multiple",
+                type='file'  # Use 'file' type for gr.File component
             )
 
             # Update the file_output component with the list of output files
-            def update_output_files():
-                files = list_output_files()
-                return files
-
-            download_button.click(fn=update_output_files, inputs=[], outputs=file_output)
+            download_button.click(fn=list_output_files, inputs=[], outputs=file_output)
+
+    # Periodically update the status_output textbox
+    def periodic_update(state):
+        return get_output(state)
+
+    # Use Gradio's `every` method to update every second
+    gui.load(
+        periodic_update, 
+        inputs=state, 
+        outputs=status_output, 
+        every=1  # Update every second
+    )
 
 gui.launch()