CodeTranslator.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8fadb09f-61c0-4d9e-b850-45939eb9be69",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "731bd304-8042-498e-9161-9e8ad0cff79f",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *  # Importing tkinter for GUI elements\n",
    "import tkinter as tk  # Importing tkinter as tk for convenience\n",
    "from tkinter import ttk, messagebox, filedialog  # Importing specific tkinter modules\n",
    "import googletrans  # Importing googletrans for language translation\n",
    "from googletrans import Translator  # Importing Translator class from googletrans\n",
    "import pyttsx3  # Importing pyttsx3 for text-to-speech functionality\n",
    "import speech_recognition as sr  # Importing speech_recognition for speech-to-text functionality\n",
    "import customtkinter  # Importing customtkinter for custom styled tkinter widgets\n",
    "from PIL import Image # Import the Image class from the PIL (Pillow) library.The PIL library is used for opening, manipulating, and saving many different image file formats.\n",
    "import pytesseract # pytesseract is a Python wrapper for Google's Tesseract-OCR Engine, which is used for Optical Character Recognition (OCR).\n",
    "\n",
    "#Update this path to the location of the Tesseract executable on your system\n",
    "pytesseract.pytesseract.tesseract_cmd = r'C:\\Program Files\\Tesseract-OCR\\tesseract.exe'\n",
    "\n",
    "def imagetotext_speech():\n",
    "    try:\n",
    "        # Create the main window for the application\n",
    "        root = tk.Tk()\n",
    "        root.title(\"Image to Text Converter\")  # Set the title of the window\n",
    "        root.geometry(\"600x500\")  # Set the size of the window\n",
    "        root.resizable(False, False)  # Prevent the user from resizing the window\n",
    "        root.configure(background=\"white\")  # Set the background color of the window\n",
    "\n",
    "        # Create a frame for buttons and voice selection\n",
    "        frame_buttons = tk.Frame(root, bg=\"white\")\n",
    "        frame_buttons.pack(pady=10, fill=tk.X)\n",
    "\n",
    "        # Create a frame for text output\n",
    "        frame_text = tk.Frame(root, bg=\"white\")\n",
    "        frame_text.pack(pady=10, fill=tk.BOTH, expand=True)\n",
    "\n",
    "        # Create a frame to contain both the buttons and text output for better organization\n",
    "        frame_main = tk.Frame(root)\n",
    "        frame_main.pack(fill=tk.BOTH, expand=True)\n",
    "\n",
    "        # Add instruction label\n",
    "        lbl = tk.Label(frame_buttons, text=\"Select an image and convert it to text\", bg=\"white\")\n",
    "        lbl.pack(pady=10)\n",
    "\n",
    "        # Text widget to display the extracted text\n",
    "        text_output = tk.Text(frame_text, height=15, width=70, wrap=tk.WORD)\n",
    "        text_output.pack(pady=10, fill=tk.BOTH, expand=True)\n",
    "        \n",
    "        # Scrollbar for the text widget\n",
    "        scrollbar = tk.Scrollbar(frame_text, command=text_output.yview)\n",
    "        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)\n",
    "        text_output.config(yscrollcommand=scrollbar.set)\n",
    "\n",
    "        # Function to handle image selection and text extraction\n",
    "        def select_image():\n",
    "            # Open a file dialog to select an image file\n",
    "            file_path = filedialog.askopenfilename(filetypes=[(\"Image Files\", \"*.png;*.jpg;*.jpeg;*.bmp\")])\n",
    "            if file_path:  # Check if a file was selected\n",
    "                try:\n",
    "                    # Load the image using PIL\n",
    "                    image = Image.open(file_path)\n",
    "                    # Use pytesseract to extract text from the image\n",
    "                    extracted_text = pytesseract.image_to_string(image)\n",
    "                    \n",
    "                    if not extracted_text.strip():\n",
    "                        messagebox.showinfo(\"Result\", \"No text found in the image.\")\n",
    "                        return\n",
    "                    \n",
    "                    # Display the extracted text in the text widget\n",
    "                    text_output.delete(1.0, tk.END)\n",
    "                    text_output.insert(tk.END, extracted_text)\n",
    "                    \n",
    "                except Exception as e:\n",
    "                    print(\"Error:\", e)\n",
    "                    messagebox.showerror(\"Error\", \"An error occurred while processing the image.\")\n",
    "        \n",
    "        # Function to convert the extracted text to speech\n",
    "        def speak_text():\n",
    "            extracted_text = text_output.get(1.0, tk.END).strip()\n",
    "            if not extracted_text:\n",
    "                messagebox.showinfo(\"Result\", \"No text available. Please select an image first.\")\n",
    "                return\n",
    "            \n",
    "            try:\n",
    "                # Initialize the text-to-speech engine\n",
    "                engine = pyttsx3.init()\n",
    "                engine.setProperty('rate', 150)  # Set the speech rate\n",
    "                engine.setProperty('voice', combo_voice.get())  # Set the voice based on user selection\n",
    "                engine.say(extracted_text)  # Convert the text to speech\n",
    "                engine.runAndWait()  # Wait for the speech to finish\n",
    "                engine.stop()  # Stop the speech engine\n",
    "\n",
    "            except Exception as e:\n",
    "                print(\"Error:\", e)\n",
    "                messagebox.showerror(\"Error\", \"An error occurred while converting text to speech.\")\n",
    "\n",
    "        # Create buttons for selecting image and speaking text\n",
    "        btn_select_image = tk.Button(frame_buttons, text=\"Select Image\", command=select_image)\n",
    "        btn_select_image.pack(side=tk.LEFT, padx=10)\n",
    "\n",
    "        btn_speak_text = tk.Button(frame_buttons, text=\"Speak Text\", command=speak_text)\n",
    "        btn_speak_text.pack(side=tk.LEFT, padx=10)\n",
    "\n",
    "        # Variable to store the selected voice\n",
    "        voice_var = tk.StringVar()\n",
    "        # Initialize the text-to-speech engine to get available voices\n",
    "        voices = pyttsx3.init().getProperty('voices')\n",
    "        # Extract the names of all available voices\n",
    "        voice_options = [voice.name for voice in voices]\n",
    "        # Create a combo box to allow the user to select a voice\n",
    "        combo_voice = ttk.Combobox(frame_buttons, textvariable=voice_var, values=voice_options)\n",
    "        combo_voice.pack(side=tk.RIGHT, padx=10)\n",
    "        combo_voice.set(voice_options[0])  # Set the default selected voice to the first in the list\n",
    "\n",
    "        root.mainloop()  # Run the main loop of the application\n",
    "\n",
    "    except Exception as e:\n",
    "        # Catch any exceptions that occur and print an error message\n",
    "        print(\"Error:\", e)  # Print the exception details\n",
    "\n",
    "# Setting appearance and color theme for customtkinter\n",
    "customtkinter.set_appearance_mode(\"dark\")  # Set the appearance mode to dark\n",
    "customtkinter.set_default_color_theme(\"green\")  # Set the default color theme to green\n",
    "\n",
    "# Initializing main application window\n",
    "app = customtkinter.CTk()  # Create the main application window\n",
    "app.title(\"Helping Hand\")  # Set the title of the application window\n",
    "app.geometry(\"800x600\")  # Set the size of the application window\n",
    "\n",
    "# Creating a frame to hold the main interface\n",
    "frame = customtkinter.CTkFrame(master=app, corner_radius=20)  # Create a frame with rounded corners\n",
    "Label(frame, text=\"Helping Hands- A Dynamic Translator\", font=\"ariel 25 bold\", fg=\"navy\", bg=\"grey\").pack(fill=\"both\")\n",
    "# Add a label to the frame with a title\n",
    "frame.pack(pady=20, padx=20, fill=\"both\", expand=True)  # Pack the frame with padding and make it expandable\n",
    "\n",
    "# Function to handle text-to-text translation\n",
    "def texttrans():\n",
    "    # Create a new window for the text-to-text translation feature\n",
    "    root = Tk()  # Initialize a new Tkinter window\n",
    "    root.title(\"Google Translator\")  # Set the title of the new window\n",
    "    root.geometry(\"1080x400\")  # Set the size of the new window\n",
    "    root.resizable(False, False)  # Make the window non-resizable\n",
    "    root.configure(background=\"White\")  # Set the background color of the new window\n",
    "\n",
    "    # Function to update the language labels periodically\n",
    "    def label_change():\n",
    "        c = combo1.get()  # Get the selected source language from the combo box\n",
    "        c1 = combo2.get()  # Get the selected target language from the combo box\n",
    "        label1.configure(text=c.upper())  # Update the source language label\n",
    "        label2.configure(text=c1.upper())  # Update the target language label\n",
    "        root.after(1000, label_change)  # Call this function again after 1 second\n",
    "\n",
    "    # Function to translate the text\n",
    "    def translate_now():\n",
    "        text_ = text1.get(1.0, END)  # Get the input text from the text widget\n",
    "        t1 = Translator()  # Initialize the Google Translator\n",
    "        # Translate the text from source language to target language\n",
    "        trans_text = t1.translate(text_, dest=combo2.get(), src=combo1.get())\n",
    "        trans_text = trans_text.text  # Extract the translated text\n",
    "\n",
    "        text2.delete(1.0, END)  # Clear the target text widget\n",
    "        text2.insert(END, trans_text)  # Insert the translated text into the target text widget\n",
    "\n",
    "    # Get available languages from Google Translator\n",
    "    language = googletrans.LANGUAGES  # Dictionary of language codes and their names\n",
    "    languageV = list(language.values())  # List of language names\n",
    "    lang1 = language.keys()  # List of language codes\n",
    "\n",
    "    # First combo box for source language selection\n",
    "    combo1 = ttk.Combobox(root, values=languageV, font=\"Roboto 14\", state=\"r\")\n",
    "    combo1.place(x=110, y=20)  # Place the combo box at specific coordinates\n",
    "    combo1.set(\"ENGLISH\")  # Set the default value of the combo box\n",
    "\n",
    "    # Label for source language\n",
    "    label1 = Label(root, text=\"ENGLISH\", font=\"segoe 30 bold\", bg=\"white\", width=18, bd=5, relief=GROOVE)\n",
    "    label1.place(x=10, y=50)  # Place the label at specific coordinates\n",
    "\n",
    "    # Second combo box for target language selection\n",
    "    combo2 = ttk.Combobox(root, values=languageV, font=\"Roboto 14\", state=\"r\")\n",
    "    combo2.place(x=730, y=20)  # Place the combo box at specific coordinates\n",
    "    combo2.set(\"SELECT LANGUAGE\")  # Set the default value of the combo box\n",
    "\n",
    "    # Label for target language\n",
    "    label2 = Label(root, text=\"ENGLISH\", font=\"segoe 30 bold\", bg=\"white\", width=18, bd=5, relief=GROOVE)\n",
    "    label2.place(x=620, y=50)  # Place the label at specific coordinates\n",
    "\n",
    "    # Frame for input text\n",
    "    f = Frame(root, bg=\"Black\", bd=5)\n",
    "    f.place(x=10, y=118, width=440, height=210)  # Place the frame at specific coordinates\n",
    "\n",
    "    text1 = Text(f, font=\"Roboto 20\", bg=\"white\", relief=GROOVE, wrap=WORD)\n",
    "    text1.place(x=0, y=0, width=430, height=200)  # Place the text widget inside the frame\n",
    "\n",
    "    # Scrollbar for the input text widget\n",
    "    scrollbar1 = Scrollbar(f)\n",
    "    scrollbar1.pack(side=\"right\", fill='y')  # Pack the scrollbar to the right side\n",
    "\n",
    "    scrollbar1.configure(command=text1.yview)  # Configure the scrollbar to work with the text widget\n",
    "    text1.configure(yscrollcommand=scrollbar1.set)  # Set the scrollbar command for the text widget\n",
    "\n",
    "    # Frame for translated text\n",
    "    f1 = Frame(root, bg=\"Black\", bd=5)\n",
    "    f1.place(x=620, y=118, width=440, height=210)  # Place the frame at specific coordinates\n",
    "\n",
    "    text2 = Text(f1, font=\"Roboto 20\", bg=\"white\", relief=GROOVE, wrap=WORD)\n",
    "    text2.place(x=0, y=0, width=430, height=200)  # Place the text widget inside the frame\n",
    "\n",
    "    # Scrollbar for the translated text widget\n",
    "    scrollbar2 = Scrollbar(f1)\n",
    "    scrollbar2.pack(side=\"right\", fill='y')  # Pack the scrollbar to the right side\n",
    "\n",
    "    scrollbar2.configure(command=text2.yview)  # Configure the scrollbar to work with the text widget\n",
    "    text2.configure(yscrollcommand=scrollbar2.set)  # Set the scrollbar command for the text widget\n",
    "\n",
    "    # Button to initiate translation\n",
    "    translate = Button(root, text=\"Translate\", font=(\"Roboto\", 15), activebackground=\"white\", cursor=\"hand2\", bd=1,\n",
    "                       width=10, height=2, bg=\"black\", fg=\"white\", command=translate_now)\n",
    "    translate.place(x=476, y=150)  # Place the button at specific coordinates\n",
    "\n",
    "    label_change()  # Call the function to update the language labels periodically\n",
    "\n",
    "# Function to handle text-to-speech conversion\n",
    "def textspeech():\n",
    "    try:\n",
    "        # Function to perform the text-to-speech conversion\n",
    "        def speaknow():\n",
    "            # Initialize the text-to-speech engine\n",
    "            engine = pyttsx3.init()\n",
    "            engine.setProperty('rate', 150)  # Set the speech rate (words per minute)\n",
    "            engine.setProperty('voice', combo_voice.get())  # Set the voice based on user selection\n",
    "            # Convert the text from the Text widget to speech\n",
    "            engine.say(text1.get(\"1.0\", END))  # Retrieve the entire content of the Text widget\n",
    "            engine.runAndWait()  # Wait for the speech to finish\n",
    "            engine.stop()  # Stop the speech engine\n",
    "\n",
    "        # Create the main window for the application\n",
    "        root = Tk()\n",
    "        root.title(\"Text to Speech\")  # Set the title of the window\n",
    "        root.geometry(\"400x200\")  # Set the size of the window\n",
    "        root.resizable(False, False)  # Prevent the user from resizing the window\n",
    "\n",
    "        # Create a LabelFrame to contain the widgets\n",
    "        obj = LabelFrame(root, text=\"Text to Speech\", font=20, bd=1)\n",
    "        obj.pack(fill=\"both\", expand=\"yes\", padx=10, pady=10)  # Pack the LabelFrame with padding\n",
    "\n",
    "        # Create a Label widget to prompt the user for text input\n",
    "        lbl = Label(obj, text=\"Text\", font=30) \n",
    "        lbl.pack(side=tk.LEFT, padx=5)  # Pack the label on the left side with padding\n",
    "\n",
    "        # Create a Text widget for text input\n",
    "        text1 = Text(obj, font=30, width=25, bd=5)\n",
    "        text1.pack(side=tk.LEFT, padx=10)  # Pack the Text widget on the left side with padding\n",
    "\n",
    "        # Create a StringVar to store the selected voice\n",
    "        voice_var = StringVar()\n",
    "        # Initialize the text-to-speech engine to get available voices\n",
    "        voices = pyttsx3.init().getProperty('voices')\n",
    "        # Extract the names of all available voices\n",
    "        voice_options = [voice.name for voice in voices]\n",
    "        # Create a combo box to allow the user to select a voice\n",
    "        combo_voice = ttk.Combobox(obj, textvariable=voice_var, values=voice_options)\n",
    "        combo_voice.pack(side=tk.LEFT, padx=10)  # Pack the combo box on the left side with padding\n",
    "        combo_voice.set(voice_options[0])  # Set the default selected voice to the first in the list\n",
    "        \n",
    "        # Function to call speaknow() when the button is pressed\n",
    "        def speak():\n",
    "            speaknow()\n",
    "            \n",
    "        # Create a Button to start the text-to-speech conversion\n",
    "        btn_speak = Button(obj, text=\"Speak\", font=20, bg=\"black\", fg=\"white\", command=speak)\n",
    "        btn_speak.pack(side=tk.LEFT, padx=10)  # Pack the button on the left side with padding\n",
    "        \n",
    "        # Function to call speaknow() when the Enter key is pressed in the Text widget\n",
    "        def on_enter(event):\n",
    "            speaknow()\n",
    "        \n",
    "        # Bind the Enter key press event to the on_enter function\n",
    "        text1.bind(\"<Return>\", on_enter)\n",
    "        \n",
    "    except Exception as e:\n",
    "        # Catch any exceptions that occur and print an error message\n",
    "        print(\"Error:\", e)\n",
    "\n",
    "# Function to handle file-to-speech conversion\n",
    "def filespeech():\n",
    "    try:\n",
    "        # Create the main window for the application\n",
    "        root = Tk()\n",
    "        root.title(\"File to Speech\")  # Set the title of the window\n",
    "        root.geometry(\"500x300\")  # Set the size of the window\n",
    "        root.resizable(False, False)  # Prevent the user from resizing the window\n",
    "        root.configure(background=\"White\")  # Set the background color of the window\n",
    "\n",
    "        # Label to prompt the user to select a text file\n",
    "        lbl = Label(root, text=\"Select a text file\", bg=\"white\")\n",
    "        lbl.place(x=10, y=50)  # Place the label at the specified coordinates\n",
    "\n",
    "        # Function to handle file selection and speech conversion\n",
    "        def file():\n",
    "            # Open a file dialog to select a text file\n",
    "            file_path = filedialog.askopenfilename()\n",
    "            if file_path:  # Check if a file was selected\n",
    "                with open(file_path, \"r\") as file:  # Open the selected file for reading\n",
    "                    text = file.read()  # Read the entire content of the file\n",
    "                # Initialize the text-to-speech engine\n",
    "                engine = pyttsx3.init()\n",
    "                engine.setProperty('rate', 150)  # Set the speech rate (words per minute)\n",
    "                engine.setProperty('voice', combo_voice.get())  # Set the voice based on user selection\n",
    "                engine.say(text)  # Convert the text to speech\n",
    "                engine.runAndWait()  # Wait for the speech to finish\n",
    "                engine.stop()  # Stop the speech engine\n",
    "\n",
    "        # Button to open file dialog and start the file processing\n",
    "        btn_browse = Button(root, text=\"Browse\", command=file)\n",
    "        btn_browse.place(x=150, y=50)  # Place the button at the specified coordinates\n",
    "\n",
    "        # Variable to store the selected voice\n",
    "        voice_var = StringVar()\n",
    "        # Initialize the text-to-speech engine to get available voices\n",
    "        voices = pyttsx3.init().getProperty('voices')\n",
    "        # Extract the names of all available voices\n",
    "        voice_options = [voice.name for voice in voices]\n",
    "        # Create a combo box to allow the user to select a voice\n",
    "        combo_voice = ttk.Combobox(root, textvariable=voice_var, values=voice_options)\n",
    "        combo_voice.place(x=250, y=50)  # Place the combo box at the specified coordinates\n",
    "        combo_voice.set(voice_options[0])  # Set the default selected voice to the first in the list\n",
    "\n",
    "    except Exception as e:\n",
    "        # Catch any exceptions that occur and print an error message\n",
    "        print(\"Error:\", e)  # Print the exception details\n",
    "        \n",
    "# Function to handle speech-to-text conversion\n",
    "def speechtotext():\n",
    "    try:\n",
    "        # Initialize the recognizer for speech recognition\n",
    "        recognizer = sr.Recognizer()\n",
    "\n",
    "        # Function to record audio from the microphone\n",
    "        def record_audio():\n",
    "            with sr.Microphone() as source:\n",
    "                print(\"Listening...\")  # Inform the user that the microphone is listening\n",
    "                recognizer.adjust_for_ambient_noise(source)  # Adjust the recognizer to account for ambient noise\n",
    "                audio = recognizer.listen(source)  # Capture audio from the microphone\n",
    "            return audio  # Return the captured audio\n",
    "\n",
    "        # Function to recognize and optionally translate speech\n",
    "        def recognize_speech():\n",
    "            try:\n",
    "                # Record audio from the microphone\n",
    "                audio = record_audio()\n",
    "                \n",
    "                # Get the selected source language from the combo box\n",
    "                src_language = combo_language.get()\n",
    "                # Map the source language name to its language code\n",
    "                src_language_code = list(googletrans.LANGUAGES.keys())[list(googletrans.LANGUAGES.values()).index(src_language.lower())]\n",
    "                \n",
    "                # Recognize the text from the recorded audio using Google Speech Recognition\n",
    "                text = recognizer.recognize_google(audio, language=src_language_code)\n",
    "                print(\"Recognized text:\", text)  # Print the recognized text\n",
    "                \n",
    "                # Update the text output widget with the recognized text\n",
    "                text_output.delete(1.0, END)\n",
    "                text_output.insert(END, text)\n",
    "                \n",
    "                # Check if translation is enabled (i.e., if a destination language is selected)\n",
    "                if combo_translate.get() != \"None\":\n",
    "                    # Get the selected target language from the combo box\n",
    "                    dest_language = combo_translate_language.get()\n",
    "                    # Map the target language name to its language code\n",
    "                    dest_language_code = list(googletrans.LANGUAGES.keys())[list(googletrans.LANGUAGES.values()).index(dest_language.lower())]\n",
    "                    \n",
    "                    # Initialize the translator and translate the recognized text\n",
    "                    translator = Translator()\n",
    "                    translated_text = translator.translate(text, dest=dest_language_code)\n",
    "                    \n",
    "                    # Update the text widget with the translated text\n",
    "                    text_translated.delete(1.0, END)\n",
    "                    text_translated.insert(END, translated_text.text)\n",
    "            except sr.UnknownValueError:\n",
    "                # Handle case where audio is not recognized\n",
    "                print(\"Google Speech Recognition could not understand audio\")\n",
    "            except sr.RequestError as e:\n",
    "                # Handle errors in connecting to the Google Speech Recognition service\n",
    "                print(f\"Could not request results from Google Speech Recognition service; {e}\")\n",
    "                messagebox.showerror(\"Error\", \"Could not connect to the internet.\")  # Show an error message to the user\n",
    "\n",
    "        # Create the main window for the application\n",
    "        root = Tk()\n",
    "        root.title(\"Speech to Text\")  # Set the title of the window\n",
    "        root.geometry(\"700x600\")  # Set the size of the window\n",
    "        root.resizable(False, False)  # Prevent the user from resizing the window\n",
    "        root.configure(background=\"White\")  # Set the background color of the window\n",
    "\n",
    "        # Label for displaying the recognized speech\n",
    "        label_recognized = Label(root, text=\"Recognized speech\", font=(\"Arial\", 14, \"bold\"))\n",
    "        label_recognized.pack(pady=10)  # Add the label to the window with vertical padding\n",
    "\n",
    "        # Create a variable to store the selected language for speech recognition\n",
    "        language_var = StringVar()\n",
    "        # List of language options for speech recognition\n",
    "        language_options = list(googletrans.LANGUAGES.values())\n",
    "        # Create a combo box for selecting the source language\n",
    "        combo_language = ttk.Combobox(root, textvariable=language_var, values=language_options)\n",
    "        combo_language.pack(pady=5)  # Add the combo box to the window with vertical padding\n",
    "        combo_language.set(\"english\")  # Set the default selected language to English\n",
    "\n",
    "        # Label for displaying the translated speech\n",
    "        label_translated = Label(root, text=\"Translated speech\", font=(\"Arial\", 14, \"bold\"))\n",
    "        label_translated.pack(pady=10)  # Add the label to the window with vertical padding\n",
    "\n",
    "        # Create a variable to store the selected language for translation\n",
    "        translate_language_var = StringVar()\n",
    "        # Add \"None\" option to the list of languages for translation (no translation)\n",
    "        translate_language_options = [\"None\"] + language_options\n",
    "        # Create a combo box for selecting the target language for translation\n",
    "        combo_translate_language = ttk.Combobox(root, textvariable=translate_language_var, values=translate_language_options)\n",
    "        combo_translate_language.pack(pady=5)  # Add the combo box to the window with vertical padding\n",
    "        combo_translate_language.set(\"None\")  # Set the default selection to \"None\" (no translation)\n",
    "\n",
    "        # Button to start the process of recording and recognizing speech\n",
    "        record_button = Button(root, text=\"Record\", command=recognize_speech)\n",
    "        record_button.pack(pady=5)  # Add the button to the window with vertical padding\n",
    "\n",
    "        # Text widget to display recognized speech\n",
    "        text_output = Text(root, height=10, width=50)\n",
    "        text_output.pack(pady=10)  # Add the text widget to the window with vertical padding\n",
    "\n",
    "        # Text widget to display translated text (if applicable)\n",
    "        text_translated = Text(root, height=10, width=50)\n",
    "        text_translated.pack(pady=10)  # Add the text widget to the window with vertical padding\n",
    "\n",
    "    except Exception as e:\n",
    "        # Catch any exceptions that occur and display an error message\n",
    "        print(\"Error:\", e)  # Print the exception details\n",
    "        messagebox.showerror(\"Error\", \"An error occurred. Please try again.\")  # Show an error message to the user\n",
    "\n",
    "# Function to handle speech-to-speech translation\n",
    "def speechtospeech():\n",
    "    try:\n",
    "        # Initialize the recognizer for speech recognition\n",
    "        recognizer = sr.Recognizer()\n",
    "        \n",
    "        # Initialize the text-to-speech engine\n",
    "        engine = pyttsx3.init()\n",
    "\n",
    "        # Function to record audio from the microphone\n",
    "        def record_audio():\n",
    "            with sr.Microphone() as source:\n",
    "                print(\"Listening...\")  # Inform the user that the microphone is listening\n",
    "                recognizer.adjust_for_ambient_noise(source)  # Adjust the recognizer to account for ambient noise\n",
    "                audio = recognizer.listen(source)  # Capture audio from the microphone\n",
    "            return audio  # Return the captured audio\n",
    "\n",
    "        # Function to speak out the given text using the specified language\n",
    "        def speaknow(text, language_code):\n",
    "            # Get a list of available voices\n",
    "            voices = engine.getProperty('voices')\n",
    "            for voice in voices:\n",
    "                # Set the voice if it matches the desired language code\n",
    "                if language_code in voice.id:\n",
    "                    engine.setProperty('voice', voice.id)\n",
    "                    break\n",
    "            engine.say(text)  # Pass the text to the speech engine\n",
    "            engine.runAndWait()  # Wait until the speech is done\n",
    "            engine.stop()  # Stop the speech engine\n",
    "\n",
    "        # Function to recognize, translate, and speak the recognized speech\n",
    "        def recognize_and_translate_speech():\n",
    "            try:\n",
    "                # Record audio from the microphone\n",
    "                audio = record_audio()\n",
    "                \n",
    "                # Get the source language from the combo box\n",
    "                src_language = combo_language.get()\n",
    "                # Map the source language name to its language code\n",
    "                src_language_code = list(googletrans.LANGUAGES.keys())[list(googletrans.LANGUAGES.values()).index(src_language.lower())]\n",
    "                \n",
    "                # Recognize the text from the recorded audio using Google Speech Recognition\n",
    "                text = recognizer.recognize_google(audio, language=src_language_code)\n",
    "                print(\"Recognized text:\", text)  # Print the recognized text\n",
    "                # Update the text output widget with the recognized text\n",
    "                text_output.delete(1.0, END)\n",
    "                text_output.insert(END, text)\n",
    "\n",
    "                # Get the target language from the combo box\n",
    "                dest_language = combo_translate_language.get()\n",
    "                # Map the target language name to its language code\n",
    "                dest_language_code = list(googletrans.LANGUAGES.keys())[list(googletrans.LANGUAGES.values()).index(dest_language.lower())]\n",
    "                \n",
    "                # Initialize the translator and translate the recognized text\n",
    "                translator = Translator()\n",
    "                translated_text = translator.translate(text, dest=dest_language_code).text\n",
    "                print(\"Translated text:\", translated_text)  # Print the translated text\n",
    "                # Update the text widget with the translated text\n",
    "                text_translated.delete(1.0, END)\n",
    "                text_translated.insert(END, translated_text)\n",
    "\n",
    "                # Speak the translated text in the selected language\n",
    "                speaknow(translated_text, dest_language_code)\n",
    "            except sr.UnknownValueError:\n",
    "                print(\"Google Speech Recognition could not understand audio\")  # Handle case where audio is not recognized\n",
    "            except sr.RequestError as e:\n",
    "                print(f\"Could not request results from Google Speech Recognition service; {e}\")  # Handle connection errors\n",
    "                messagebox.showerror(\"Error\", \"Could not connect to the internet.\")  # Show an error message to the user\n",
    "\n",
    "        # Create the main window for the application\n",
    "        root = Tk()\n",
    "        root.title(\"Speech to Speech\")  # Set the title of the window\n",
    "        root.geometry(\"700x500\")  # Set the size of the window\n",
    "        root.resizable(False, False)  # Prevent the user from resizing the window\n",
    "        root.configure(background=\"White\")  # Set the background color of the window\n",
    "\n",
    "        # Label to display the title or description of the application\n",
    "        label_recognized = Label(root, text=\"Speech to Speech Translation\", font=(\"Arial\", 14, \"bold\"))\n",
    "        label_recognized.pack(pady=10)  # Add the label to the window with vertical padding\n",
    "\n",
    "        # Create a variable to store the selected language for speech recognition\n",
    "        language_var = StringVar()\n",
    "        # List of language options for speech recognition\n",
    "        language_options = list(googletrans.LANGUAGES.values())\n",
    "        # Create a combo box for selecting the source language\n",
    "        combo_language = ttk.Combobox(root, textvariable=language_var, values=language_options)\n",
    "        combo_language.pack(pady=5)  # Add the combo box to the window with vertical padding\n",
    "        combo_language.set(\"english\")  # Set the default selected language to English\n",
    "\n",
    "        # Create a variable to store the selected language for translation\n",
    "        translate_language_var = StringVar()\n",
    "        # List of language options for translation (same as source language options)\n",
    "        translate_language_options = language_options\n",
    "        # Create a combo box for selecting the target language\n",
    "        combo_translate_language = ttk.Combobox(root, textvariable=translate_language_var, values=translate_language_options)\n",
    "        combo_translate_language.pack(pady=5)  # Add the combo box to the window with vertical padding\n",
    "        combo_translate_language.set(\"spanish\")  # Set the default selected language to Spanish\n",
    "\n",
    "        # Button to start the process of recording, recognizing, and translating speech\n",
    "        record_button = Button(root, text=\"Translate Speech\", command=recognize_and_translate_speech)\n",
    "        record_button.pack(pady=20)  # Add the button to the window with vertical padding\n",
    "\n",
    "        # Text widget to display the recognized speech\n",
    "        text_output = Text(root, height=10, width=50)\n",
    "        text_output.pack(pady=10)  # Add the text widget to the window with vertical padding\n",
    "\n",
    "        # Text widget to display the translated text\n",
    "        text_translated = Text(root, height=10, width=50)\n",
    "        text_translated.pack(pady=10)  # Add the text widget to the window with vertical padding\n",
    "\n",
    "    except Exception as e:\n",
    "        # Catch any exceptions that occur and display an error message\n",
    "        print(\"Error:\", e)  # Print the exception details\n",
    "        messagebox.showerror(\"Error\", \"An error occurred. Please try again.\")  # Show an error message to the user\n",
    "\n",
    "# Creating a button for the \"Text-to-Text\" functionality on the main interface\n",
    "# This button allows the user to convert text to text using the specified function `texttrans`\n",
    "button_1 = customtkinter.CTkButton(\n",
    "    master=frame,                # The parent container where the button will be placed\n",
    "    text=\"Text-to-Text\",         # The text label displayed on the button\n",
    "    corner_radius=8,             # The radius of the button corners (for rounded corners)\n",
    "    width=200,                   # The width of the button in pixels\n",
    "    height=30,                   # The height of the button in pixels\n",
    "    command=texttrans,           # The function to be called when the button is clicked\n",
    "    font=(\"Arial\", 20),          # The font style and size for the button text\n",
    "    border_spacing=10,           # The spacing between the button border and the text\n",
    "    fg_color=\"#D2122E\"           # The foreground color of the button (text color)\n",
    ")\n",
    "button_1.pack(padx=20, pady=20)   # Adding the button to the layout with padding around it\n",
    "\n",
    "# Creating a button for the \"Text-to-Speech\" functionality on the main interface\n",
    "# This button allows the user to convert text to speech using the specified function `textspeech`\n",
    "button_2 = customtkinter.CTkButton(\n",
    "    master=frame,                # The parent container where the button will be placed\n",
    "    text=\"Text-to-Speech\",       # The text label displayed on the button\n",
    "    corner_radius=8,             # The radius of the button corners (for rounded corners)\n",
    "    width=200,                   # The width of the button in pixels\n",
    "    height=30,                   # The height of the button in pixels\n",
    "    command=textspeech,          # The function to be called when the button is clicked\n",
    "    font=(\"Arial\", 20),          # The font style and size for the button text\n",
    "    border_spacing=10,           # The spacing between the button border and the text\n",
    "    fg_color=\"#D2122E\"           # The foreground color of the button (text color)\n",
    ")\n",
    "button_2.pack(padx=20, pady=20)   # Adding the button to the layout with padding around it\n",
    "\n",
    "# Creating a button for the \"Speech-to-Text\" functionality on the main interface\n",
    "# This button allows the user to convert speech to text using the specified function `speechtotext`\n",
    "button_3 = customtkinter.CTkButton(\n",
    "    master=frame,                # The parent container where the button will be placed\n",
    "    text=\"Speech-to-Text\",       # The text label displayed on the button\n",
    "    corner_radius=8,             # The radius of the button corners (for rounded corners)\n",
    "    width=200,                   # The width of the button in pixels\n",
    "    height=30,                   # The height of the button in pixels\n",
    "    command=speechtotext,        # The function to be called when the button is clicked\n",
    "    font=(\"Arial\", 20),          # The font style and size for the button text\n",
    "    border_spacing=10,           # The spacing between the button border and the text\n",
    "    fg_color=\"#D2122E\"           # The foreground color of the button (text color)\n",
    ")\n",
    "button_3.pack(padx=20, pady=20)   # Adding the button to the layout with padding around it\n",
    "\n",
    "# Creating a button for the \"File-to-Speech\" functionality on the main interface\n",
    "# This button allows the user to convert a file to speech using the specified function `filespeech`\n",
    "button_4 = customtkinter.CTkButton(\n",
    "    master=frame,                # The parent container where the button will be placed\n",
    "    text=\"File-to-Speech\",       # The text label displayed on the button\n",
    "    corner_radius=8,             # The radius of the button corners (for rounded corners)\n",
    "    width=200,                   # The width of the button in pixels\n",
    "    height=30,                   # The height of the button in pixels\n",
    "    command=filespeech,          # The function to be called when the button is clicked\n",
    "    font=(\"Arial\", 20),          # The font style and size for the button text\n",
    "    border_spacing=10,           # The spacing between the button border and the text\n",
    "    fg_color=\"#D2122E\"           # The foreground color of the button (text color)\n",
    ")\n",
    "button_4.pack(padx=20, pady=20)   # Adding the button to the layout with padding around it\n",
    "\n",
    "# Creating a button for the \"Speech-to-Speech\" functionality on the main interface\n",
    "# This button allows the user to convert speech to speech using the specified function `speechtospeech`\n",
    "button_5 = customtkinter.CTkButton(\n",
    "    master=frame,                # The parent container where the button will be placed\n",
    "    text=\"Speech-to-Speech\",     # The text label displayed on the button\n",
    "    corner_radius=8,             # The radius of the button corners (for rounded corners)\n",
    "    width=200,                   # The width of the button in pixels\n",
    "    height=30,                   # The height of the button in pixels\n",
    "    command=speechtospeech,      # The function to be called when the button is clicked\n",
    "    font=(\"Arial\", 20),          # The font style and size for the button text\n",
    "    border_spacing=10,           # The spacing between the button border and the text\n",
    "    fg_color=\"#D2122E\"           # The foreground color of the button (text color)\n",
    ")\n",
    "button_5.pack(padx=20, pady=20)   # Adding the button to the layout with padding around it\n",
    "\n",
    "# Creating a button for the \"Image-to-Text&Speech\" functionality on the main interface\n",
    "# This button allows the user to convert Image to Text & Speech using the specified function `imagetotext`\n",
    "button_6 = customtkinter.CTkButton(\n",
    "    master=frame,                       # The parent container where the button will be placed\n",
    "    text=\"Image-to-Text&Speech\",        # The text label displayed on the button\n",
    "    corner_radius=8,                    # The radius of the button corners (for rounded corners)\n",
    "    width=200,                          # The width of the button in pixels\n",
    "    height=30,                          # The height of the button in pixels\n",
    "    command=imagetotext_speech,         # The function to be called when the button is clicked\n",
    "    font=(\"Arial\", 20),                 # The font style and size for the button text\n",
    "    border_spacing=10,                  # The spacing between the button border and the text\n",
    "    fg_color=\"#D2122E\"                  # The foreground color of the button (text color)\n",
    ")\n",
    "button_6.pack(padx=20, pady=20)   # Adding the button to the layout with padding around it\n",
    "\n",
    "# Starting the main application loop to make the GUI responsive\n",
    "# This line keeps the application running and listens for user interactions\n",
    "app.mainloop()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}