This code is something I generated using ChatGPT while adding in my own prompts. While the main part of it works, some sections like error messages popping up even after the download has been successfully completed and and the percentage counter below the download bar not being updated happen. I also tried adding in a Function to check if the file already exists and prompt user but that just ended up showing an error message. It completely stops working when i execute it after converting it into an exe. While i made this needlessly complicated for something i made for fun, i cant rest without getting it working.

import os
import time
import logging
import threading
from tkinter import filedialog, StringVar, DoubleVar, IntVar
import tkinter as tk
import ttkbootstrap as ttk
from ttkbootstrap.constants import *
from ttkbootstrap.dialogs import Messagebox
from ttkbootstrap import Style
from pytube import YouTube
from pytube.exceptions import VideoUnavailable, RegexMatchError, PytubeError

# Setup logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s', filename='youtube_downloader.log', filemode='w')

# Number of retry attempts
RETRY_ATTEMPTS = 3

# Delay between retries in seconds
RETRY_DELAY = 5

# Enable high DPI awareness
try:
    from ctypes import windll
    windll.shcore.SetProcessDpiAwareness(1)
except Exception as e:
    logging.warning(f"Unable to set DPI awareness: {e}")

# Setup Tkinter GUI
style = Style(theme="darkly")
root = style.master
root.title("YouTube Video Downloader")

# Set minimum size and initial size
root.minsize(1500, 650)
root.geometry('1500x650')

# Global variable to control download cancellation
download_cancelled = IntVar(value=0)
running_processes = []
download_thread = None

# Function to handle errors and display error message box
def show_error_message(title, message):
    # Calculate the width and height of the error message box based on the length of the message
    width = max(len(message) * 10, 300)  # Adjust the multiplier and minimum width as needed
    height = max(message.count('n') * 20, 100)  # Adjust the multiplier and minimum height as needed
    Messagebox.show_error(title, message, width=width, height=height)

# a
def check_existing_file(url, save_path, resolution):
    filename = YouTube(url).title + resolution + ".mp4"
    filepath = os.path.join(save_path, filename)
    if os.path.exists(filepath):
        existing_file_size = os.path.getsize(filepath)
        yt = YouTube(url)
        stream = yt.streams.filter(res=resolution, progressive=True).first()
        if not stream:
            logging.error(f"Error: {resolution} stream not available.")
            root.after(0, Messagebox.show_error, "Error", f"{resolution} stream not available.")
            return
        new_file_size = stream.filesize
        if existing_file_size == new_file_size:
            logging.info("File with the same size already exists. Cancelling download.")
            root.after(0, Messagebox.show_info, "Info", "File with the same size already exists.")
            return
        else:
            logging.info("File with the same name but different size found.")
            response = root.after(0, Messagebox.ask_question, "Replace File", "A file with the same name but different size already exists. Do you want to replace it?")
            if response == "yes":
                os.remove(filepath)
                download_youtube_video_thread(url, save_path, resolution)
            else:
                logging.info("Download cancelled by user.")
                root.after(0, Messagebox.show_info, "Cancelled", "Download cancelled by user.")
                return
    else:
        download_youtube_video_thread(url, save_path, resolution)

# Function to initiate download of YouTube video
def start_download():
    global download_thread
    if download_thread and download_thread.is_alive():
        logging.info("Download already in progress.")
        root.after(0, Messagebox.show_info, "Info", "Download already in progress.")
        return
    url = url_var.get().strip()
    save_path = save_path_var.get().strip()
    resolution = resolution_var.get().strip()
    try:
        validate_url(url)
        validate_save_path(save_path)
        if not resolution:
            raise ValueError("No resolution selected. Please fetch and select a resolution.")
        download_cancelled.set(0)
        process_description = f"Downloading: {url}"
        running_processes.append(process_description)
        update_running_processes()
        download_thread = threading.Thread(target=check_existing_file, args=(url, save_path, resolution))
        download_thread.start()
    except ValueError as ve:
        error_message = str(ve)
        root.after(0, show_error_message, "Validation Error", error_message)  # Moved to the main thread
    except Exception as e:
        error_message = f"An unexpected error occurred: {e}"
        root.after(0, show_error_message, "Unexpected Error", error_message)  # Moved to the main thread

# Function to fetch video information from YouTube
def fetch_video_info_thread(url):
    try:
        validate_url(url)
        yt, resolutions = fetch_video_info(url)
        
        # Update resolution options in the main thread
        root.after(0, update_resolutions, resolutions)
        
        # Update video info in the main thread
        video_info_str = f"Title: {yt.title}nAuthor: {yt.author}nLength: {yt.length} secondsnViews: {yt.views}"
        root.after(0, update_video_info, video_info_str)
        
    except ValueError as ve:
        root.after(0, show_error_message, "Validation Error", str(ve))  # Moved to the main thread
    except Exception as e:
        root.after(0, show_error_message, "Unexpected Error", f"An unexpected error occurred: {e}")  # Moved to the main thread

def fetch_video_info(url):
    try:
        yt = YouTube(url)
        streams = yt.streams.filter(progressive=True)
        resolutions = [stream.resolution for stream in streams if stream.resolution]
        resolutions = list(set(resolutions))
        resolutions.sort(key=lambda x: int(x[:-1]), reverse=True)
        return yt, resolutions
    except (VideoUnavailable, RegexMatchError, PytubeError) as e:
        raise ValueError(f"Error fetching video info: {e}")
    except Exception as e:
        raise ValueError(f"Unexpected error: {e}")

def update_resolutions(resolutions):
    resolution_menu['menu'].delete(0, 'end')
    for res in resolutions:
        resolution_menu['menu'].add_command(label=res, command=lambda value=res: resolution_var.set(value))
    resolution_var.set(resolutions[0] if resolutions else "")

def update_video_info(info_str):
    video_info.set(info_str)

# Function to download a YouTube video
def download_youtube_video_thread(url, save_path, resolution):
    threading.Thread(target=download_youtube_video, args=(url, save_path, resolution)).start()

def download_youtube_video(url, save_path, resolution):
    global download_cancelled
    for attempt in range(RETRY_ATTEMPTS):
        if download_cancelled.get():
            logging.info("Download cancelled by user.")
            root.after(0, Messagebox.show_info, "Cancelled", "Download cancelled by user.")
            return

        try:
            yt = YouTube(url, on_progress_callback=progress_function)
            stream = yt.streams.filter(res=resolution, progressive=True).first()
            if not stream:
                logging.error(f"Error: {resolution} stream not available.")
                root.after(0, Messagebox.show_error, "Error", f"{resolution} stream not available.")
                return
            
            stream.download(save_path)
            logging.info(f"Downloaded: {yt.title}")
            running_processes.remove(f"Downloading: {yt.title}")
            update_running_processes()
            root.after(0, Messagebox.show_info, "Success", f"Downloaded: {yt.title}")
            return
        
        except VideoUnavailable:
            logging.error("Error: The video is unavailable.")
            root.after(0, Messagebox.show_error, "Error", "The video is unavailable.")
            return
        
        except RegexMatchError:
            logging.error("Error: The URL is invalid.")
            root.after(0, Messagebox.show_error, "Error", "The URL is invalid.")
            return
        
        except PytubeError as e:
            logging.error(f"Pytube error occurred on attempt {attempt + 1}: {e}")
        
        except Exception as e:
            logging.error(f"An unexpected error occurred on attempt {attempt + 1}: {e}")
        
        if attempt < RETRY_ATTEMPTS - 1:
            logging.info(f"Retrying in {RETRY_DELAY} seconds...")
            time.sleep(RETRY_DELAY)
        else:
            logging.error("Failed to download the video after several attempts.")
            root.after(0, Messagebox.show_error, "Error", "Failed to download the video after several attempts.")
            return

# Function to validate YouTube URL
def validate_url(url):
    if not (url.startswith("https://www.youtube.com/") or url.startswith("https://youtu.be/")):
        raise ValueError("Invalid URL. Please enter a valid YouTube video URL.")
    return url

# Function to validate save path
def validate_save_path(path):
    if not os.path.exists(path):
        raise ValueError("The specified path does not exist.")
    if not os.path.isdir(path):
        raise ValueError("The specified path is not a directory.")
    return path

# Function to select save path
def select_save_path():
    path = filedialog.askdirectory()
    save_path_var.set(path)

# Function to fetch resolutions for a given YouTube video
def fetch_resolutions():
    url = url_var.get().strip()
    process_description = f"Fetching resolutions for {url}"
    running_processes.append(process_description)
    update_running_processes()
    threading.Thread(target=fetch_video_info_thread, args=(url,)).start()

# Function to create context menu
def create_context_menu(entry):
    menu = ttk.Menu(entry, tearoff=0)
    menu.add_command(label="Paste", command=lambda: entry.event_generate("<<Paste>>"))
    
    def show_menu(event):
        menu.tk_popup(event.x_root, event.y_root)
    
    entry.bind("<Button-3>", show_menu)

# Function to cancel the download
def cancel_download():
    global download_cancelled
    download_cancelled.set(1)

# Progress function for updating progress bar
def progress_function(stream, chunk, bytes_remaining):
    total_size = stream.filesize
    bytes_downloaded = total_size - bytes_remaining
    percentage = bytes_downloaded / total_size * 100
    root.after(0, update_progress, percentage)

def update_progress(percentage):
    progress_var.set(percentage)

# Function to update running processes in the dropdown menu
def update_running_processes():
    processes_menu['menu'].delete(0, 'end')
    for process in running_processes:
        processes_menu['menu'].add_command(label=process)

# Custom Fonts and Colors
font_style = ("Helvetica", 12)

# Variables for GUI components
url_var = StringVar()
save_path_var = StringVar()
resolution_var = StringVar()
video_info = StringVar()
progress_var = DoubleVar()

# Labels and Entry Widgets
ttk.Label(root, text="YouTube URL:", font=font_style).grid(row=0, column=0, padx=10, pady=10, sticky='e')
url_entry = ttk.Entry(root, textvariable=url_var, width=50, font=font_style)
url_entry.grid(row=0, column=1, padx=10, pady=10, sticky='ew')
ttk.Button(root, text="Fetch Resolutions", style='primary.TButton', command=fetch_resolutions).grid(row=0, column=2, padx=10, pady=10, sticky='w')
create_context_menu(url_entry)

ttk.Label(root, text="Available Resolutions:", font=font_style).grid(row=1, column=0, padx=10, pady=10, sticky='e')
resolution_menu = ttk.OptionMenu(root, resolution_var, "")
resolution_menu.grid(row=1, column=1, padx=10, pady=10, sticky='ew')

ttk.Label(root, text="Save Path:", font=font_style).grid(row=2, column=0, padx=10, pady=10, sticky='e')
save_path_entry = ttk.Entry(root, textvariable=save_path_var, width=50, font=font_style)
save_path_entry.grid(row=2, column=1, padx=10, pady=10, sticky='ew')
ttk.Button(root, text="Browse", style='primary.TButton', command=select_save_path).grid(row=2, column=2, padx=10, pady=10, sticky='w')

ttk.Label(root, textvariable=video_info, font=font_style).grid(row=3, column=0, columnspan=3, padx=10, pady=10, sticky='nsew')

# Progress Bar
progress_frame = ttk.Frame(root)
progress_frame.grid(row=4, column=0, columnspan=3, padx=10, pady=10, sticky='ew')

progress_bar = ttk.Progressbar(progress_frame, variable=progress_var, maximum=100, style="success.Horizontal.TProgressbar")
progress_bar.pack(fill='x', padx=10, pady=5)

progress_label = ttk.Label(progress_frame, text="0%", font=font_style)
progress_label.pack(pady=5)

# Download and Cancel Buttons side by side and centered
button_frame = ttk.Frame(root)
button_frame.grid(row=5, column=0, columnspan=3, padx=10, pady=10)

ttk.Button(button_frame, text="Download", style='primary.TButton', command=start_download).pack(side='left', padx=5)
ttk.Button(button_frame, text="Cancel", style='danger.TButton', command=cancel_download).pack(side='left', padx=5)

# Running Processes Menu
processes_menu = ttk.OptionMenu(root, StringVar(), "")
processes_menu.grid(row=6, column=0, columnspan=3, padx=10, pady=10, sticky='ew')

root.mainloop()