pycaption 2.2.23__tar.gz → 2.2.25__tar.gz

{pycaption-2.2.23/pycaption.egg-info → pycaption-2.2.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycaption
-Version: 2.2.23
+Version: 2.2.25
 Summary: Closed caption converter
 Author: Joe Norton
 Author-email: joey@nortoncrew.com

{pycaption-2.2.23 → pycaption-2.2.25}/pycaption/scc/__init__.py

@@ -332,7 +332,14 @@ class SCCReader(BaseReader):
         for idx, word in enumerate(word_list):
             word = word.strip()
             if len(word) == 4:
-                next_command = word_list[idx + 1] if idx + 1 < len(word_list) else None
+                # Look ahead for the next command, skipping the duplicate
+                # that SCC uses for error-correction (same word repeated).
+                next_idx = idx + 1
+                if next_idx < len(word_list) and word_list[next_idx].strip() == word:
+                    next_idx += 1
+                next_command = (
+                    word_list[next_idx] if next_idx < len(word_list) else None
+                )
                 self._translate_word(word=word, next_command=next_command)
 
     def _translate_word(self, word, next_command=None):
@@ -488,10 +495,11 @@ class SCCReader(BaseReader):
             edm_time = self.time_translator.get_time()
             if self.pop_ons_queue:
                 self._pop_on(end=edm_time)
-            if self.buffer_dict.active_key in ("paint", "roll") \
-                    and not self.buffer.is_empty():
-                self.caption_stash.create_and_store(
-                    self.buffer, self.time, edm_time)
+            if (
+                self.buffer_dict.active_key in ("paint", "roll")
+                and not self.buffer.is_empty()
+            ):
+                self.caption_stash.create_and_store(self.buffer, self.time, edm_time)
                 self.buffer = self.node_creator_factory.new_creator()
                 self.node_creator_factory.position_tracker.reset_for_new_caption()
                 self.time = edm_time
@@ -555,9 +563,17 @@ class SCCReader(BaseReader):
         self.caption_stash.create_and_store(pop_on_cue.buffer, pop_on_cue.start, end)
 
 
+SCC_TOKENS_PER_CAPTION_MAX = 80
+
+_SCC_PREFIX = ["94ae", "94ae", "9420", "9420"]
+_SCC_SUFFIX = ["942c", "942c", "942f", "942f"]
+_SCC_OVERHEAD = len(_SCC_PREFIX) + len(_SCC_SUFFIX)
+
+
 class SCCWriter(BaseWriter):
-    def __init__(self, *args, **kw):
+    def __init__(self, *args, drop_frame=False, **kw):
         super().__init__(*args, **kw)
+        self.drop_frame = drop_frame
 
     def write(self, caption_set):
         output = HEADER + "\n\n"
@@ -581,24 +597,64 @@ class SCCWriter(BaseWriter):
         # Advance start times so as to have time to write to the pop-on
         # buffer; possibly remove the previous clear-screen command
         for index, (code, start, end) in enumerate(codes):
-            code_words = len(code) / 5 + 8
+            code_words = len(code.split()) + _SCC_OVERHEAD
             code_time_microseconds = code_words * MICROSECONDS_PER_CODEWORD
             code_start = start - code_time_microseconds
-            if index > 0:
-                previous_code, previous_start, previous_end = codes[index - 1]
-                if code_start < previous_start:
-                    code_start = previous_start
-                if previous_end + 3 * MICROSECONDS_PER_CODEWORD >= code_start:
+            if code_start < 0:
+                code_start = 0
+            if index == 0:
+                codes[index] = (code, code_start, end)
+                continue
+            previous_code, previous_start, previous_end = codes[index - 1]
+            if code_start <= previous_start + MICROSECONDS_PER_CODEWORD:
+                prev_words = len(previous_code.split()) + _SCC_OVERHEAD
+                code_start = max(
+                    code_start,
+                    previous_start + prev_words * MICROSECONDS_PER_CODEWORD,
+                )
+                codes[index] = (code, code_start, end)
+                codes[index - 1] = (previous_code, previous_start, None)
+            else:
+                if (
+                    previous_end is not None
+                    and previous_end + 3 * MICROSECONDS_PER_CODEWORD >= code_start
+                ):
                     codes[index - 1] = (previous_code, previous_start, None)
-            codes[index] = (code, code_start, end)
+                codes[index] = (code, code_start, end)
 
         # PASS 3:
-        # Write captions.
+        # Deduplicate timestamps — ensure monotonically increasing frame values
+        last_emitted_frame = -1
+        for index, (code, start, end) in enumerate(codes):
+            cur_frame = self._microseconds_to_frame(start)
+            if cur_frame <= last_emitted_frame:
+                while self._microseconds_to_frame(start) <= last_emitted_frame:
+                    start += MICROSECONDS_PER_CODEWORD
+                codes[index] = (code, start, end)
+            last_emitted_frame = self._microseconds_to_frame(start)
+
+        # PASS 4:
+        # Write captions, splitting if > SCC_TOKENS_PER_CAPTION_MAX tokens.
+        max_payload = SCC_TOKENS_PER_CAPTION_MAX - _SCC_OVERHEAD
         for code, start, end in codes:
-            output += f"{self._format_timestamp(start)}\t"
-            output += "94ae 94ae 9420 9420 "
-            output += code
-            output += "942c 942c 942f 942f\n\n"
+            code_tokens = code.split()
+            if len(code_tokens) + _SCC_OVERHEAD <= SCC_TOKENS_PER_CAPTION_MAX:
+                output += f"{self._format_timestamp(start)}\t"
+                output += "94ae 94ae 9420 9420 "
+                output += code
+                output += "942c 942c 942f 942f\n\n"
+            else:
+                offset = 0
+                while offset < len(code_tokens):
+                    chunk = code_tokens[offset : offset + max_payload]
+                    line = _SCC_PREFIX + chunk + _SCC_SUFFIX
+                    output += (
+                        f"{self._format_timestamp(start)}\t" + " ".join(line) + "\n\n"
+                    )
+                    offset += max_payload
+                    if offset < len(code_tokens):
+                        start += MICROSECONDS_PER_CODEWORD
+
             if end is not None:
                 output += f"{self._format_timestamp(end)}\t942c 942c\n\n"
 
@@ -660,10 +716,20 @@ class SCCWriter(BaseWriter):
             code = self._maybe_align(code)
         return code
 
+    def _format_timestamp(self, microseconds):
+        if self.drop_frame:
+            return self._format_timestamp_df(microseconds)
+        return self._format_timestamp_ndf(microseconds)
+
+    def _microseconds_to_frame(self, microseconds):
+        if self.drop_frame:
+            return math.floor(microseconds * 30 / 1_000_000 * 1000 / 1001 + 1e-9)
+        seconds_float = microseconds / 1_000_000.0 * 1000.0 / 1001.0
+        return math.floor(seconds_float * 30)
+
     @staticmethod
-    def _format_timestamp(microseconds):
-        seconds_float = microseconds / 1000.0 / 1000.0
-        # Convert to non-drop-frame timecode
+    def _format_timestamp_ndf(microseconds):
+        seconds_float = microseconds / 1_000_000.0
         seconds_float *= 1000.0 / 1001.0
         hours = math.floor(seconds_float / 3600)
         seconds_float -= hours * 3600
@@ -674,6 +740,26 @@ class SCCWriter(BaseWriter):
         frames = math.floor(seconds_float * 30)
         return f"{hours:02}:{minutes:02}:{seconds:02}:{frames:02}"
 
+    @staticmethod
+    def _format_timestamp_df(microseconds):
+        total_frames = math.floor(microseconds * 30 / 1_000_000 * 1000 / 1001 + 1e-9)
+        fps = 30
+        frames_per_10min = 17982  # 10*60*30 - 2*9
+        d = total_frames // frames_per_10min
+        m = total_frames % frames_per_10min
+        if m < 2:
+            tc_frames = total_frames + 18 * d
+        else:
+            tc_frames = total_frames + 18 * d + 2 * ((m - 2) // 1798)
+
+        hours = tc_frames // (fps * 60 * 60)
+        rem = tc_frames % (fps * 60 * 60)
+        minutes = rem // (fps * 60)
+        rem = rem % (fps * 60)
+        seconds = rem // fps
+        frames = rem % fps
+        return f"{hours:02}:{minutes:02}:{seconds:02};{frames:02}"
+
 
 class _SccTimeTranslator:
     """Converts SCC time to microseconds, keeping track of frames passed"""

{pycaption-2.2.23 → pycaption-2.2.25/pycaption.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycaption
-Version: 2.2.23
+Version: 2.2.25
 Summary: Closed caption converter
 Author: Joe Norton
 Author-email: joey@nortoncrew.com

{pycaption-2.2.23 → pycaption-2.2.25}/pycaption.egg-info/SOURCES.txt

@@ -41,6 +41,7 @@ tests/test_sami_conversion.py
 tests/test_scc.py
 tests/test_scc_conversion.py
 tests/test_scc_translator.py
+tests/test_scc_writer.py
 tests/test_srt.py
 tests/test_srt_conversion.py
 tests/test_webvtt.py

{pycaption-2.2.23 → pycaption-2.2.25}/setup.py

@@ -20,7 +20,7 @@ transcript_dependencies = ["nltk==3.9.4"]
 
 setup(
     name="pycaption",
-    version="2.2.23",
+    version="2.2.25",
     description="Closed caption converter",
     long_description=open(README_PATH).read(),
     author="Joe Norton",

{pycaption-2.2.23 → pycaption-2.2.25}/tests/conftest.py

@@ -91,6 +91,7 @@ from tests.fixtures.scc import (  # noqa: F401
     sample_no_positioning_at_all_scc,
     sample_scc_created_dfxp_with_wrongly_closing_spans,
     sample_scc_duplicate_special_characters,
+    sample_scc_doubled_mid_row_before_punctuation,
     sample_scc_duplicate_tab_offset,
     sample_scc_empty,
     sample_scc_eoc_first_command,

{pycaption-2.2.23 → pycaption-2.2.25}/tests/fixtures/scc.py

@@ -659,3 +659,13 @@ Scenarist_SCC V1.0
 00:00:04;00	942c
 
 """
+
+
+@pytest.fixture(scope="session")
+def sample_scc_doubled_mid_row_before_punctuation():
+    return """\
+Scenarist_SCC V1.0
+
+00:26:48;29\t9420 9420 94d0 94d0 97a1 97a1 3e3e 2057 e5a7 ecec 2062 e520 6261 e36b 206e e5f8 f420 f7e5 e56b 20f7 e9f4 6880 9470 9470 616e eff4 68e5 f220 e570 e973 ef64 e520 efe6 91ae 91ae 4361 6e61 6461 2046 e9ec e573 9120 9120 ae80 942c 942c 8080 8080 942f 942f
+
+"""

{pycaption-2.2.23 → pycaption-2.2.25}/tests/test_scc.py

@@ -392,6 +392,24 @@ class TestSCCReader(ReaderTestingMixIn):
             ]
             assert expected_lines == actual_lines
 
+    def test_doubled_mid_row_before_punctuation_no_extra_space(
+        self,
+        sample_scc_doubled_mid_row_before_punctuation,
+    ):
+        caption_set = SCCReader().read(
+            sample_scc_doubled_mid_row_before_punctuation
+        )
+        captions = caption_set.get_captions("en-US")
+        text_nodes = [
+            node.content
+            for cap_ in captions
+            for node in cap_.nodes
+            if node.type_ == CaptionNode.TEXT
+        ]
+        full_text = "".join(text_nodes)
+        assert " ." not in full_text
+        assert full_text.endswith("Files.")
+
     def test_removing_spaces_at_end_of_lines(
         self,
         sample_scc_with_spaces_at_eol_pop,

pycaption-2.2.25/tests/test_scc_writer.py

@@ -0,0 +1,255 @@
+import re
+
+
+from pycaption import SCCReader, SCCWriter, SRTReader, WebVTTReader
+
+
+class TestSCCWriterTimestampFormatting:
+    def test_ndf_timestamp_uses_colons(self):
+        assert SCCWriter._format_timestamp_ndf(0) == "00:00:00:00"
+        assert ";" not in SCCWriter._format_timestamp_ndf(1_000_000)
+
+    def test_ndf_known_values(self):
+        assert SCCWriter._format_timestamp_ndf(0) == "00:00:00:00"
+        # 1 second of real time at 29.97fps NDF
+        # 1_000_000 us * 1000/1001 = 999.000999 coded seconds → 29 frames
+        assert SCCWriter._format_timestamp_ndf(1_000_000) == "00:00:00:29"
+        # 60 seconds real → 59.94 coded seconds → 59s + 28 frames
+        assert SCCWriter._format_timestamp_ndf(60_000_000) == "00:00:59:28"
+
+    def test_df_timestamp_uses_semicolons(self):
+        result = SCCWriter._format_timestamp_df(1_000_000)
+        assert ";" in result
+
+    def test_df_known_values(self):
+        assert SCCWriter._format_timestamp_df(0) == "00:00:00;00"
+        # 10 minutes of real time should map to exactly 10:00;00 in DF
+        ten_minutes_us = 10 * 60 * 1_000_000
+        assert SCCWriter._format_timestamp_df(ten_minutes_us) == "00:10:00;00"
+
+    def test_df_frame_skip_at_minute_boundary(self):
+        # Real frame 1800 is the first frame of minute 1 in DF.
+        # Minute 0 has 1800 frames (0..1799), no drops.
+        # Minute 1 starts at real frame 1800, displayed as 00:01:00;02
+        # (frames ;00 and ;01 are dropped at non-10th minutes).
+        us_for_frame_1800 = round(1800 * 1001 / 1000 / 30 * 1_000_000)
+        result = SCCWriter._format_timestamp_df(us_for_frame_1800)
+        assert result == "00:01:00;02"
+
+    def test_df_no_frame_skip_at_10_minute_boundary(self):
+        # At 10-minute boundaries, no frames are dropped
+        twenty_minutes_us = 20 * 60 * 1_000_000
+        result = SCCWriter._format_timestamp_df(twenty_minutes_us)
+        assert result == "00:20:00;00"
+
+
+class TestSCCWriterDropFrameFlag:
+    def _make_simple_captions(self):
+        srt = (
+            "1\n"
+            "00:00:01,000 --> 00:00:03,000\n"
+            "Hello world\n\n"
+            "2\n"
+            "00:00:05,000 --> 00:00:07,000\n"
+            "Second line\n"
+        )
+        return SRTReader().read(srt)
+
+    def test_drop_frame_false_is_default(self):
+        writer = SCCWriter()
+        assert writer.drop_frame is False
+
+    def test_drop_frame_false_uses_colons(self):
+        captions = self._make_simple_captions()
+        output = SCCWriter(drop_frame=False).write(captions)
+        timestamps = re.findall(r"\d{2}:\d{2}:\d{2}[:;]\d{2}", output)
+        for ts in timestamps:
+            assert ";" not in ts
+
+    def test_drop_frame_true_uses_semicolons(self):
+        captions = self._make_simple_captions()
+        output = SCCWriter(drop_frame=True).write(captions)
+        timestamps = re.findall(r"\d{2}:\d{2}:\d{2}[:;]\d{2}", output)
+        assert len(timestamps) > 0
+        for ts in timestamps:
+            assert ";" in ts
+
+    def test_drop_frame_false_preserves_existing_behavior(self):
+        captions = self._make_simple_captions()
+        output_default = SCCWriter().write(captions)
+        output_explicit = SCCWriter(drop_frame=False).write(captions)
+        assert output_default == output_explicit
+
+
+class TestSCCWriterTimestampOrdering:
+    def test_timestamps_monotonically_increasing_ndf(self):
+        vtt_input = (
+            "WEBVTT\n\n"
+            "0\n00:00:01.529 --> 00:00:03.640\n"
+            "When it comes to finding the one,\n\n"
+            "1\n00:00:03.730 --> 00:00:07.239\n"
+            "I always say that if they can love you at your messiest,\n\n"
+            "2\n00:00:07.570 --> 00:00:09.319\n"
+            "calm you at your moodiest,\n\n"
+            "3\n00:00:09.529 --> 00:00:11.680\n"
+            "and laugh with you at your quirkiest,\n\n"
+            "4\n00:00:11.930 --> 00:00:13.760\n"
+            "you've probably found your person.\n"
+        )
+        captions = WebVTTReader().read(vtt_input)
+        output = SCCWriter(drop_frame=False).write(captions)
+        timestamps = re.findall(r"(\d{2}:\d{2}:\d{2}:\d{2})", output)
+        for i in range(1, len(timestamps)):
+            assert (
+                timestamps[i] >= timestamps[i - 1]
+            ), f"NDF timestamps out of order: {timestamps[i - 1]} > {timestamps[i]}"
+
+    def test_timestamps_monotonically_increasing_df(self):
+        vtt_input = (
+            "WEBVTT\n\n"
+            "0\n00:00:01.529 --> 00:00:03.640\n"
+            "When it comes to finding the one,\n\n"
+            "1\n00:00:03.730 --> 00:00:07.239\n"
+            "I always say that if they can love you at your messiest,\n\n"
+            "2\n00:00:07.570 --> 00:00:09.319\n"
+            "calm you at your moodiest,\n\n"
+            "3\n00:00:09.529 --> 00:00:11.680\n"
+            "and laugh with you at your quirkiest,\n\n"
+            "4\n00:00:11.930 --> 00:00:13.760\n"
+            "you've probably found your person.\n"
+        )
+        captions = WebVTTReader().read(vtt_input)
+        output = SCCWriter(drop_frame=True).write(captions)
+        timestamps = re.findall(r"(\d{2}:\d{2}:\d{2};\d{2})", output)
+        for i in range(1, len(timestamps)):
+            assert (
+                timestamps[i] >= timestamps[i - 1]
+            ), f"DF timestamps out of order: {timestamps[i - 1]} > {timestamps[i]}"
+
+    def test_rapid_short_captions_stay_ordered(self):
+        """Short text followed by long text should not cause timestamp inversion."""
+        vtt_input = (
+            "WEBVTT\n\n"
+            "0\n00:00:02.200 --> 00:00:02.359\nyou know,\n\n"
+            "1\n00:00:02.400 --> 00:00:03.760\n"
+            "the way he kind of looked at me.\n\n"
+            "2\n00:00:04.700 --> 00:00:05.169\nAnd I said,\n\n"
+            "3\n00:00:05.210 --> 00:00:05.520\noh\n"
+        )
+        captions = WebVTTReader().read(vtt_input)
+        for df in (True, False):
+            output = SCCWriter(drop_frame=df).write(captions)
+            sep = ";" if df else ":"
+            pattern = r"\d{2}:\d{2}:\d{2}" + re.escape(sep) + r"\d{2}"
+            timestamps = re.findall(pattern, output)
+            for i in range(1, len(timestamps)):
+                assert (
+                    timestamps[i] >= timestamps[i - 1]
+                ), f"drop_frame={df}: {timestamps[i - 1]} > {timestamps[i]}"
+
+
+class TestSCCWriterFirstCueBackshift:
+    def test_first_cue_start_is_shifted_back(self):
+        srt = "1\n" "00:00:10,000 --> 00:00:12,000\n" "Hello world\n"
+        captions = SRTReader().read(srt)
+        output = SCCWriter(drop_frame=False).write(captions)
+        timestamps = re.findall(r"(\d{2}:\d{2}:\d{2}:\d{2})", output)
+        # The first timestamp should be earlier than 00:00:09:29
+        # (10s real time -> ~9:29 NDF, minus backshift)
+        assert timestamps[0] < "00:00:09:29"
+
+    def test_first_cue_at_zero_does_not_go_negative(self):
+        srt = "1\n" "00:00:00,100 --> 00:00:02,000\n" "Hello\n"
+        captions = SRTReader().read(srt)
+        output = SCCWriter(drop_frame=False).write(captions)
+        timestamps = re.findall(r"(\d{2}:\d{2}:\d{2}:\d{2})", output)
+        assert timestamps[0] == "00:00:00:00"
+
+
+class TestSCCWriterOverlappingCues:
+    def test_overlapping_cues_suppress_clear_screen(self):
+        """When cues are very close together, the clear-screen (942c) for
+        the previous cue should be suppressed."""
+        srt = (
+            "1\n00:00:01,000 --> 00:00:01,900\nFirst\n\n"
+            "2\n00:00:02,000 --> 00:00:03,000\nSecond\n"
+        )
+        captions = SRTReader().read(srt)
+        output = SCCWriter(drop_frame=False).write(captions)
+        # Count standalone 942c lines (clear-screen commands between captions)
+        clear_lines = [
+            line
+            for line in output.split("\n")
+            if line.strip().endswith("942c 942c") and "94ae" not in line
+        ]
+        # With tight cues, the first cue's clear should be suppressed
+        # (only the last cue gets a clear-screen at its end time)
+        assert len(clear_lines) <= 1
+
+
+class TestSCCWriterSplitLongCaption:
+    def test_split_caption_exceeding_80_tokens(self):
+        """A caption that would exceed 80 SCC tokens should be split."""
+        # Create a very long caption that will produce many code tokens
+        long_text = "A" * 32 + "\n" + "B" * 32 + "\n" + "C" * 32 + "\n" + "D" * 32
+        srt = "1\n" "00:00:05,000 --> 00:00:10,000\n" f"{long_text}\n"
+        captions = SRTReader().read(srt)
+        output = SCCWriter(drop_frame=False).write(captions)
+        # Each output line (non-empty, non-header) should have <= 80 tokens
+        for line in output.split("\n"):
+            line = line.strip()
+            if not line or line == "Scenarist_SCC V1.0":
+                continue
+            # Line format: "HH:MM:SS:FF\t<tokens>"
+            parts = line.split("\t")
+            if len(parts) == 2:
+                tokens = parts[1].split()
+                assert len(tokens) <= SCC_TOKENS_PER_CAPTION_MAX, (
+                    f"Line has {len(tokens)} tokens, "
+                    f"exceeds {SCC_TOKENS_PER_CAPTION_MAX}"
+                )
+
+
+class TestSCCWriterRoundTrip:
+    def test_srt_to_scc_roundtrip_ndf(self):
+        srt = (
+            "1\n00:00:01,000 --> 00:00:03,000\nHello world\n\n"
+            "2\n00:00:05,000 --> 00:00:07,000\nGoodbye world\n"
+        )
+        captions = SRTReader().read(srt)
+        scc_output = SCCWriter(drop_frame=False).write(captions)
+        # Should be readable by SCCReader
+        result = SCCReader().read(scc_output)
+        assert not result.is_empty()
+        assert len(result.get_captions("en-US")) == 2
+
+    def test_srt_to_scc_roundtrip_df(self):
+        srt = (
+            "1\n00:00:01,000 --> 00:00:03,000\nHello world\n\n"
+            "2\n00:00:05,000 --> 00:00:07,000\nGoodbye world\n"
+        )
+        captions = SRTReader().read(srt)
+        scc_output = SCCWriter(drop_frame=True).write(captions)
+        # SCCReader already supports semicolon (DF) timestamps
+        result = SCCReader().read(scc_output)
+        assert not result.is_empty()
+        assert len(result.get_captions("en-US")) == 2
+
+    def test_webvtt_to_scc_roundtrip_df(self):
+        vtt_input = (
+            "WEBVTT\n\n"
+            "0\n00:00:01.529 --> 00:00:03.640\n"
+            "When it comes to finding the one,\n\n"
+            "1\n00:00:03.730 --> 00:00:07.239\n"
+            "I always say that if they can love you\n\n"
+            "2\n00:00:07.570 --> 00:00:09.319\n"
+            "calm you at your moodiest,\n"
+        )
+        captions = WebVTTReader().read(vtt_input)
+        scc_output = SCCWriter(drop_frame=True).write(captions)
+        result = SCCReader().read(scc_output)
+        assert not result.is_empty()
+        assert len(result.get_captions("en-US")) == 3
+
+
+from pycaption.scc import SCC_TOKENS_PER_CAPTION_MAX  # noqa: E402