Update app.py

app.py

@@ -1,8 +1,13 @@
 import gradio as gr
 import multiprocessing
+import threading
 import time
+import os
 from math import isqrt
 
+# Path to save the primes
+PRIME_SAVE_PATH = "primes.txt"
+
 # Function to check if a number is prime
 def is_prime(n):
     if n < 2:
@@ -16,23 +21,35 @@ def is_prime(n):
             return False
     return True
 
-# Function to find the next prime number in a given range
+# Function to find primes in a given range
 def find_primes_in_range(start, end, queue):
     primes = [str(num) for num in range(start, end) if is_prime(num)]
     queue.put(primes)
 
-# Function that utilizes multiple processes to find primes
-def start_prime_printer():
-    num = 2  # Start from the first prime
-    batch_size = 1000  # Size of the range each process will handle
-    output = []
-    num_processes = multiprocessing.cpu_count()  # Utilize all available CPU cores
+# Function to load previously saved primes
+def load_saved_primes():
+    if os.path.exists(PRIME_SAVE_PATH):
+        with open(PRIME_SAVE_PATH, "r") as file:
+            return file.read().splitlines()
+    return []
+
+# Function to save new primes to file
+def save_primes_to_file(prime_list):
+    with open(PRIME_SAVE_PATH, "a") as file:
+        file.write("\n".join(prime_list) + "\n")
 
+# Background prime number generator function
+def prime_generator():
+    num = 2
+    batch_size = 1000
+    num_processes = multiprocessing.cpu_count()
+    prime_list = load_saved_primes()  # Load previously generated primes
+    
     while True:
         processes = []
         queue = multiprocessing.Queue()
         
-        # Create and start processes
+        # Start multiple processes to find primes in parallel
         for i in range(num_processes):
             start = num + i * batch_size
             end = start + batch_size
@@ -40,24 +57,38 @@ def start_prime_printer():
             process.start()
             processes.append(process)
         
-        # Collect results from all processes
+        # Collect primes from all processes
         for process in processes:
-            process.join()  # Wait for process to finish
-            primes = queue.get()  # Get primes from this process
-            output.extend(primes)
+            process.join()
+            primes = queue.get()
+            prime_list.extend(primes)
         
-        # Display the collected prime numbers
-        yield "\n".join(output)
+        # Save the newly found primes to the file
+        save_primes_to_file(primes)
         
         num += num_processes * batch_size
-        time.sleep(0.1)  # Adjust the sleep time if needed to manage UI responsiveness
+        time.sleep(0.1)  # Adjust this to control responsiveness and resource usage
+
+def start_background_thread():
+    thread = threading.Thread(target=prime_generator, daemon=True)
+    thread.start()
+
+# Function to display the primes in Gradio
+def display_primes():
+    prime_list = load_saved_primes()
+    while True:
+        yield "\n".join(prime_list)
+        time.sleep(1)  # Refresh interval
+
+# Start the background prime number generation
+start_background_thread()
 
 # Gradio Interface
 interface = gr.Interface(
-    fn=start_prime_printer,  # Function to execute
-    inputs=None,  # No input required
-    outputs="text",  # Output type
-    live=True  # Enable real-time updates
+    fn=display_primes,   # Display function
+    inputs=None,         # No inputs required
+    outputs="text",      # Output is a text field
+    live=True            # Enable live updates
 )
 
 # Launch the interface