so this script monitor the clipboard for any changes and automatically translate copied japanese text to english using gpt and then show the translation on a created window. can you make this script to not run shell and only the window instead? also make it to print any error on a new window

import time
import pyperclip
import openai
import json
import tkinter as tk
import threading
import os
from tkinter import font, Menu
from tkinter import font

# Set your OpenAI API key and base
openai.api_base = ""
openai.api_key = ""

# Global variables
pause_monitoring = False
dark_mode = False

# Storing prompt text
prompt_logfile = "prompt_eiyuuou.txt"
try:
    with open(prompt_logfile, "r", encoding="utf-8") as f:
        prompt_text = f.read()
except FileNotFoundError:
    # If the log file doesn’t exist, use the default prompt text
    prompt_text = "Translate the following text: {text_to_translate}"

# Keeping translation logs
KEEP_LOGS = False
translated_dict = {}
jsonfile = "eiyuuou_translation.json"
try:
    with open(jsonfile, "r", encoding="utf-8") as f:
        translated_dict = json.load(f)
except FileNotFoundError:
    pass

def translate_text(text_to_translate, prompt_template):
    prompt = prompt_template.format(text_to_translate=text_to_translate)
    completion = openai.ChatCompletion.create(
        model="gpt-3.5-turbo-0301",
        temperature=1,
        messages=[
            {
                "role": "user",
                "content": f"{prompt}",
            }
        ],
    )
    translated_text = (
        completion["choices"][0]
        .get("message")
        .get("content")
        .encode("utf8")
        .decode()
    )

    return translated_text

def update_display(display, text):
    display.delete(1.0, tk.END)
    display.insert(tk.END, text)

def retranslate():
    untranslated_text = untranslated_textbox.get(1.0, tk.END).strip()
    if untranslated_text:
        pyperclip.copy(untranslated_text)

def toggle_pause_monitoring():
    global pause_monitoring
    pause_monitoring = not pause_monitoring
    pause_button.config(
        text="Resume" if pause_monitoring else "Pause",
        relief=tk.SUNKEN if pause_monitoring else tk.RAISED
    )

def clipboard_monitor():
    global prompt_text
    old_clipboard = ""

    while True:
        if not pause_monitoring:
            new_clipboard = pyperclip.paste()

            # Remove line breaks from new_clipboard
            new_clipboard = new_clipboard.replace('\n', '').replace('\r', '')

            # Compare new_clipboard with old_clipboard to detect changes
            if new_clipboard != old_clipboard:
                old_clipboard = new_clipboard
                if new_clipboard in translated_dict:
                    translated_text = translated_dict[new_clipboard]
                else:
                    try:
                        prompt_text = prompt_textbox.get(1.0, tk.END).strip()
                        translated_text = translate_text(new_clipboard, prompt_text)
                    except Exception as e:
                        print(e, "Connection Error")
                        continue

                    translated_dict[new_clipboard] = translated_text
                    if KEEP_LOGS:
                        with open(jsonfile, "w", encoding="utf-8") as f:
                            json.dump(translated_dict, f, ensure_ascii=False, indent=4)

                update_display(untranslated_textbox, new_clipboard)
                update_display(translated_textbox, translated_text)

        time.sleep(1)

def toggle_translated():
    current_bg = translated_textbox.cget("background")
    if current_bg == "black":
        translated_textbox.configure(background="white")
        translated_textbox.delete(1.0, tk.END)
        try:
            translated_textbox.insert(tk.END, translated_dict[untranslated_textbox.get(1.0, tk.END).strip()])
        except Exception as e:
            pass
        toggle_button.config(text="Hide", relief=tk.RAISED)
    else:
        translated_textbox.configure(background="black")
        translated_textbox.delete(1.0, tk.END)
        toggle_button.config(text="Show", relief=tk.SUNKEN)

def save_prompt():
    global prompt_text
    current_prompt_text = prompt_textbox.get(1.0, tk.END).strip()
    if current_prompt_text != prompt_text:
        # Save any prompt_text changes to the log file
        prompt_text = current_prompt_text
        with open(prompt_logfile, "w", encoding="utf-8") as f:
            f.write(prompt_text)

def set_always_on_top():
    root.attributes("-topmost", always_on_top_var.get())

def increase_opacity():
    opacity = root.attributes("-alpha")
    opacity = min(opacity + 0.1, 1.0)
    root.attributes("-alpha", opacity)

def decrease_opacity():
    opacity = root.attributes("-alpha")
    opacity = max(opacity - 0.1, 0.1)
    root.attributes("-alpha", opacity)
    
def toggle_dark_mode():
    global dark_mode
    dark_mode = not dark_mode
    bg_color = "black" if dark_mode else "white"
    fg_color = "white" if dark_mode else "black"

    untranslated_textbox.configure(bg=bg_color, fg=fg_color)
    translated_textbox.configure(bg=bg_color, fg=fg_color)
    prompt_textbox.configure(bg=bg_color, fg=fg_color)
    root.configure(bg=bg_color)
    options_menu.configure(bg=bg_color, fg=fg_color)
    menu_bar.configure(bg=bg_color, fg=fg_color)

def font_window():
    global current_font
    current_font = {
        "family": font.Font(font=untranslated_textbox["font"]).actual("family"),
        "size": font.Font(font=untranslated_textbox["font"]).actual("size"),
        "color": untranslated_textbox.cget("foreground")
    }

    font_window = tk.Toplevel()
    font_window.title("Font Settings")
    font_window.geometry("150x150")

    font_family = tk.StringVar()
    font_family_label = tk.Label(font_window, text="Font Family")
    font_family_label.pack()
    font_family_entry = tk.Entry(font_window, textvariable=font_family)
    font_family_entry.insert(0, current_font["family"])
    font_family_entry.pack()

    font_size = tk.StringVar()
    font_size_label = tk.Label(font_window, text="Font Size")
    font_size_label.pack()
    font_size_entry = tk.Entry(font_window, textvariable=font_size)
    font_size_entry.insert(0, current_font["size"])
    font_size_entry.pack()

    font_color = tk.StringVar()
    font_color_label = tk.Label(font_window, text="Font Color")
    font_color_label.pack()
    font_color_entry = tk.Entry(font_window, textvariable=font_color)
    font_color_entry.insert(0, current_font["color"])
    font_color_entry.pack()

    def apply_changes():
        new_font_family = font_family.get() or current_font["family"]
        new_font_size = font_size.get() or current_font["size"]
        new_font_color = font_color.get() or current_font["color"]
        current_font = {"family": new_font_family, "size": new_font_size, "color": new_font_color}

        untranslated_textbox.configure(font=(current_font["family"], current_font["size"]), fg=current_font["color"])
        translated_textbox.configure(font=(current_font["family"], current_font["size"]), fg=current_font["color"])
        font_window.destroy()

    apply_button = tk.Button(font_window, text="Apply", command=apply_changes)
    apply_button.pack()

    cancel_button = tk.Button(font_window, text="Cancel", command=font_window.destroy)
    cancel_button.pack()

root = tk.Tk()
root.title("Clipboard Translator")
root.geometry("400x200")

menu_bar = Menu(root)

# Add Options menu
options_menu = Menu(menu_bar, tearoff=0)
menu_bar.add_cascade(label="Options", menu=options_menu)
options_menu.add_command(label="Save Prompt", command=save_prompt)
always_on_top_var = tk.BooleanVar(value=False)
options_menu.add_checkbutton(label="Always on top", variable=always_on_top_var, command=set_always_on_top)
dark_mode_var = tk.BooleanVar(value=False)
options_menu.add_checkbutton(label="Dark Mode", variable=dark_mode_var, command=toggle_dark_mode)
options_menu.add_command(label="Increase opacity", command=increase_opacity)
options_menu.add_command(label="Decrease opacity", command=decrease_opacity)
options_menu.add_command(label="Font", command=font_window)

root.config(menu=menu_bar)

paned_window = tk.PanedWindow(root, sashrelief="groove", sashwidth=5, orient="horizontal")
paned_window.pack(expand=True, fill="both")

untranslated_textbox = tk.Text(paned_window, wrap="word")
paned_window.add(untranslated_textbox)

translated_textbox = tk.Text(paned_window, wrap="word")
paned_window.add(translated_textbox)

prompt_textbox = tk.Text(paned_window, wrap="word")
paned_window.add(prompt_textbox)
update_display(prompt_textbox, prompt_text)

retranslate_button = tk.Button(root, text="Copy", command=retranslate)
retranslate_button.place(relx=0, rely=1, anchor="sw")

toggle_button = tk.Button(root, text="Hide", command=toggle_translated, relief=tk.RAISED)
toggle_button.place(relx=0.5, rely=1, anchor="s")

pause_button = tk.Button(root, text="Pause", command=toggle_pause_monitoring, relief=tk.RAISED)
pause_button.place(relx=1, rely=1, anchor="se")

if __name__ == "__main__":
    print("Starting Clipboard Translator…\n")
    clipboard_monitor_thread = threading.Thread(target=clipboard_monitor)
    clipboard_monitor_thread.start()
    root.mainloop()