this is chatgpt modificaion completely . so if things go to shit , revert back immediately

app.py

@@ -1,107 +1,70 @@
 import gradio as gr
-import pdfminer
 from pdfminer.high_level import extract_text
 import logging
 from typing import cast
-
-import gradio as gr
 from balacoon_tts import TTS
 from huggingface_hub import hf_hub_download, list_repo_files
 
-# global tts module, initialized from a model selected
+# Global tts module, initialized from a model selected
 tts = None
 
 def read_pdf(file):
-    text = extract_text(file.name)
+    with open(file.name, "rb") as f:
+        text = extract_text(f)
     return text
 
-# iface = gr.Interface(
-#     read_pdf,
-#     gr.inputs.File(),
-#     # gr.outputs.Textbox()
-# )
-# iface.launch()
-
-
 def main():
     logging.basicConfig(level=logging.INFO)
-    with gr.Blocks() as demo:
-        gr.Markdown(
+    with gr.Interface(fn=None, title="PDF TO SPEECH CONVERTER", layout="rows", debug=True) as iface:
+        repo_files = list_repo_files(repo_id="balacoon/tts")
+        model_files = [x for x in repo_files if x.endswith("_cpu.addon")]
+        model_name = gr.inputs.Dropdown(label="Model", choices=model_files)
+        speaker = gr.inputs.Dropdown(label="Speaker", choices=[])
+
+        def set_model(model_name_str):
             """
-            <h1 align="center">PDF TO SPEECH CONVERTER</h1>
-            1. insert a pdf 
-            2. Select the model to synthesize with
-            3. Select speaker
-            4. Hit "Generate" and listen to the result!
-            When you select model for the first time,
-            it will take a little time to download it.
-            this project is designed to take the love 
-            of reading without the hassle of looking over.
-            if you want an audio book , you now got it .
+            Gets value from `model_name`, loads the model,
+            re-initializes the tts object, and gets a list of
+            speakers that the model supports and sets them to `speaker`.
             """
-        )
-
-        with gr.Row(variant="panel"):
-            f=gr.inputs.File("enter the file")
-            text = read_pdf(f)
-
-        with gr.Row():
-            with gr.Column(variant="panel"):
-                repo_files = list_repo_files(repo_id="balacoon/tts")
-                model_files = [x for x in repo_files if x.endswith("_cpu.addon")]
-                model_name = gr.Dropdown(
-                    label="Model",
-                    choices=model_files,
-                )
-            with gr.Column(variant="panel"):
-                speaker = gr.Dropdown(label="Speaker", choices=[])
-
-            def set_model(model_name_str: str):
-                """
-                gets value from `model_name`, loads model,
-                re-initializes tts object, gets list of
-                speakers that model supports and set them to `speaker`
-                """
-                model_path = hf_hub_download(
-                    repo_id="balacoon/tts", filename=model_name_str
-                )
-                global tts
-                tts = TTS(model_path)
-                speakers = tts.get_speakers()
-                value = speakers[-1]
-                return gr.Dropdown.update(
-                    choices=speakers, value=value, visible=True
-                )
+            model_path = hf_hub_download(repo_id="balacoon/tts", filename=model_name_str)
+            global tts
+            tts = TTS(model_path)
+            speakers = tts.get_speakers()
+            value = speakers[-1]
+            speaker.choices = speakers
+            speaker.value = value
 
-            model_name.change(set_model, inputs=model_name, outputs=speaker)
+        model_name.onChange(set_model)
 
-        with gr.Row(variant="panel"):
-            generate = gr.Button("Generate")
-        with gr.Row(variant="panel"):
-            audio = gr.Audio()
+        file_input = gr.inputs.File(label="Select a PDF File", type="file")
+        text = gr.outputs.Textbox()
 
-        def synthesize_audio(text_str: str, speaker_str: str = ""):
+        def synthesize_audio(file, model_name_str, speaker_str):
             """
-            gets utterance to synthesize from `text` Textbox
-            and speaker name from `speaker` dropdown list.
-            speaker name might be empty for single-speaker models.
-            Synthesizes the waveform and updates `audio` with it.
+            Gets the selected PDF `file`, model name from `model_name`,
+            and speaker name from `speaker`. Synthesizes the audio waveform
+            from the text extracted from the PDF and returns it.
             """
-            if not text_str:
-                logging.info("text or speaker are not provided")
+            if file is None or file.name == "":
+                logging.info("No file selected.")
                 return None
-            global tts
+
+            text_str = read_pdf(file)
             if len(text_str) > 1024:
                 text_str = text_str[:1024]
+
+            global tts
             samples = cast(TTS, tts).synthesize(text_str, speaker_str)
-            return gr.Audio.update(value=(cast(TTS, tts).get_sampling_rate(), samples))
+            return (cast(TTS, tts).get_sampling_rate(), samples)
 
-        generate.click(synthesize_audio, inputs=[text, speaker], outputs=audio)
+        audio = gr.outputs.Audio(label="Generated Audio")
 
-    demo.launch()
+        iface.inputs = [file_input, model_name, speaker]
+        iface.outputs = audio
+        iface.fn = synthesize_audio
+        iface.launch()
 
 
 if __name__ == "__main__":
     main()
-
-