Xyruxify Python GUI

import tkinter as tk
from tkinter import ttk
import random
import time
import threading

class RandomDataGeneratorApp:
    def __init__(self, master):
        self.master = master
        master.title("Random Data Generator & Visualizer")

        # --- Data Generation Parameters ---
        self.data_size_label = ttk.Label(master, text="Data Size:")
        self.data_size_label.grid(row=0, column=0, padx=5, pady=5, sticky=tk.W)
        self.data_size_entry = ttk.Entry(master)
        self.data_size_entry.grid(row=0, column=1, padx=5, pady=5, sticky=tk.E)
        self.data_size_entry.insert(0, "100") # Default value

        self.data_type_label = ttk.Label(master, text="Data Type:")
        self.data_type_label.grid(row=1, column=0, padx=5, pady=5, sticky=tk.W)
        self.data_type_combo = ttk.Combobox(master, values=["Integer", "Float", "String"])
        self.data_type_combo.grid(row=1, column=1, padx=5, pady=5, sticky=tk.E)
        self.data_type_combo.set("Integer") # Default value

        self.update_interval_label = ttk.Label(master, text="Update Interval (ms):")
        self.update_interval_label.grid(row=2, column=0, padx=5, pady=5, sticky=tk.W)
        self.update_interval_entry = ttk.Entry(master)
        self.update_interval_entry.grid(row=2, column=1, padx=5, pady=5, sticky=tk.E)
        self.update_interval_entry.insert(0, "500") # Default value

        # --- Generation & Display --- 
        self.generate_button = ttk.Button(master, text="Generate Data", command=self.start_data_generation)
        self.generate_button.grid(row=3, column=0, columnspan=2, padx=5, pady=5)

        self.data_text = tk.Text(master, height=10, width=40)
        self.data_text.grid(row=4, column=0, columnspan=2, padx=5, pady=5)

        self.stop_button = ttk.Button(master, text="Stop Generation", command=self.stop_data_generation, state=tk.DISABLED)
        self.stop_button.grid(row=5, column=0, columnspan=2, padx=5, pady=5)

        # --- Visualization (Simple Bar Chart) ---
        self.canvas = tk.Canvas(master, width=400, height=200, bg="white")
        self.canvas.grid(row=6, column=0, columnspan=2, padx=5, pady=5)
        self.max_bar_height = 180 #Canvas height - margin

        # --- Details Button --- 
        self.details_button = ttk.Button(master, text="Details", command=self.show_details)
        self.details_button.grid(row=7, column=0, columnspan=2, padx=5, pady=5)

        self.running = False  # Flag to control the data generation thread
        self.data_generation_thread = None # Store the thread object

    def start_data_generation(self):
        if not self.running:
            self.running = True
            self.generate_button['state'] = tk.DISABLED
            self.stop_button['state'] = tk.NORMAL
            self.data_generation_thread = threading.Thread(target=self.generate_data)
            self.data_generation_thread.daemon = True # Allow main thread to exit even if this thread is running
            self.data_generation_thread.start()

    def stop_data_generation(self):
        self.running = False
        self.generate_button['state'] = tk.NORMAL
        self.stop_button['state'] = tk.DISABLED

    def generate_data(self):
        try:
            data_size = int(self.data_size_entry.get())
            data_type = self.data_type_combo.get()
            update_interval = int(self.update_interval_entry.get())
        except ValueError:
            self.display_error("Invalid input. Please enter valid numbers.")
            self.stop_data_generation()
            return

        while self.running:
            data = []
            for _ in range(data_size):
                if data_type == "Integer":
                    data.append(random.randint(1, 100))
                elif data_type == "Float":
                    data.append(random.uniform(0.0, 100.0))
                elif data_type == "String":
                    data.append(random.choice(["apple", "banana", "cherry", "date", "fig"]))

            self.display_data(data)
            self.visualize_data(data)

            time.sleep(update_interval / 1000)

    def display_data(self, data):
        self.data_text.delete("1.0", tk.END)
        self.data_text.insert(tk.END, str(data))

    def visualize_data(self, data):
        self.canvas.delete("all") # Clear previous bars
        if not data:
            return

        bar_width = 400 / len(data) #canvas width / number of data points
        max_value = max(data)
        for i, value in enumerate(data):
            #Scale the value to the canvas height
            height = (value / max_value) * self.max_bar_height if max_value > 0 else 0
            x0 = i * bar_width
            y0 = 200 - height #canvas height - scaled height
            x1 = (i + 1) * bar_width
            y1 = 200
            self.canvas.create_rectangle(x0, y0, x1, y1, fill="blue")

    def display_error(self, message):
        self.data_text.delete("1.0", tk.END)
        self.data_text.insert(tk.END, "Error: " + message)

    def show_details(self):
        details_window = tk.Toplevel(self.master)
        details_window.title("Program Details")
        details_text = tk.Text(details_window, height=15, width=60)
        details_text.pack(padx=10, pady=10)
        details_text.insert(tk.END, """
        Xyruxify: Random Data Generator & Visualizer

        This program generates random data of specified types (Integer, Float, String) and displays it in both text format and as a simple bar chart.

        Functionality:
        1.  Data Generation:  Configure the size and type of random data to generate.
        2.  Real-time Visualization:  The generated data is displayed as a bar chart that updates dynamically.
        3.  Error Handling:  The program handles invalid input gracefully, preventing crashes.
        4.  Dynamic Updates:  The update interval can be adjusted to control the speed of data generation and visualization.

        This application provides a basic, but versatile, framework for demonstrating data generation and visualization concepts.
        """)
        details_text.config(state=tk.DISABLED) # Make the text read-only

root = tk.Tk()
app = RandomDataGeneratorApp(root)
root.mainloop()