Update app.py

app.py

@@ -96,7 +96,8 @@ def convert_ebook_to_audio(ebook_file, language_display, output_format, embed_co
     Converts an ebook file to an audiobook using Calibre and espeak-ng.
     """
     if not ebook_file:
-        return None, None, "Error: No ebook file provided.", None
+        # Return None for audio, None for cover, and the error message
+        return None, None, "**Error:** No ebook file provided."
 
     # Check required commands based on selection
     calibre_convert_ok = check_command("ebook-convert")
@@ -113,17 +114,17 @@ def convert_ebook_to_audio(ebook_file, language_display, output_format, embed_co
     if not oggenc_ok and output_format == 'ogg': missing.append("oggenc (for OGG)")
 
     if missing:
-         error_msg = f"Error: Missing required command(s): {', '.join(missing)}. Please install them and ensure they are in your system PATH."
-         logging.error(error_msg)
-         # Use Markdown for better formatting in Gradio Textbox
-         return None, None, f"**Error:** Missing required command(s):\n- {', '.join(missing)}\n\nPlease install them and ensure they are in your system PATH.", None
+         error_msg = f"**Error:** Missing required command(s):\n- {', '.join(missing)}\n\nPlease install them and ensure they are in your system PATH."
+         logging.error(error_msg.replace("**Error:** ","").replace("\n- "," ").replace("\n"," ")) # Log plain text
+         # Return None for audio, None for cover, and the error message
+         return None, None, error_msg
 
 
     temp_dir = tempfile.mkdtemp(prefix="ebook_audio_")
     logging.info(f"Created temporary directory: {temp_dir}")
     status_updates = ["Conversion started..."]
     cover_image_path_final = None
-    audio_output_path_final = None
+    audio_output_path_final = None # Keep track of the final audio path
 
     try:
         input_ebook_path = ebook_file.name # Gradio provides a temp path for the upload
@@ -218,23 +219,23 @@ def convert_ebook_to_audio(ebook_file, language_display, output_format, embed_co
             logging.info("Ebook successfully converted to TXT.")
         except subprocess.CalledProcessError as e:
             stderr_decoded = e.stderr.decode(errors='ignore') if e.stderr else "No stderr"
-            error_msg = f"Error during Calibre conversion: {stderr_decoded or e}"
-            status_updates.append(f"❌ {error_msg}")
-            logging.error(error_msg)
-            # Use Markdown for better formatting in Gradio Textbox
-            return None, cover_image_path_final, f"**Error:** Calibre conversion failed.\n```\n{stderr_decoded or e}\n```", None # Return extracted cover if available
+            error_msg = f"**Error:** Calibre conversion failed.\n```\n{stderr_decoded or e}\n```"
+            status_updates.append(f"❌ Calibre conversion failed.") # Keep status short
+            logging.error(f"Error during Calibre conversion: {stderr_decoded or e}")
+            # Return None for audio, the extracted cover (if any), and the error message
+            return None, cover_image_path_final, "\n".join(status_updates) + f"\n\n{error_msg}"
         except Exception as e:
-            error_msg = f"An unexpected error occurred during ebook conversion: {e}"
-            status_updates.append(f"❌ {error_msg}")
-            logging.error(error_msg, exc_info=True)
-            return None, cover_image_path_final, f"**Error:** An unexpected error occurred during ebook conversion:\n{e}", None
+            error_msg = f"**Error:** An unexpected error occurred during ebook conversion:\n{e}"
+            status_updates.append(f"❌ Unexpected conversion error.")
+            logging.error(f"Unexpected error during ebook conversion: {e}", exc_info=True)
+            return None, cover_image_path_final, "\n".join(status_updates) + f"\n\n{error_msg}"
 
         # Check if TXT file was actually created and is not empty
         if not os.path.exists(txt_output_path) or os.path.getsize(txt_output_path) == 0:
-            error_msg = "Error: Calibre finished, but the output TXT file is missing or empty. The ebook might be image-based or DRM protected."
-            status_updates.append(f"❌ {error_msg}")
-            logging.error(error_msg)
-            return None, cover_image_path_final, f"**Error:** Calibre finished, but the output TXT file is missing or empty.\nThis can happen with image-based ebooks (like comics/scans) or DRM-protected files.", None
+            error_msg = "**Error:** Calibre finished, but the output TXT file is missing or empty.\nThis can happen with image-based ebooks (like comics/scans) or DRM-protected files."
+            status_updates.append(f"❌ TXT output empty/missing.")
+            logging.error("Calibre finished, but the output TXT file is missing or empty.")
+            return None, cover_image_path_final, "\n".join(status_updates) + f"\n\n{error_msg}"
 
         # --- Step 3: Convert TXT to Audio ---
         progress(0.6, desc="Converting TXT to Audio")
@@ -352,27 +353,28 @@ def convert_ebook_to_audio(ebook_file, language_display, output_format, embed_co
                                f"**Command:**\n```\n{cmd_str}\n```\n" \
                                f"**Exit Status:** {exit_status_str}\n\n" \
                                f"**Output/Error:**\n```\n{error_details}\n```"
-            return None, cover_image_path_final, md_error_details, None
+            # Return None for audio, the cover (if any), and the combined status/error message
+            return None, cover_image_path_final, "\n".join(status_updates) + f"\n\n{md_error_details}"
             # --- END MODIFIED ERROR HANDLING ---
 
         except FileNotFoundError as e:
              missing_cmd = e.filename # Usually contains the missing command
-             error_msg = f"Error: Command '{missing_cmd}' not found for {output_format.upper()} output."
-             status_updates.append(f"❌ {error_msg}")
-             logging.error(error_msg)
-             return None, cover_image_path_final, f"**Error:** Command `{missing_cmd}` not found.\nPlease install it and ensure it's in your system PATH.", None
+             error_msg = f"**Error:** Command `{missing_cmd}` not found for {output_format.upper()} output.\nPlease install it and ensure it's in your system PATH."
+             status_updates.append(f"❌ Command '{missing_cmd}' not found.")
+             logging.error(f"Error: Command '{missing_cmd}' not found.")
+             return None, cover_image_path_final, "\n".join(status_updates) + f"\n\n{error_msg}"
         except Exception as e:
-            error_msg = f"An unexpected error occurred during audio generation: {e}"
-            status_updates.append(f"❌ {error_msg}")
-            logging.error(error_msg, exc_info=True)
-            return None, cover_image_path_final, f"**Error:** An unexpected error occurred during audio generation:\n{e}", None
+            error_msg = f"**Error:** An unexpected error occurred during audio generation:\n{e}"
+            status_updates.append(f"❌ Unexpected audio error.")
+            logging.error(f"An unexpected error occurred during audio generation: {e}", exc_info=True)
+            return None, cover_image_path_final, "\n".join(status_updates) + f"\n\n{error_msg}"
 
         # Check if audio file exists and has size
         if not os.path.exists(audio_output_path) or os.path.getsize(audio_output_path) < 1024: # Check for > 1KB as a basic sanity check
-             error_msg = f"Error: Audio generation command finished, but the output file '{Path(audio_output_path).name}' is missing or too small. Check logs for details."
-             status_updates.append(f"❌ {error_msg}")
-             logging.error(error_msg)
-             return None, cover_image_path_final, f"**Error:** Audio output file missing or too small after conversion.\nCheck system logs for `espeak-ng`, `lame`, or `oggenc` or the status box above for errors.", None
+             error_msg = f"**Error:** Audio generation command finished, but the output file '{Path(audio_output_path).name}' is missing or too small. Check logs for details."
+             status_updates.append(f"❌ Audio output missing/small.")
+             logging.error(f"Audio output file missing or too small: {audio_output_path}")
+             return None, cover_image_path_final, "\n".join(status_updates) + f"\n\n{error_msg}"
 
 
         # --- Step 4: Embed Cover Art (Optional) ---
@@ -384,12 +386,24 @@ def convert_ebook_to_audio(ebook_file, language_display, output_format, embed_co
                     cover_data = img_f.read()
 
                 # Determine mimetype using PIL
-                img = Image.open(cover_image_path_final)
-                mime_type = Image.MIME.get(img.format)
-                img.close()
+                mime_type = None
+                try:
+                    img = Image.open(cover_image_path_final)
+                    mime_type = Image.MIME.get(img.format)
+                    img.close()
+                except Exception as pil_err:
+                    logging.warning(f"Could not determine MIME type using PIL: {pil_err}")
+
                 if not mime_type:
-                     mime_type = 'image/jpeg' # Default guess
-                     logging.warning(f"Could not determine MIME type for cover image, defaulting to {mime_type}")
+                     # Basic fallback based on extension
+                     ext = Path(cover_image_path_final).suffix.lower()
+                     if ext == ".jpg" or ext == ".jpeg":
+                         mime_type = 'image/jpeg'
+                     elif ext == ".png":
+                         mime_type = 'image/png'
+                     else:
+                        mime_type = 'image/jpeg' # Default guess if extension unknown/unsupported
+                     logging.warning(f"Defaulting cover MIME type to {mime_type}")
 
 
                 logging.info(f"Attempting to embed cover art ({mime_type}) into {audio_output_path}")
@@ -400,23 +414,39 @@ def convert_ebook_to_audio(ebook_file, language_display, output_format, embed_co
 
                 # Clear existing images before adding new one (optional, prevents duplicates)
                 try:
+                    tags_modified = False
                     if isinstance(audio, (MP3, EasyMP3)):
-                        audio.tags.delall('APIC')
+                        if audio.tags and 'APIC:' in audio.tags:
+                            del audio.tags['APIC:'] # Common key format
+                            tags_modified = True
+                        # Also try deleting all APIC frames regardless of description
+                        if audio.tags:
+                           apic_keys = [k for k in audio.tags.keys() if k.startswith('APIC')]
+                           for k in apic_keys:
+                               del audio.tags[k]
+                               tags_modified = True
                     elif isinstance(audio, FLAC):
-                        audio.clear_pictures()
+                        if audio.pictures:
+                             audio.clear_pictures()
+                             tags_modified = True
                     elif isinstance(audio, MP4):
                         if 'covr' in audio:
                             del audio['covr']
+                            tags_modified = True
                     # OggVorbis picture removal is more complex, might need specific key deletion
                     elif isinstance(audio, OggVorbis) and "metadata_block_picture" in audio:
                         del audio["metadata_block_picture"]
-                    audio.save() # Save after deletion before adding
-                    audio = mutagen.File(audio_output_path, easy=False) # Re-load
+                        tags_modified = True
+
+                    if tags_modified:
+                         audio.save() # Save after deletion before adding
+                         audio = mutagen.File(audio_output_path, easy=False) # Re-load
                 except Exception as e:
                     logging.warning(f"Could not clear existing artwork before embedding: {e}")
 
 
                 # Embedding logic differs by format
+                save_needed = False
                 if isinstance(audio, (MP3, EasyMP3)):
                     if audio.tags is None: audio.add_tags() # Ensure tags exist
                     audio.tags.add(
@@ -428,6 +458,7 @@ def convert_ebook_to_audio(ebook_file, language_display, output_format, embed_co
                             data=cover_data
                         )
                     )
+                    save_needed = True
                 elif isinstance(audio, FLAC):
                      pic = mutagen.flac.Picture()
                      pic.data = cover_data
@@ -435,16 +466,26 @@ def convert_ebook_to_audio(ebook_file, language_display, output_format, embed_co
                      pic.mime = mime_type
                      # pic.width, pic.height, pic.depth = ... # Optionally get dimensions from PIL
                      audio.add_picture(pic)
+                     save_needed = True
                 elif isinstance(audio, OggVorbis):
                      # Ogg uses base64 encoded pictures in METADATA_BLOCK_PICTURE tag
                      import base64
-                     pic_data = base64.b64encode(cover_data).decode('ascii')
                      # This field expects a FLAC Picture block, base64 encoded.
                      pic = mutagen.flac.Picture()
                      pic.data = cover_data
                      pic.type = mutagen.id3.PictureType.COVER_FRONT
                      pic.mime = mime_type
+                     # Add required fields if possible (otherwise defaults might work)
+                     img = Image.open(cover_image_path_final)
+                     pic.width = img.width
+                     pic.height = img.height
+                     # Determine color depth (e.g., 24 for RGB, 32 for RGBA)
+                     pic.depth = {'RGB': 24, 'RGBA': 32, 'L': 8}.get(img.mode, 24)
+                     img.close()
+
+                     # Encode the full picture block
                      audio["metadata_block_picture"] = [base64.b64encode(pic.write()).decode("ascii")]
+                     save_needed = True
 
                 elif isinstance(audio, MP4):
                      if mime_type == 'image/jpeg':
@@ -457,23 +498,27 @@ def convert_ebook_to_audio(ebook_file, language_display, output_format, embed_co
 
                      if pic_format != MP4Cover.FORMAT_UNDEFINED:
                          audio['covr'] = [MP4Cover(cover_data, imageformat=pic_format)]
+                         save_needed = True
 
-                # Add other metadata (optional)
+                # Add other metadata (optional) - Use easy=True for simpler access
                 try:
-                    # Use easy=True for simpler metadata access if needed elsewhere
                     audio_easy = mutagen.File(audio_output_path, easy=True)
                     if audio_easy is not None:
-                         audio_easy['title'] = base_filename
-                         audio_easy['artist'] = "Generated Audiobook" # Or try to get from ebook metadata later
-                         audio_easy.save() # Save easy tags first
+                        if 'title' not in audio_easy or not audio_easy['title']:
+                             audio_easy['title'] = base_filename
+                             save_needed = True
+                        if 'artist' not in audio_easy or not audio_easy['artist']:
+                             audio_easy['artist'] = "Generated Audiobook"
+                             save_needed = True
+                        if save_needed:
+                             audio_easy.save() # Save easy tags if modified
+                             save_needed = False # Prevent double save if only easy tags changed
                 except Exception as tag_err:
                     logging.warning(f"Could not set basic title/artist tags: {tag_err}")
-                    # If easy tags failed, save the main audio object (with picture)
-                    if audio is not None: audio.save()
-                else:
-                     # If easy tags succeeded, save the main audio object too (if necessary, though easy.save might suffice)
-                     if audio is not None: audio.save()
 
+                # Save the main audio object if changes were made (picture or direct tags)
+                if save_needed and audio is not None:
+                    audio.save()
 
                 status_updates.append("✅ Cover art embedded successfully.")
                 logging.info("Cover art embedded successfully.")
@@ -497,25 +542,20 @@ def convert_ebook_to_audio(ebook_file, language_display, output_format, embed_co
 
         # Return paths for Gradio components
         final_status = "\n".join(status_updates)
-        # Need to return a *copy* of the file outside the temp dir, or Gradio might lose it after cleanup
-        # However, Gradio usually handles temp files well if returned directly. Let's try direct return first.
-        # If issues arise, copy the file to a more stable temp location managed by Gradio if possible, or just let the user download.
         logging.info(f"Returning audio: {audio_output_path_final}, cover: {cover_image_path_final}")
-        # Return audio path twice: once for Audio component, once for File component
-        return audio_output_path_final, cover_image_path_final, final_status, audio_output_path_final
+        # Return audio path for Audio component, cover path for Image, status for Textbox
+        return audio_output_path_final, cover_image_path_final, final_status
 
     except Exception as e:
         error_msg = f"An unexpected error occurred in the main process: {e}"
         status_updates.append(f"❌ {error_msg}")
         logging.error(error_msg, exc_info=True)
-        return None, cover_image_path_final, f"**Error:** An unexpected critical error occurred.\nCheck logs for details.\n{e}", None # Return what we have
+        # Return None for audio, cover path (if extracted), and the error status
+        return None, cover_image_path_final, f"**Error:** An unexpected critical error occurred.\nCheck logs for details.\n{e}"
 
     finally:
         # --- Cleanup ---
-        # Keep the final audio and cover files if successful, delete the rest
-        # Gradio should handle the returned file paths, but clean the temp dir *contents* just in case.
-        # It's safer to let Gradio manage the returned files' lifecycle.
-        # We'll clean the intermediate files (.txt, original cover if converted).
+        # Clean intermediate files. Let Gradio handle the returned files.
         try:
             if 'txt_output_path' in locals() and os.path.exists(txt_output_path):
                 os.remove(txt_output_path)
@@ -526,26 +566,27 @@ def convert_ebook_to_audio(ebook_file, language_display, output_format, embed_co
                 os.path.exists(cover_output_path_temp)):
                  os.remove(cover_output_path_temp)
                  logging.info(f"Removed intermediate file: {cover_output_path_temp}")
-            # Let Gradio handle the final audio/cover paths returned.
-            # Do NOT delete temp_dir itself if files within it were returned to Gradio.
-            # If Gradio copies the files, then shutil.rmtree(temp_dir) is safe. Test this behavior.
-            # For safety, let's rely on OS/Gradio temp file cleanup unless memory becomes an issue.
+
+            # Optionally schedule full temp dir removal if Gradio doesn't handle it.
+            # For now, assume Gradio manages the returned file paths.
             if 'temp_dir' in locals() and os.path.exists(temp_dir):
-                logging.info(f"Skipping deletion of temp dir '{temp_dir}' to allow Gradio access to output files.")
-                # To force cleanup (may break Gradio display):
+                logging.info(f"Temp dir '{temp_dir}' contains output files. Skipping immediate deletion.")
+                # To force cleanup (may break Gradio display if files aren't copied):
                 # shutil.rmtree(temp_dir, ignore_errors=True)
                 # logging.info(f"Attempted cleanup of temp dir: {temp_dir}")
 
-
         except OSError as e:
-            logging.warning(f"Could not remove intermediate file: {e}")
+            logging.warning(f"Error during cleanup of intermediate files: {e}")
 
 
 # --- Gradio Interface Definition ---
 
 available_voices = get_espeak_voices()
 voice_choices = list(available_voices.keys())
-default_voice = "English (en-US) (en-us)" if "English (en-US) (en-us)" in voice_choices else ("English (en)" if "English (en)" in voice_choices else (voice_choices[0] if voice_choices else "en")) # Sensible default
+# Try to find a more specific default like en-US, otherwise fall back
+default_voice_options = ["English (en-US) (en-us)", "English (United States) (en-us)", "English (en)", "en"]
+default_voice = next((v for v in default_voice_options if v in voice_choices), (voice_choices[0] if voice_choices else "en"))
+
 
 # Check for external tools on startup and display warnings if needed
 startup_warnings = []
@@ -558,9 +599,10 @@ if not MUTAGEN_AVAILABLE: startup_warnings.append("Python 'mutagen' library (nee
 
 startup_message = ""
 if startup_warnings:
+    warning_list = "\n- ".join(startup_warnings)
     startup_message = (
         "**⚠️ Startup Warning: The following components might be missing or not found in PATH:**\n\n"
-        f"- {', '.join(startup_warnings)}\n\n"
+        f"- {warning_list}\n\n"
         "Please install them for full functionality. Check console logs for details."
     )
     print("-" * 60)
@@ -604,15 +646,16 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
                  # Use filepath for image to avoid potential base64 encoding issues with large images
                  cover_image = gr.Image(label="Extracted Cover Art", type="filepath", interactive=False, height=200, width=200)
                  # Use filepath for audio for consistency and potentially better handling of large files
+                 # The gr.Audio component includes download functionality.
                  audio_output_player = gr.Audio(label="Generated Audiobook", type="filepath", interactive=False)
-            # Add a dedicated download button using gr.File
-            audio_output_download = gr.File(label="Download Audiobook File", interactive=False)
+            # REMOVED: audio_output_download = gr.File(label="Download Audiobook File", interactive=False)
 
     # Connect components
     submit_button.click(
         fn=convert_ebook_to_audio,
         inputs=[ebook_input, lang_dropdown, format_dropdown, cover_checkbox],
-        outputs=[audio_output_player, cover_image, status_textbox, audio_output_download] # Map audio path to Audio player and File download
+        # Map outputs to the player, image, and status box.
+        outputs=[audio_output_player, cover_image, status_textbox] # MODIFIED
     )
 
 # --- Launch the App ---
@@ -621,4 +664,5 @@ if __name__ == "__main__":
     print("Ensure Calibre (ebook-convert, ebook-meta), espeak-ng, lame, and oggenc are installed and in your system PATH.")
     if not voice_choices:
          print("\nWARNING: Could not retrieve any voices from espeak-ng. The language dropdown will be limited or empty!\n")
-    demo.launch() # Add share=True here if you need a public link: demo.launch(share=True)
+    # Add share=True for a public link, server_name="0.0.0.0" for Docker/network access
+    demo.launch()