v1.1.5

CHANGELOG.md

@@ -1,3 +1,21 @@
+# 1.1.5
+- Changed the temporary directory path to user's cache directory, which is more appropriate for storing cache files and avoids issues with unintended cleanup.
+- Fixed the isssue where extra metadata information was not being saved to M4B files when they have no chapters, ensuring that all metadata is correctly written to the output file.
+- Fixed sleep prevention process not ending if program exited using Ctrl+C or kill.
+- Improved automatic filename suffixing to better prevent overwriting files with the same name, even if they have different extensions.
+- Improvements in code and documentation.
+
+# 1.1.4
+- Fixed extra metadata information not being saved to M4B files, ensuring that all metadata is correctly written to the output file.
+- Reformatted the code using Black for better readability and consistency.
+
+# 1.1.3
+- `M4B (with chapters)` generation is faster now, as it directly generates `m4b` files instead of converting from `wav`, which significantly reduces processing time, fixes the issue mentioned by @Milor123 in #39 
+- Better sleep state handling for Linux.
+- The app window now tries to fit the screen if its height would exceed the available display area.
+- Fixed issue where the app would not restart properly on Windows.
+- Fixed last sentence/subtitle entry timing in generated subtitles, the end time of the final subtitle entry now correctly matches the end of the audio chunk, preventing zero or invalid timings at the end.
+
 # v1.1.2
 - Now you can play the audio files while they are processing.
 - Audio and subtitle files are now written directly to disk during generation, which significantly reduces memory usage.

README.md

@@ -149,9 +149,9 @@ Here’s Abogen in action: in this demo, it processes ∼3,000 characters of tex
 | **Configure max lines in log window** | Configures the maximum number of lines to display in the log window. |
 | **Separate chapters audio format** | Configures the audio format for separate chapters as `wav`, `flac`, `mp3`, or `opus`. |
 | **Create desktop shortcut** | Creates a shortcut on your desktop for easy access. |
-| **Open config.json directory** | Opens the directory where the configuration file is stored. |
-| **Open temp directory** | Opens the temporary directory where converted text files are stored. |
-| **Clear temporary files** | Deletes temporary files created during the conversion or preview. |
+| **Open config directory** | Opens the directory where the configuration file is stored. |
+| **Open cache directory** | Opens the cache directory where converted text files are stored. |
+| **Clear cache files** | Deletes cache files created during the conversion or preview. |
 | **Check for updates at startup** | Automatically checks for updates when the program starts. |
 | **Disable Kokoro's internet access** | Prevents Kokoro from downloading models or voices from HuggingFace Hub, useful for offline use. |
 | **Reset to default settings** | Resets all settings to their default values. |
@@ -174,7 +174,7 @@ Abogen will process each item in the queue automatically, saving outputs as conf
 > Special thanks to [@jborza](https://github.com/jborza) for adding queue mode in PR [#35](https://github.com/denizsafak/abogen/pull/35)
 
 ## `About Chapter Markers`
-When you process ePUB or PDF files, Abogen converts them into text files stored in your temporary directory. When you click "Edit," you're actually modifying these converted text files. In these text files, you'll notice tags that look like this:
+When you process ePUB or PDF files, Abogen converts them into text files stored in your cache directory. When you click "Edit," you're actually modifying these converted text files. In these text files, you'll notice tags that look like this:
 
 ```
 <<CHAPTER_MARKER:Chapter Title>>
@@ -270,7 +270,7 @@ Abogen launches automatically inside the container.
 
 Known issues:
 - Audio preview is not working inside container (ALSA error).
-- `Open temp directory` and `Open configuration directory` options in settings not working. (Tried pcmanfm, did not work with Abogen).
+- `Open cache directory` and `Open configuration directory` options in settings not working. (Tried pcmanfm, did not work with Abogen).
 
 (Special thanks to [@geo38](https://www.reddit.com/user/geo38/) from Reddit, who provided the Dockerfile and instructions in [this comment](https://www.reddit.com/r/selfhosted/comments/1k8x1yo/comment/mpe0bz8/).)
 

abogen/VERSION

@@ -1 +1 @@
-1.1.2
+1.1.5

abogen/constants.py

@@ -31,6 +31,28 @@ LANGUAGE_DESCRIPTIONS = {
     "z": "Mandarin Chinese",
 }
 
+# Supported sound formats
+SUPPORTED_SOUND_FORMATS = [
+    "wav",
+    "mp3",
+    "opus",
+    "m4b",
+    "flac",
+]
+
+# Supported subtitle formats
+SUPPORTED_SUBTITLE_FORMATS = [
+    "srt",
+    "ass",
+]
+
+# Supported input formats
+SUPPORTED_INPUT_FORMATS = [
+    "epub",
+    "pdf",
+    "txt",
+]
+
 # Supported languages for subtitle generation
 # Currently, only 'a (American English)' and 'b (British English)' are supported for subtitle generation.
 # This is because tokens that contain timestamps are not generated for other languages in the Kokoro pipeline.

abogen/conversion.py

@@ -1,6 +1,5 @@
 import os
 import re
-import tempfile
 import time
 import chardet
 import charset_normalizer
@@ -9,14 +8,15 @@ from platformdirs import user_desktop_dir
 from PyQt5.QtCore import QThread, pyqtSignal, Qt, QTimer
 from PyQt5.QtWidgets import QCheckBox, QVBoxLayout, QDialog, QLabel, QDialogButtonBox
 import soundfile as sf
-from abogen.utils import clean_text, create_process
+from abogen.utils import clean_text, create_process, get_user_cache_path
 from abogen.constants import (
-    PROGRAM_NAME,
     LANGUAGE_DESCRIPTIONS,
     SAMPLE_VOICE_TEXTS,
     COLORS,
     CHAPTER_OPTIONS_COUNTDOWN,
     SUBTITLE_FORMATS,
+    SUPPORTED_SOUND_FORMATS,
+    SUPPORTED_SUBTITLE_FORMATS,
 )
 from abogen.voice_formulas import get_new_voice
 import abogen.hf_tracker as hf_tracker
@@ -426,29 +426,19 @@ class ConversionThread(QThread):
                 )
             # Find a unique suffix for both folder and merged file, always
             counter = 1
+            allowed_exts = set(SUPPORTED_SOUND_FORMATS + SUPPORTED_SUBTITLE_FORMATS)
             while True:
                 suffix = f"_{counter}" if counter > 1 else ""
                 chapters_out_dir_candidate = os.path.join(
                     parent_dir, f"{base_name}{suffix}_chapters"
                 )
-                merged_file_candidate = os.path.join(
-                    parent_dir, f"{base_name}{suffix}.{self.output_format}"
+                # Only check for files with allowed extensions (extension without dot, case-insensitive)
+                clash = any(
+                    os.path.splitext(fname)[0] == f"{base_name}{suffix}" and
+                    os.path.splitext(fname)[1][1:].lower() in allowed_exts
+                    for fname in os.listdir(parent_dir)
                 )
-                merged_srt_candidate = (
-                    os.path.splitext(merged_file_candidate)[0] + ".srt"
-                )
-                if (
-                    not os.path.exists(chapters_out_dir_candidate)
-                    and (
-                        not merge_chapters_at_end
-                        or not os.path.exists(merged_file_candidate)
-                    )
-                    and (
-                        self.subtitle_mode == "Disabled"
-                        or not merge_chapters_at_end
-                        or not os.path.exists(merged_srt_candidate)
-                    )
-                ):
+                if not os.path.exists(chapters_out_dir_candidate) and not clash:
                     break
                 counter += 1
             if save_chapters_separately and total_chapters > 1:
@@ -488,13 +478,37 @@ class ConversionThread(QThread):
                     )
                     ffmpeg_proc = None
                 elif self.output_format == "m4b":
-                    temp_wav_path = os.path.join(
-                        out_dir, f"temp_{base_name}{suffix}.wav"
-                    )
-                    merged_out_file = sf.SoundFile(
-                        temp_wav_path, "w", samplerate=24000, channels=1, format="wav"
-                    )
+                    # Real-time M4B generation using FFmpeg pipe
+                    static_ffmpeg.add_paths()
+                    merged_out_file = None
                     ffmpeg_proc = None
+                    metadata_options = (
+                            self._extract_and_add_metadata_tags_to_ffmpeg_cmd()
+                        )
+                    # Prepare ffmpeg command for m4b output
+                    cmd = [
+                        "ffmpeg",
+                        "-y",
+                        "-thread_queue_size",
+                        "32768",
+                        "-f",
+                        "f32le",
+                        "-ar",
+                        "24000",
+                        "-ac",
+                        "1",
+                        "-i",
+                        "pipe:0",
+                        "-c:a",
+                        "aac",
+                        "-q:a",
+                        "2",
+                        "-movflags",
+                        "+faststart+use_metadata_tags",
+                    ]
+                    cmd += metadata_options
+                    cmd.append(merged_out_path)
+                    ffmpeg_proc = create_process(cmd, stdin=subprocess.PIPE, text=False)
                 elif self.output_format == "opus":
                     static_ffmpeg.add_paths()
                     cmd = [
@@ -793,6 +807,7 @@ class ConversionThread(QThread):
                                 tokens_with_timestamps,
                                 new_entries,
                                 self.max_subtitle_words,
+                                fallback_end_time=chunk_start + chunk_dur,
                             )
                             if merged_subtitle_file:
                                 subtitle_format = getattr(
@@ -819,6 +834,7 @@ class ConversionThread(QThread):
                                 chapter_tokens_with_timestamps,
                                 new_chapter_entries,
                                 self.max_subtitle_words,
+                                fallback_end_time=chapter_current_time + chunk_dur,
                             )
                             if chapter_subtitle_file:
                                 subtitle_format = getattr(
@@ -910,8 +926,9 @@ class ConversionThread(QThread):
                 if self.output_format in ["wav", "mp3", "flac"]:
                     merged_out_file.close()
                 elif self.output_format == "m4b":
-                    merged_out_file.close()
-                    # Only generate chapters info if there are chapters
+                    ffmpeg_proc.stdin.close()
+                    ffmpeg_proc.wait()
+                    # Add chapters via fast post-processing
                     if total_chapters > 1:
                         chapters_info_path = f"{base_filepath_no_ext}_chapters.txt"
                         with open(chapters_info_path, "w", encoding="utf-8") as f:
@@ -923,15 +940,19 @@ class ConversionThread(QThread):
                                 f.write(f"START={int(chapter['start']*1000)}\n")
                                 f.write(f"END={int(chapter['end']*1000)}\n")
                                 f.write(f"title={chapter_title}\n\n")
+                        # Fast mux chapters into m4b (write to temp file, then replace original)
+                        static_ffmpeg.add_paths()
+                        orig_path = merged_out_path
+                        root, ext = os.path.splitext(orig_path)
+                        tmp_path = root + ".tmp" + ext
                         metadata_options = (
                             self._extract_and_add_metadata_tags_to_ffmpeg_cmd()
                         )
-                        static_ffmpeg.add_paths()
                         cmd = [
                             "ffmpeg",
                             "-y",
                             "-i",
-                            temp_wav_path,
+                            orig_path,
                             "-i",
                             chapters_info_path,
                             "-map",
@@ -940,46 +961,15 @@ class ConversionThread(QThread):
                             "1",
                             "-map_chapters",
                             "1",
-                            *metadata_options,
                             "-c:a",
-                            "aac",
-                            "-q:a",
-                            "2",
-                            "-movflags",
-                            "+faststart+use_metadata_tags",
-                            merged_out_path,
+                            "copy",
                         ]
+                        cmd += metadata_options
+                        cmd.append(tmp_path)
                         proc = create_process(cmd)
                         proc.wait()
-                        self.log_updated.emit(
-                            ("\nCleaning up temporary files...", "grey")
-                        )
-                        if os.path.exists(chapters_info_path):
-                            os.remove(chapters_info_path)
-                    else:
-                        # No chapters: skip chapters info and related ffmpeg args
-                        metadata_options = (
-                            self._extract_and_add_metadata_tags_to_ffmpeg_cmd()
-                        )
-                        static_ffmpeg.add_paths()
-                        cmd = [
-                            "ffmpeg",
-                            "-y",
-                            "-i",
-                            temp_wav_path,
-                            *metadata_options,
-                            "-c:a",
-                            "aac",
-                            "-q:a",
-                            "2",
-                            "-movflags",
-                            "+faststart+use_metadata_tags",
-                            merged_out_path,
-                        ]
-                        proc = create_process(cmd)
-                        proc.wait()
-                    if os.path.exists(temp_wav_path):
-                        os.remove(temp_wav_path)
+                        os.replace(tmp_path, orig_path)
+                        os.remove(chapters_info_path)
                 elif self.output_format in ["opus"]:
                     ffmpeg_proc.stdin.close()
                     ffmpeg_proc.wait()
@@ -1146,7 +1136,11 @@ class ConversionThread(QThread):
         return f"{h}:{m:02}:{s:02}.{cs:02}"
 
     def _process_subtitle_tokens(
-        self, tokens_with_timestamps, subtitle_entries, max_subtitle_words
+        self,
+        tokens_with_timestamps,
+        subtitle_entries,
+        max_subtitle_words,
+        fallback_end_time=None,
     ):
         """Helper function to process subtitle tokens according to the subtitle mode"""
         if not tokens_with_timestamps:
@@ -1191,9 +1185,15 @@ class ConversionThread(QThread):
                 sentence_text = ""
                 for t in current_sentence:
                     sentence_text += t["text"] + (t.get("whitespace", "") or "")
-
                 subtitle_entries.append((start_time, end_time, sentence_text.strip()))
 
+            # Fallback for last entry
+            if subtitle_entries and fallback_end_time is not None:
+                last_entry = subtitle_entries[-1]
+                start, end, text = last_entry
+                if end is None or end <= start or end <= 0:
+                    subtitle_entries[-1] = (start, fallback_end_time, text)
+
         else:
             # Word count-based grouping
             try:
@@ -1230,36 +1230,12 @@ class ConversionThread(QThread):
                     subtitle_entries.append(
                         (group[0]["start"], group[-1]["end"], text.strip())
                     )
-
-    def _write_ass_subtitle(
-        self, file_path, subtitle_entries, is_centered=False, is_narrow=False
-    ):
-        with open(file_path, "w", encoding="utf-8", errors="replace") as f:
-            # Minimal ASS header
-            f.write("[Script Info]\n")
-            f.write("Title: Generated by Abogen\n")
-            f.write("ScriptType: v4.00+\n\n")
-
-            # Only events section, use override tags for positioning
-            f.write("[Events]\n")
-            f.write(
-                "Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text\n"
-            )
-
-            # Set margin based on is_narrow parameter
-            margin = "90" if is_narrow else ""
-            alignment_tag = ""
-            if is_centered:
-                alignment = 5
-                alignment_tag = f"{{\\an{alignment}}}"
-
-            # Write each subtitle with override tag for alignment and margins
-            for i, (start, end, text) in enumerate(subtitle_entries, 1):
-                start_time = self._ass_time(start)
-                end_time = self._ass_time(end)
-                f.write(
-                    f"Dialogue: 0,{start_time},{end_time},Default,,{margin},{margin},0,,{alignment_tag}{text}\n"
-                )
+            # Fallback for last entry
+            if subtitle_entries and fallback_end_time is not None:
+                last_entry = subtitle_entries[-1]
+                start, end, text = last_entry
+                if end is None or end <= start or end <= 0:
+                    subtitle_entries[-1] = (start, fallback_end_time, text)
 
     def cancel(self):
         self.cancel_requested = True
@@ -1311,10 +1287,7 @@ class VoicePreviewThread(QThread):
         self.use_gpu = use_gpu
 
         # Cache location for preview audio
-        self.cache_dir = os.path.join(
-            tempfile.gettempdir(), PROGRAM_NAME, "preview_cache"
-        )
-        os.makedirs(self.cache_dir, exist_ok=True)
+        self.cache_dir = get_user_cache_path("preview_cache")
 
         # Calculate cache path
         self.cache_path = self._get_cache_path()

abogen/gui.py

@@ -62,6 +62,7 @@ from abogen.utils import (
     prevent_sleep_end,
     calculate_text_length,
     get_resource_path,
+    get_user_cache_path,
     LoadPipelineThread,
 )
 from abogen.conversion import ConversionThread, VoicePreviewThread, PlayAudioThread
@@ -564,12 +565,12 @@ class TextboxDialog(QDialog):
             self.reject()
         else:
             # Check if we need to warn about overwriting a non-temporary file
-            if hasattr(self, "is_non_temp_file") and self.is_non_temp_file:
+            if hasattr(self, "is_non_cache_file") and self.is_non_cache_file:
                 msg_box = QMessageBox(self)
                 msg_box.setIcon(QMessageBox.Warning)
                 msg_box.setWindowTitle("File Overwrite Warning")
                 msg_box.setText(
-                    f"You are about to overwrite the original file:\n{self.non_temp_file_path}"
+                    f"You are about to overwrite the original file:\n{self.non_cache_file_path}"
                 )
                 msg_box.setInformativeText("Do you want to continue?")
                 msg_box.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
@@ -591,11 +592,11 @@ class TextboxDialog(QDialog):
 
             # Get default filename from original file if editing
             initial_path = ""
-            if hasattr(self, "non_temp_file_path") and self.non_temp_file_path:
-                initial_path = self.non_temp_file_path
+            if hasattr(self, "non_cache_file_path") and self.non_cache_file_path:
+                initial_path = self.non_cache_file_path
 
             # For EPUB and PDF files, use the displayed_file_path from the main window
-            # This gives a better filename instead of the temporary file path
+            # This gives a better filename instead of the cache file path
             main_window = self.parent()
             if (
                 hasattr(main_window, "displayed_file_path")
@@ -763,7 +764,11 @@ class abogen(QWidget):
         self.setWindowTitle(f"{PROGRAM_NAME} v{VERSION}")
         screen = QApplication.primaryScreen().geometry()
         width, height = 500, 800
-        x, y = (screen.width() - width) // 2, (screen.height() - height) // 2
+        x = (screen.width() - width) // 2
+        # If desired height is larger than screen, fit to screen height
+        if height > screen.height() - 65:
+            height = screen.height() - 100  # Leave a margin for window borders
+        y = max((screen.height() - height) // 2, 0)
         self.setGeometry(x, y, width, height)
         outer_layout = QVBoxLayout()
         outer_layout.setContentsMargins(15, 15, 15, 15)
@@ -1191,7 +1196,7 @@ class abogen(QWidget):
             if book_path.lower().endswith(".pdf"):
                 self.pdf_has_bookmarks = getattr(dialog, "has_pdf_bookmarks", False)
 
-            # Use "abogen" prefix for temporary files
+            # Use "abogen" prefix for cache files
             # Extract base name without extension
             base_name = os.path.splitext(os.path.basename(book_path))[0]
 
@@ -1201,15 +1206,15 @@ class abogen(QWidget):
                     self, "Select Project Folder", "", QFileDialog.ShowDirsOnly
                 )
                 if not project_dir:
-                    # User cancelled, fallback to temp
+                    # User cancelled, fallback to cache
                     self.save_as_project = False
-                    temp_dir = os.path.join(tempfile.gettempdir(), PROGRAM_NAME)
+                    cache_dir = get_user_cache_path()
                 else:
                     # Create project folder structure
                     project_name = f"{base_name}_project"
                     project_dir = os.path.join(project_dir, project_name)
-                    temp_dir = os.path.join(project_dir, "text")
-                    os.makedirs(temp_dir, exist_ok=True)
+                    cache_dir = os.path.join(project_dir, "text")
+                    os.makedirs(cache_dir, exist_ok=True)
 
                     # Save metadata if available
                     meta_dir = os.path.join(project_dir, "metadata")
@@ -1264,11 +1269,10 @@ class abogen(QWidget):
                         with open(cover_path, "wb") as f:
                             f.write(dialog.book_metadata["cover_image"])
             else:
-                temp_dir = os.path.join(tempfile.gettempdir(), PROGRAM_NAME)
-                os.makedirs(temp_dir, exist_ok=True)
+                cache_dir = get_user_cache_path()
 
             fd, tmp = tempfile.mkstemp(
-                prefix=f"{base_name}_", suffix=".txt", dir=temp_dir
+                prefix=f"{base_name}_", suffix=".txt", dir=cache_dir
             )
             os.close(fd)
             with open(tmp, "w", encoding="utf-8") as f:
@@ -1289,13 +1293,13 @@ class abogen(QWidget):
             return
 
         editing = False
-        is_temp_file = False
+        is_cache_file = False
         # If path is explicitly provided, use it
         if file_path and os.path.exists(file_path):
             editing = True
             edit_file = file_path
-            # Check if this is a temporary file
-            is_temp_file = tempfile.gettempdir() in file_path
+            # Check if this is a cache file
+            is_cache_file = get_user_cache_path() in file_path
         # Otherwise use selected_file if it's a txt file
         elif (
             self.selected_file_type == "txt"
@@ -1304,8 +1308,8 @@ class abogen(QWidget):
         ):
             editing = True
             edit_file = self.selected_file
-            # Check if this is a temporary file
-            is_temp_file = tempfile.gettempdir() in self.selected_file
+            # Check if this is a cache file
+            is_cache_file = get_user_cache_path() in self.selected_file
 
         dialog = TextboxDialog(self)
         if editing:
@@ -1317,10 +1321,10 @@ class abogen(QWidget):
                     dialog.text_edit.toPlainText()
                 )  # Store original text
 
-                # If editing a non-temporary file, alert the user
-                if not is_temp_file:
-                    dialog.is_non_temp_file = True
-                    dialog.non_temp_file_path = edit_file
+                # If editing a non-cache file, alert the user
+                if not is_cache_file:
+                    dialog.is_non_cache_file = True
+                    dialog.non_cache_file_path = edit_file
             except Exception:
                 pass
         if dialog.exec_() == QDialog.Accepted:
@@ -1338,10 +1342,9 @@ class abogen(QWidget):
                     # Hide chapters button since we're using custom text now
                     self.input_box.chapters_btn.hide()
                 else:
-                    temp_dir = os.path.join(tempfile.gettempdir(), PROGRAM_NAME)
-                    os.makedirs(temp_dir, exist_ok=True)
+                    cache_dir = get_user_cache_path()
                     fd, tmp = tempfile.mkstemp(
-                        prefix="abogen_", suffix=".txt", dir=temp_dir
+                        prefix="abogen_", suffix=".txt", dir=cache_dir
                     )
                     os.close(fd)
                     with open(tmp, "w", encoding="utf-8") as f:
@@ -2149,7 +2152,7 @@ class abogen(QWidget):
         if not lang_to_cache or not voice_to_cache:  # Not enough info
             return None
 
-        cache_dir = os.path.join(tempfile.gettempdir(), PROGRAM_NAME, "preview_cache")
+        cache_dir = get_user_cache_path("preview_cache")
 
         if "*" in voice_to_cache:  # Voice formula
             voice_id = (
@@ -2767,17 +2770,17 @@ class abogen(QWidget):
         reveal_config_action.triggered.connect(self.reveal_config_in_explorer)
         menu.addAction(reveal_config_action)
 
-        # Add open temp directory option
-        open_temp_action = QAction("Open temp directory", self)
-        open_temp_action.triggered.connect(self.open_temp_directory)
-        menu.addAction(open_temp_action)
+        # Add open cache directory option
+        open_cache_action = QAction("Open cache directory", self)
+        open_cache_action.triggered.connect(self.open_cache_directory)
+        menu.addAction(open_cache_action)
 
-        # Add clear temporary files option
-        clear_temp_action = QAction("Clear temporary files", self)
-        clear_temp_action.triggered.connect(self.clear_temp_files)
-        menu.addAction(clear_temp_action)
+        # Add clear cache files option
+        clear_cache_action = QAction("Clear cache files", self)
+        clear_cache_action.triggered.connect(self.clear_cache_files)
+        menu.addAction(clear_cache_action)
 
-        # Add seperator"
+        # Add separator
         menu.addSeparator()
 
         # Add "Disable Kokoro's internet access" option
@@ -2815,6 +2818,24 @@ class abogen(QWidget):
         self.config["replace_single_newlines"] = enabled
         save_config(self.config)
 
+    def restart_app(self):
+        from PyQt5.QtCore import QProcess
+        import sys
+
+        exe = sys.executable
+        args = sys.argv
+
+        # On Windows, use .exe if available
+        if platform.system() == "Windows":
+            script_path = args[0]
+            if not script_path.lower().endswith(".exe"):
+                exe_path = os.path.splitext(script_path)[0] + ".exe"
+                if os.path.exists(exe_path):
+                    args[0] = exe_path
+
+        QProcess.startDetached(exe, args)
+        QApplication.quit()
+
     def toggle_kokoro_internet_access(self, disabled):
         if disabled:
             message = (
@@ -2838,11 +2859,7 @@ class abogen(QWidget):
             self.config["disable_kokoro_internet"] = disabled
             save_config(self.config)
             try:
-                from PyQt5.QtCore import QProcess
-                import sys
-
-                QProcess.startDetached(sys.executable, sys.argv)
-                QApplication.quit()
+                self.restart_app()
             except Exception as e:
                 QMessageBox.critical(
                     self, "Restart Failed", f"Failed to restart the application:\n{e}"
@@ -2858,16 +2875,12 @@ class abogen(QWidget):
         )
         if reply == QMessageBox.Yes:
             from abogen.utils import get_user_config_path
-            import sys
 
             config_path = get_user_config_path()
             try:
                 if os.path.exists(config_path):
                     os.remove(config_path)
-                from PyQt5.QtCore import QProcess
-
-                QProcess.startDetached(sys.executable, sys.argv)
-                QApplication.quit()
+                self.restart_app()
             except Exception as e:
                 QMessageBox.critical(
                     self, "Reset Error", f"Could not reset settings:\n{e}"
@@ -2886,21 +2899,21 @@ class abogen(QWidget):
                 self, "Config Error", f"Could not open config location:\n{e}"
             )
 
-    def open_temp_directory(self):
-        """Open the temporary directory used by the program."""
+    def open_cache_directory(self):
+        """Open the cache directory used by the program."""
         try:
-            # Get the temp directory path
-            temp_dir = os.path.join(tempfile.gettempdir(), PROGRAM_NAME)
+            # Get the cache directory path
+            cache_dir = get_user_cache_path()
 
             # Create the directory if it doesn't exist
-            if not os.path.exists(temp_dir):
-                os.makedirs(temp_dir)
+            if not os.path.exists(cache_dir):
+                os.makedirs(cache_dir)
 
             # Open the directory in file explorer
-            QDesktopServices.openUrl(QUrl.fromLocalFile(temp_dir))
+            QDesktopServices.openUrl(QUrl.fromLocalFile(cache_dir))
         except Exception as e:
             QMessageBox.critical(
-                self, "Temp Directory Error", f"Could not open temp directory:\n{e}"
+                self, "Cache Directory Error", f"Could not open cache directory:\n{e}"
             )
 
     def add_shortcut_to_desktop(self):
@@ -3240,23 +3253,23 @@ Categories=AudioVideo;Audio;Utility;
                 )
             pass
 
-    def clear_temp_files(self):
-        """Clear temporary files created by the program."""
+    def clear_cache_files(self):
+        """Clear cache files created by the program."""
         import glob
 
         try:
-            # Get the abogen temp directory
-            temp_dir = os.path.join(tempfile.gettempdir(), PROGRAM_NAME)
+            # Get the abogen cache directory
+            cache_dir = get_user_cache_path()
 
-            # Find all .txt files in the abogen temp directory
-            pattern = os.path.join(temp_dir, "*.txt")
-            temp_files = glob.glob(pattern)
+            # Find all .txt files in the abogen cache directory
+            pattern = os.path.join(cache_dir, "*.txt")
+            cache_files = glob.glob(pattern)
 
             # Count the files
-            file_count = len(temp_files)
+            file_count = len(cache_files)
 
             # Check for preview cache files
-            preview_cache_dir = os.path.join(temp_dir, "preview_cache")
+            preview_cache_dir = os.path.join(cache_dir, "preview_cache")
             preview_files = []
             if os.path.exists(preview_cache_dir):
                 preview_pattern = os.path.join(preview_cache_dir, "*.wav")
@@ -3266,16 +3279,16 @@ Categories=AudioVideo;Audio;Utility;
 
             if file_count == 0 and preview_count == 0:
                 QMessageBox.information(
-                    self, "No Temporary Files", "No temporary files were found."
+                    self, "No Cache Files", "No cache files were found."
                 )
                 return
 
             # Create a custom message box with checkbox
             msg_box = QMessageBox(self)
             msg_box.setIcon(QMessageBox.Question)
-            msg_box.setWindowTitle("Clear Temporary Files")
+            msg_box.setWindowTitle("Clear Cache Files")
 
-            msg_text = f"Found {file_count} temporary file{'s' if file_count != 1 else ''} in the {PROGRAM_NAME} temp folder."
+            msg_text = f"Found {file_count} cache file{'s' if file_count != 1 else ''} in the {PROGRAM_NAME} cache folder."
             if preview_count > 0:
                 msg_text += f"\nAlso found {preview_count} preview cache file{'s' if preview_count != 1 else ''}."
 
@@ -3299,7 +3312,7 @@ Categories=AudioVideo;Audio;Utility;
 
             # Delete the text files
             deleted_count = 0
-            for file_path in temp_files:
+            for file_path in cache_files:
                 try:
                     os.remove(file_path)
                     deleted_count += 1
@@ -3322,12 +3335,12 @@ Categories=AudioVideo;Audio;Utility;
                 result_msg += f"\nAlso deleted {deleted_preview_count} preview cache file{'s' if deleted_preview_count != 1 else ''}."
 
             # Show results
-            QMessageBox.information(self, "Temporary Files Cleared", result_msg)
+            QMessageBox.information(self, "Cache Files Cleared", result_msg)
 
-            # If currently selected file is in the temp directory, clear the UI
+            # If currently selected file is in the cache directory, clear the UI
             if (
                 self.selected_file
-                and os.path.dirname(self.selected_file) == temp_dir
+                and os.path.dirname(self.selected_file) == cache_dir
                 and self.selected_file.endswith(".txt")
             ):
                 self.input_box.clear_input()

abogen/main.py

@@ -2,6 +2,8 @@ from json import load
 import os
 import sys
 import platform
+import atexit
+import signal
 from PyQt5.QtWidgets import QApplication
 from PyQt5.QtGui import QIcon
 from PyQt5.QtCore import qInstallMessageHandler, QtMsgType
@@ -9,7 +11,7 @@ from PyQt5.QtCore import qInstallMessageHandler, QtMsgType
 # Add the directory to Python path
 sys.path.insert(0, os.path.join(os.path.dirname(__file__)))
 
-from abogen.utils import get_resource_path, load_config
+from abogen.utils import get_resource_path, load_config, prevent_sleep_end
 
 # Set Hugging Face Hub environment variables
 os.environ["HF_HUB_DISABLE_TELEMETRY"] = "1"  # Disable Hugging Face telemetry
@@ -27,6 +29,17 @@ from abogen.constants import PROGRAM_NAME, VERSION
 os.environ["MIOPEN_FIND_MODE"] = "FAST"
 os.environ["MIOPEN_CONV_PRECISE_ROCM_TUNING"] = "0"
 
+# Reset sleep states
+atexit.register(prevent_sleep_end)
+
+# Also handle signals (Ctrl+C, kill, etc.)
+def _cleanup_sleep(signum, frame):
+    prevent_sleep_end()
+    sys.exit(0)
+
+signal.signal(signal.SIGINT, _cleanup_sleep)
+signal.signal(signal.SIGTERM, _cleanup_sleep)
+
 # Ensure sys.stdout and sys.stderr are valid in GUI mode
 if sys.stdout is None:
     sys.stdout = open(os.devnull, "w")
@@ -37,7 +50,6 @@ if sys.stderr is None:
 if platform.system() == "Darwin" and platform.processor() == "arm":
     os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] = "1"
 
-
 # Custom message handler to filter out specific Qt warnings
 def qt_message_handler(mode, context, message):
     if "Wayland does not support QWindow::requestActivate()" in message:

abogen/utils.py

@@ -74,14 +74,23 @@ def get_user_config_path():
         if os.path.exists(custom_dir):
             config_dir = custom_dir
         else:
-            config_dir = user_config_dir("abogen", appauthor=False, roaming=True)
+            config_dir = user_config_dir("abogen", appauthor=False, roaming=True, ensure_exists=True)
     else:
         # Windows and fallback case
-        config_dir = user_config_dir("abogen", appauthor=False, roaming=True)
+        config_dir = user_config_dir("abogen", appauthor=False, roaming=True, ensure_exists=True)
 
-    os.makedirs(config_dir, exist_ok=True)
     return os.path.join(config_dir, "config.json")
 
+# Define cache path
+def get_user_cache_path(folder=None):
+    from platformdirs import user_cache_dir
+
+    cache_dir = user_cache_dir("abogen", appauthor=False, opinion=True, ensure_exists=True)
+    if folder:
+        cache_dir = os.path.join(cache_dir, folder)
+        # Ensure the directory exists
+        os.makedirs(cache_dir, exist_ok=True)
+    return cache_dir
 
 _sleep_procs = {"Darwin": None, "Linux": None}  # Store sleep prevention processes
 
@@ -244,6 +253,8 @@ def get_gpu_acceleration(enabled):
 
 
 def prevent_sleep_start():
+    from abogen.constants import PROGRAM_NAME
+
     system = platform.system()
     if system == "Windows":
         import ctypes
@@ -254,11 +265,15 @@ def prevent_sleep_start():
     elif system == "Darwin":
         _sleep_procs["Darwin"] = create_process(["caffeinate"])
     elif system == "Linux":
-        # use a sleep that never exits so inhibition stays active
+        # Add program name and reason for inhibition
+        program_name = PROGRAM_NAME
+        reason = "Prevent sleep during abogen process"
         _sleep_procs["Linux"] = create_process(
             [
                 "systemd-inhibit",
-                "--what=handle-lid-switch:sleep",
+                f"--who={program_name}",
+                f"--why={reason}",
+                "--what=sleep",
                 "--mode=block",
                 "sleep",
                 "infinity",