Add whisper.cpp JSON converter

tests/test_convert_whispercpp_json.py

@@ -0,0 +1,145 @@
+import json
+import tempfile
+import unittest
+from pathlib import Path
+
+from scripts.convert_whispercpp_json import (
+    WhisperCppConversionError,
+    convert_entries,
+    convert_whispercpp_json,
+    format_timestamp,
+)
+
+
+def whispercpp_entry(
+    text: str,
+    offset_from: int,
+    offset_to: int,
+    timestamp_from: str = "00:00:00,000",
+    timestamp_to: str = "00:00:01,000",
+) -> dict:
+    return {
+        "timestamps": {"from": timestamp_from, "to": timestamp_to},
+        "offsets": {"from": offset_from, "to": offset_to},
+        "text": text,
+    }
+
+
+class ConvertWhisperCppJsonTests(unittest.TestCase):
+    def test_valid_whispercpp_json_writes_compact_json_and_text(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            input_path = root / "whispercpp.json"
+            json_output = root / "converted.json"
+            text_output = root / "converted.txt"
+            input_path.write_text(
+                json.dumps(
+                    {
+                        "transcription": [
+                            whispercpp_entry(" Hello ", 0, 12340),
+                            whispercpp_entry("world", 12340, 13000),
+                        ]
+                    },
+                    ensure_ascii=False,
+                ),
+                encoding="utf-8",
+            )
+
+            summary = convert_whispercpp_json(input_path, json_output, text_output)
+
+            converted = json.loads(json_output.read_text(encoding="utf-8"))
+            self.assertEqual(converted["text"], "Hello world")
+            self.assertEqual(
+                converted["segments"],
+                [
+                    {"id": 0, "start": 0.0, "end": 12.34, "text": "Hello"},
+                    {"id": 1, "start": 12.34, "end": 13.0, "text": "world"},
+                ],
+            )
+            self.assertEqual(
+                text_output.read_text(encoding="utf-8"),
+                "[00:00:00.000 - 00:00:12.340] Hello\n"
+                "[00:00:12.340 - 00:00:13.000] world\n",
+            )
+            self.assertEqual(summary["original_entry_count"], 2)
+            self.assertEqual(summary["retained_segment_count"], 2)
+            self.assertEqual(summary["total_character_count"], len("Hello world"))
+            self.assertEqual(summary["detected_total_duration"], 13.0)
+
+    def test_empty_segments_are_skipped_and_ids_are_renumbered(self) -> None:
+        converted = convert_entries(
+            [
+                whispercpp_entry("first", 0, 1000),
+                whispercpp_entry("   ", 1000, 2000),
+                whispercpp_entry("", 2000, 3000),
+                whispercpp_entry("second", 3000, 4000),
+            ]
+        )
+
+        self.assertEqual(converted["text"], "first second")
+        self.assertEqual(
+            converted["segments"],
+            [
+                {"id": 0, "start": 0.0, "end": 1.0, "text": "first"},
+                {"id": 1, "start": 3.0, "end": 4.0, "text": "second"},
+            ],
+        )
+
+    def test_missing_transcription_list_is_rejected(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            input_path = Path(directory) / "missing.json"
+            input_path.write_text(json.dumps({"segments": []}), encoding="utf-8")
+
+            with self.assertRaisesRegex(
+                WhisperCppConversionError,
+                "Input JSON must contain a 'transcription' list.",
+            ):
+                convert_whispercpp_json(input_path)
+
+    def test_malformed_offsets_are_rejected(self) -> None:
+        with self.assertRaisesRegex(
+            WhisperCppConversionError,
+            r"transcription\[0\]\.offsets\.from must be a number.",
+        ):
+            convert_entries([whispercpp_entry("bad", "0", 1000)])
+
+        with self.assertRaisesRegex(
+            WhisperCppConversionError,
+            r"offsets\.to must be greater than or equal to offsets\.from",
+        ):
+            convert_entries([whispercpp_entry("bad", 2000, 1000)])
+
+    def test_utf8_text_is_preserved(self) -> None:
+        converted = convert_entries(
+            [
+                whispercpp_entry("  Grüße für Marleen – HÜSKER  ", 0, 1000),
+            ]
+        )
+
+        self.assertEqual(converted["text"], "Grüße für Marleen – HÜSKER")
+        self.assertEqual(
+            converted["segments"][0]["text"],
+            "Grüße für Marleen – HÜSKER",
+        )
+
+    def test_ordering_is_preserved(self) -> None:
+        converted = convert_entries(
+            [
+                whispercpp_entry("third spoken first", 3000, 4000),
+                whispercpp_entry("first spoken second", 0, 1000),
+                whispercpp_entry("second spoken third", 1000, 2000),
+            ]
+        )
+
+        self.assertEqual(
+            [segment["text"] for segment in converted["segments"]],
+            ["third spoken first", "first spoken second", "second spoken third"],
+        )
+
+    def test_format_timestamp_uses_hours_minutes_seconds_milliseconds(self) -> None:
+        self.assertEqual(format_timestamp(123.45), "00:02:03.450")
+        self.assertEqual(format_timestamp(3723.004), "01:02:03.004")
+
+
+if __name__ == "__main__":
+    unittest.main()