app.py

import os
import json
import threading
import gradio as gr
import statistics
from scipy import stats
import numpy as np  # Added import for numpy to compute percentiles

DATA_DIR = './storage'
DATA_FILE = os.path.join(DATA_DIR, 'guesses.json')
lock = threading.Lock()

def ensure_data_directory():
    os.makedirs(DATA_DIR, exist_ok=True)

def load_guesses():
    ensure_data_directory()
    if not os.path.exists(DATA_FILE):
        with open(DATA_FILE, 'w') as f:
            json.dump([], f)
    with open(DATA_FILE, 'r') as f:
        return json.load(f)

def save_guesses(guesses):
    with open(DATA_FILE, 'w') as f:
        json.dump(guesses, f)

def add_guess(guess):
    with lock:
        guesses = load_guesses()
        guesses.append(guess)
        save_guesses(guesses)
    return compute_statistics(guesses, include_message=True)

def get_current_results():
    with lock:
        guesses = load_guesses()
    return compute_statistics(guesses, include_message=False)

def compute_statistics(guesses, include_message):
    n = len(guesses)
    if n == 0:
        return "No guesses have been made yet."
    
    average = sum(guesses) / n
    median = statistics.median(guesses)
    # Calculate IQR
    Q1 = np.percentile(guesses, 25)
    Q3 = np.percentile(guesses, 75)
    IQR = Q3 - Q1

    # Initialize the message
    message = (
        (f"Your guess has been recorded.\n" if include_message else "") +
        f"Current average of all {n} guesses: {average:.2f}\n" +
        f"Median of all guesses: {median:.2f}\n" +
        f"Interquartile Range (IQR): {IQR:.2f}\n" +
        "(The IQR is the range between the 25th percentile and 75th percentile of the data.)\n"
    )

    if n >= 2:
        # Calculate sample standard deviation
        s = statistics.stdev(guesses)
        # Calculate standard error
        SE = s / (n ** 0.5)
        # Degrees of freedom
        df = n - 1
        # Confidence level (e.g., 95%)
        confidence_level = 0.95
        alpha = 1 - confidence_level
        # Calculate critical t-value
        t_value = stats.t.ppf(1 - alpha/2, df)
        # Calculate margin of error
        ME = t_value * SE
        # Calculate confidence interval
        ci_lower = average - ME
        ci_upper = average + ME
        # Append confidence interval to the message
        message += f"95% confidence interval for the average: ({ci_lower:.2f}, {ci_upper:.2f})"
    else:
        # Not enough data to compute confidence interval
        message += "Not enough data to compute confidence interval for the average."
    
    return message

with gr.Blocks() as demo:
    gr.Markdown("# Collective Guessing Game")
    gr.Markdown("Submit your guess and contribute to the global statistics!")
    guess_input = gr.Number(label="Enter your guess")
    submit_button = gr.Button("Submit Guess")
    with gr.Accordion("View Current Results!", open=False):
        output_text = gr.Textbox(label="Results", lines=10)
        refresh_button = gr.Button("Refresh Results")
    submit_button.click(fn=add_guess, inputs=guess_input, outputs=output_text)
    refresh_button.click(fn=get_current_results, outputs=output_text)
    demo.load(fn=get_current_results, outputs=output_text)
    
demo.launch()