refactor: split tts.py into per-backend packages

1 files changed, 30 insertions, 23 deletions

diff --git a/app/tests/test_converter.py b/app/tests/test_converter.py
index 7aa9c69..53e2897 100644
--- a/app/tests/test_converter.py
+++ b/app/tests/test_converter.py
@@ -9,7 +9,14 @@ from contextlib import redirect_stdout
 from pathlib import Path
 from unittest.mock import MagicMock, patch
 
-from converter import config, tts
+from converter import config
+from converter.clients import (
+    BACKEND_AUDIOCPP,
+    BACKEND_FASTER,
+    BACKEND_QWEN,
+    VOICE_MODE_CLONE,
+    VOICE_MODE_CUSTOM,
+)
 from converter import converter as converter_mod
 from converter.converter import (
     AudiobookConverter,
@@ -56,17 +63,17 @@ class ConfigurationValidationTests(unittest.TestCase):
 
     def test_language_defaults_to_config(self):
         with patch("converter.converter.QwenTTSClient") as mock_tts:
-            AudiobookConverter(backend=tts.BACKEND_QWEN)
+            AudiobookConverter(backend=BACKEND_QWEN)
         self.assertEqual(mock_tts.call_args.kwargs["language"], config.LANGUAGE)
 
     def test_output_format_defaults_to_config(self):
         with patch("converter.converter.QwenTTSClient"):
-            converter = AudiobookConverter(backend=tts.BACKEND_QWEN)
+            converter = AudiobookConverter(backend=BACKEND_QWEN)
         self.assertEqual(converter.output_format, config.AUDIO_FORMAT)
 
     def test_language_normalized_before_tts_client(self):
         with patch("converter.converter.QwenTTSClient") as mock_tts:
-            converter = AudiobookConverter(language="ja", backend=tts.BACKEND_QWEN)
+            converter = AudiobookConverter(language="ja", backend=BACKEND_QWEN)
         self.assertEqual(converter.language, "Japanese")
         self.assertEqual(mock_tts.call_args.kwargs["language"], "Japanese")
 
@@ -129,40 +136,40 @@ class NarratorTagTests(unittest.TestCase):
         converter = AudiobookConverter.__new__(AudiobookConverter)
         converter.voice_mode = voice_mode
         converter.voice_clone_ref_audio = ref_audio
-        converter.backend = tts.BACKEND_QWEN
+        converter.backend = BACKEND_QWEN
         converter.voice = None
         converter.instructions = instructions
         return converter
 
     def test_custom_voice_uses_speaker_display_name(self):
-        self.assertEqual(self._converter(tts.VOICE_MODE_CUSTOM)._narrator_tag(),
+        self.assertEqual(self._converter(VOICE_MODE_CUSTOM)._narrator_tag(),
                          "Vivian")
 
     def test_multi_word_display_name_gets_underscores(self):
         with patch.object(config, "SPEAKER", "uncle_fu"):
-            self.assertEqual(self._converter(tts.VOICE_MODE_CUSTOM)._narrator_tag(),
+            self.assertEqual(self._converter(VOICE_MODE_CUSTOM)._narrator_tag(),
                              "Uncle_Fu")
 
     def test_clone_uses_reference_audio_stem(self):
-        self.assertEqual(self._converter(tts.VOICE_MODE_CLONE, "/x/ref.wav")._narrator_tag(),
+        self.assertEqual(self._converter(VOICE_MODE_CLONE, "/x/ref.wav")._narrator_tag(),
                          "ref")
 
     def test_clone_stem_spaces_become_underscores(self):
-        self.assertEqual(self._converter(tts.VOICE_MODE_CLONE, "/x/my voice.wav")._narrator_tag(),
+        self.assertEqual(self._converter(VOICE_MODE_CLONE, "/x/my voice.wav")._narrator_tag(),
                          "my_voice")
 
     def test_invalid_characters_sanitized(self):
-        self.assertEqual(self._converter(tts.VOICE_MODE_CLONE, "/x/bad:name?.wav")._narrator_tag(),
+        self.assertEqual(self._converter(VOICE_MODE_CLONE, "/x/bad:name?.wav")._narrator_tag(),
                          "bad_name")
 
     def test_empty_after_sanitize_falls_back(self):
-        self.assertEqual(self._converter(tts.VOICE_MODE_CLONE, "/x/???.wav")._narrator_tag(),
+        self.assertEqual(self._converter(VOICE_MODE_CLONE, "/x/???.wav")._narrator_tag(),
                          "narrator")
 
     def _audiocpp_converter(self, voice=None, instructions=None):
-        converter = self._converter(tts.VOICE_MODE_CUSTOM,
+        converter = self._converter(VOICE_MODE_CUSTOM,
                                     instructions=instructions)
-        converter.backend = tts.BACKEND_AUDIOCPP
+        converter.backend = BACKEND_AUDIOCPP
         converter.voice = voice
         return converter
 
@@ -202,7 +209,7 @@ class NarratorTagTests(unittest.TestCase):
                 with patch("builtins.input",
                            side_effect=AssertionError("should not prompt")):
                     _, planned = AudiobookConverter.preflight_overwrites(
-                        tts.BACKEND_AUDIOCPP, None, tts.VOICE_MODE_CUSTOM,
+                        BACKEND_AUDIOCPP, None, VOICE_MODE_CUSTOM,
                         None, "mp3", instructions="A warm narrator")
                 self.assertEqual(planned, [(converter_mod.BOOKS_FOLDER / "book.txt",
                                             "book_designed")])
@@ -324,8 +331,8 @@ class DebugDumpTests(unittest.TestCase):
 
     def test_debug_flag_wiring(self):
         with patch("converter.converter.QwenTTSClient"):
-            self.assertFalse(AudiobookConverter(backend=tts.BACKEND_QWEN).debug)
-            self.assertTrue(AudiobookConverter(debug=True, backend=tts.BACKEND_QWEN).debug)
+            self.assertFalse(AudiobookConverter(backend=BACKEND_QWEN).debug)
+            self.assertTrue(AudiobookConverter(debug=True, backend=BACKEND_QWEN).debug)
 
 
 class SetupLoggingTests(unittest.TestCase):
@@ -415,7 +422,7 @@ class ChunkProgressOutputTests(unittest.TestCase):
 
     def _converter(self):
         converter = AudiobookConverter.__new__(AudiobookConverter)
-        converter.backend = tts.BACKEND_AUDIOCPP
+        converter.backend = BACKEND_AUDIOCPP
         converter.speed = 1.0
         converter.output_format = "mp3"
         converter.tts = MagicMock()
@@ -514,14 +521,14 @@ class PreflightOverwritesTests(unittest.TestCase):
         (converter_mod.BOOKS_FOLDER / "book.txt").unlink()
         with patch("builtins.input", side_effect=AssertionError("should not prompt")):
             book_files, planned = AudiobookConverter.preflight_overwrites(
-                tts.BACKEND_QWEN, None, tts.VOICE_MODE_CUSTOM, None, "mp3")
+                BACKEND_QWEN, None, VOICE_MODE_CUSTOM, None, "mp3")
         self.assertEqual(book_files, [])
         self.assertEqual(planned, [])
 
     def test_new_book_planned_without_prompt(self):
         with patch("builtins.input", side_effect=AssertionError("should not prompt")):
             book_files, planned = AudiobookConverter.preflight_overwrites(
-                tts.BACKEND_QWEN, None, tts.VOICE_MODE_CUSTOM, None, "mp3")
+                BACKEND_QWEN, None, VOICE_MODE_CUSTOM, None, "mp3")
         self.assertEqual(len(book_files), 1)
         self.assertEqual(planned, [(book_files[0], "book_Vivian")])
 
@@ -529,14 +536,14 @@ class PreflightOverwritesTests(unittest.TestCase):
         (converter_mod.AUDIOBOOKS_FOLDER / "book_Vivian.mp3").write_bytes(b"existing")
         with patch("builtins.input", return_value=""):
             book_files, planned = AudiobookConverter.preflight_overwrites(
-                tts.BACKEND_QWEN, None, tts.VOICE_MODE_CUSTOM, None, "mp3")
+                BACKEND_QWEN, None, VOICE_MODE_CUSTOM, None, "mp3")
         self.assertEqual(planned, [(book_files[0], "book_Vivian")])
 
     def test_existing_output_declined_is_skipped(self):
         (converter_mod.AUDIOBOOKS_FOLDER / "book_Vivian.mp3").write_bytes(b"existing")
         with patch("builtins.input", return_value="n"):
             book_files, planned = AudiobookConverter.preflight_overwrites(
-                tts.BACKEND_QWEN, None, tts.VOICE_MODE_CUSTOM, None, "mp3")
+                BACKEND_QWEN, None, VOICE_MODE_CUSTOM, None, "mp3")
         self.assertEqual(len(book_files), 1)
         self.assertEqual(planned, [])
 
@@ -552,9 +559,9 @@ class RunOverwritePromptTests(unittest.TestCase):
         converter_mod.AUDIOBOOKS_FOLDER = Path(self._output_tmp.name)
         (converter_mod.BOOKS_FOLDER / "book.txt").write_text("hello world", encoding="utf-8")
         self.converter = AudiobookConverter.__new__(AudiobookConverter)
-        self.converter.voice_mode = tts.VOICE_MODE_CUSTOM
+        self.converter.voice_mode = VOICE_MODE_CUSTOM
         self.converter.voice_clone_ref_audio = None
-        self.converter.backend = tts.BACKEND_QWEN
+        self.converter.backend = BACKEND_QWEN
         self.converter.voice = None
         self.converter.instructions = None
         self.converter.speed = 1.0