pycaption 2.3.13__tar.gz → 2.3.14__tar.gz

{pycaption-2.3.13/pycaption.egg-info → pycaption-2.3.14}/PKG-INFO

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

{pycaption-2.3.13 → pycaption-2.3.14}/pycaption/sami/writer.py

@@ -37,7 +37,6 @@ class SAMIWriter(BaseWriter):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self._span_stack = []
-        self.last_time = None
         self._promote_center = False
 
     def write(self, caption_set, **kwargs):
@@ -51,13 +50,8 @@ class SAMIWriter(BaseWriter):
             caption_set.layout_info
         )
 
-        primary = None
-
+        timelines = {}
         for lang in caption_set.get_languages():
-            self.last_time = None
-            if primary is None:
-                primary = lang
-
             caption_set.set_layout_info(
                 lang,
                 self._relativize_and_fit_to_screen(caption_set.get_layout_info(lang)),
@@ -72,12 +66,11 @@ class SAMIWriter(BaseWriter):
                     node.layout_info = self._relativize_and_fit_to_screen(
                         node.layout_info
                     )
-                sami = self._recreate_p_tag(caption, sami, lang, primary, caption_set)
+            cues = self._build_timeline(captions)
+            if cues:
+                timelines[lang] = cues
 
-            if self.last_time and captions:
-                sami = self._recreate_blank_tag(
-                    sami, captions[-1], lang, primary, caption_set
-                )
+        self._recreate_syncs(sami, timelines, caption_set)
 
         stylesheet = self._recreate_stylesheet(caption_set)
         sami.find("style").append(stylesheet)
@@ -86,17 +79,64 @@ class SAMIWriter(BaseWriter):
         caption_content = "\n".join(a[1:])
         return caption_content
 
-    def _recreate_p_tag(self, caption, sami, lang, primary, captions):
-        """Build a <sync><p> block for a single caption with styling and alignment."""
-        time = int(caption.start // 1000)
-
-        if self.last_time and time != self.last_time:
-            sami = self._recreate_blank_tag(sami, caption, lang, primary, captions)
-
-        self.last_time = int(caption.end // 1000)
+    @staticmethod
+    def _build_timeline(captions):
+        """Return (start_ms, end_ms, caption) cues sorted by start.
 
-        sami, sync = self._recreate_sync(sami, lang, primary, time)
+        Zero-length cues are never on screen, so they are dropped.
+        """
+        cues = []
+        for caption in captions:
+            start = int(caption.start // 1000)
+            end = int(caption.end // 1000)
+            if end > start:
+                cues.append((start, end, caption))
+        cues.sort(key=lambda cue: cue[0])
+        return cues
+
+    def _recreate_syncs(self, sami, timelines, captions):
+        """Append one <sync> per time at which any language's visible cues change.
+
+        Overlapping cues of a language are merged: a <sync> repeats every cue
+        of that language still on screen, so start times never decrease and
+        no cue is cleared early.
+        """
+        times = sorted(
+            {time for cues in timelines.values() for cue in cues for time in cue[:2]}
+        )
+        shown = {lang: [] for lang in timelines}
+        pending = {lang: 0 for lang in timelines}
+
+        for time in times:
+            sync = None
+            for lang, cues in timelines.items():
+                active = [i for i in shown[lang] if cues[i][1] > time]
+                while pending[lang] < len(cues) and cues[pending[lang]][0] <= time:
+                    active.append(pending[lang])
+                    pending[lang] += 1
+                if active == shown[lang]:
+                    continue
+                shown[lang] = active
+
+                if sync is None:
+                    sync = sami.new_tag("sync", start=time)
+                    sami.body.append(sync)
+
+                if active:
+                    for i in active:
+                        sync.append(
+                            self._recreate_p_tag(cues[i][2], sami, lang, captions)
+                        )
+                else:
+                    # The blank takes the class of the next cue, or of the
+                    # last cue once the language has no cues left.
+                    upcoming = cues[min(pending[lang], len(cues) - 1)][2]
+                    sync.append(
+                        self._recreate_blank_tag(upcoming, sami, lang, captions)
+                    )
 
+    def _recreate_p_tag(self, caption, sami, lang, captions):
+        """Build a <p> for a single caption with styling and alignment."""
         p = sami.new_tag("p")
 
         p_style = self._build_p_style(caption)
@@ -107,9 +147,7 @@ class SAMIWriter(BaseWriter):
         p["class"] = self._recreate_p_lang(caption, lang, captions)
         p.string = encode_leading_nbsp(self._recreate_text(caption.nodes))
 
-        sync.append(p)
-
-        return sami
+        return p
 
     def _build_p_style(self, caption):
         """Build the inline CSS style string for a <p> element."""
@@ -158,45 +196,13 @@ class SAMIWriter(BaseWriter):
 
         return HORIZONTAL_ALIGNMENT_MAP.get(h)
 
-    def _recreate_sync(self, sami, lang, primary, time):
-        """Find or create a <sync> tag at the given millisecond timestamp."""
-        if lang == primary:
-            sync = sami.new_tag("sync", start=time)
-            sami.body.append(sync)
-        else:
-            sync = sami.find("sync", start=time)
-            if sync is None:
-                sami, sync = self._find_closest_sync(sami, time)
-
-        return sami, sync
-
-    @staticmethod
-    def _find_closest_sync(sami, time):
-        """Insert a new <sync> tag in chronological order among existing syncs."""
-        sync = sami.new_tag("sync", start=time)
-
-        earlier = sami.find_all("sync", start=lambda x: int(x) < time)
-        if earlier:
-            last_sync = earlier[-1]
-            last_sync.insert_after(sync)
-        else:
-            later = sami.find_all("sync", start=lambda x: int(x) > time)
-            if later:
-                last_sync = later[0]
-                last_sync.insert_before(sync)
-        return sami, sync
-
-    def _recreate_blank_tag(self, sami, caption, lang, primary, captions):
-        """Insert an &nbsp; paragraph to clear the previous caption at its end time."""
-        sami, sync = self._recreate_sync(sami, lang, primary, self.last_time)
-
+    def _recreate_blank_tag(self, caption, sami, lang, captions):
+        """Build an &nbsp; <p> that clears the language's previous caption."""
         p = sami.new_tag("p")
         p["class"] = self._recreate_p_lang(caption, lang, captions)
         p.string = "&nbsp;"
 
-        sync.append(p)
-
-        return sami
+        return p
 
     @staticmethod
     def _recreate_p_lang(caption, lang, captions):

{pycaption-2.3.13 → pycaption-2.3.14}/pycaption/webvtt/reader.py

@@ -76,6 +76,7 @@ class _ParseState:
         "open_tags",
         "layout_info",
         "found_timing",
+        "drop_cue",
         "in_note_block",
         "in_style_block",
         "in_region_block",
@@ -90,6 +91,7 @@ class _ParseState:
         self.open_tags = []
         self.layout_info = None
         self.found_timing = False
+        self.drop_cue = False
         self.in_note_block = False
         self.in_style_block = False
         self.in_region_block = False
@@ -114,7 +116,9 @@ class WebVTTReader(BaseReader):
         :param ignore_timing_errors: When False, raises on non-monotonic
             or inverted timestamps. Default True for lenient parsing.
         :param time_shift_milliseconds: Offset applied to all timestamps
-            (positive = shift forward, negative = shift backward).
+            (positive = shift forward, negative = shift backward). After a
+            negative shift, a cue crossing 0 is clamped to start at 0 and a
+            cue ending at or before 0 is dropped.
         """
         super().__init__(*args, **kwargs)
         self.ignore_timing_errors = ignore_timing_errors
@@ -219,15 +223,7 @@ class WebVTTReader(BaseReader):
 
         # Flush the last cue if file doesn't end with a blank line
         if state.nodes:
-            captions.append(
-                self._build_cue(
-                    state.nodes,
-                    state.open_tags,
-                    state.start,
-                    state.end,
-                    state.layout_info,
-                )
-            )
+            self._finalize_cue(state, captions)
 
         return captions
 
@@ -251,6 +247,7 @@ class WebVTTReader(BaseReader):
             state.start, state.end, state.layout_info = self._read_timing(
                 line, line_index, last_start_time
             )
+            state.drop_cue = state.start is None
             return
 
         if not state.found_timing and line != "":
@@ -261,12 +258,10 @@ class WebVTTReader(BaseReader):
             state.pending_id = None
             return
 
-        if line == "" and state.found_timing and state.nodes:
+        if line == "" and state.found_timing:
             self._finalize_cue(state, captions)
             return
 
-        if not state.found_timing or line == "":
-            return
         if state.nodes:
             state.nodes.append(CaptionNode.create_break())
         state.nodes.extend(self._parse_cue_text(line, state.open_tags))
@@ -320,18 +315,20 @@ class WebVTTReader(BaseReader):
         state.seen_ids.add(cue_id)
 
     def _finalize_cue(self, state, captions):
-        """Close the current cue, append it to captions, and reset state
-        for the next cue."""
+        """Close the current cue, append it to captions unless it is dropped
+        or empty, and reset state for the next cue."""
         state.found_timing = False
-        captions.append(
-            self._build_cue(
-                state.nodes,
-                state.open_tags,
-                state.start,
-                state.end,
-                state.layout_info,
+        if not state.drop_cue and state.nodes:
+            captions.append(
+                self._build_cue(
+                    state.nodes,
+                    state.open_tags,
+                    state.start,
+                    state.end,
+                    state.layout_info,
+                )
             )
-        )
+        state.drop_cue = False
         state.nodes = []
         state.open_tags = []
 
@@ -438,7 +435,9 @@ class WebVTTReader(BaseReader):
         :param line: Raw timing line, e.g.
             "00:00:01.000 --> 00:00:05.000 line:80%"
         :param last_start_time: Start time of previous cue (for validation).
-        :returns: Tuple of (start_us, end_us, Layout or None).
+        :returns: Tuple of (start_us, end_us, Layout or None). start_us and
+            end_us are None when a negative time shift puts the cue end at
+            or before 0, meaning the cue is dropped.
         :raises CaptionReadSyntaxError: On unparseable timing format.
         """
         m = TIMING_LINE_PATTERN.search(line)
@@ -449,6 +448,15 @@ class WebVTTReader(BaseReader):
         end = self._parse_timestamp(m.group(2)) + self.time_shift_microseconds
         cue_settings = m.group(3)
 
+        if self.time_shift_microseconds < 0:
+            if end <= 0:
+                # Shifted entirely before 0: drop. Still reject inverted
+                # timings; ordering is moot since the cue is not kept.
+                if not self.ignore_timing_errors:
+                    self._validate_timings(start, end, start)
+                return None, None, None
+            start = max(start, 0)
+
         if not self.ignore_timing_errors:
             self._validate_timings(start, end, last_start_time)
 

{pycaption-2.3.13 → pycaption-2.3.14/pycaption.egg-info}/PKG-INFO

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

{pycaption-2.3.13 → pycaption-2.3.14}/setup.py

@@ -21,7 +21,7 @@ transcript_dependencies = ["nltk==3.10.0"]
 
 setup(
     name="pycaption",
-    version="2.3.13",
+    version="2.3.14",
     description="Closed caption converter",
     long_description=open(README_PATH).read(),
     author="Joe Norton",

{pycaption-2.3.13 → pycaption-2.3.14}/tests/conftest.py

@@ -29,6 +29,7 @@ from tests.fixtures.dfxp import (  # noqa: F401
     sample_dfxp_multiple_regions_output,
     sample_dfxp_only_spaces_paragraph,
     sample_dfxp_output,
+    sample_dfxp_overlapping_cues,
     sample_dfxp_style_tag_with_no_xml_id_input,
     sample_dfxp_style_tag_with_no_xml_id_output,
     sample_dfxp_syntax_error,
@@ -219,7 +220,16 @@ from tests.fixtures.webvtt import (  # noqa: F401
     sample_webvtt_double_br,
     sample_webvtt_empty,
     sample_webvtt_empty_cue,
+    sample_webvtt_empty_cue_multiple_blanks,
+    sample_webvtt_empty_cue_only_orphan_text,
     sample_webvtt_empty_cue_output,
+    sample_webvtt_empty_cue_then_duplicate_id,
+    sample_webvtt_empty_cue_then_id,
+    sample_webvtt_empty_cue_then_note,
+    sample_webvtt_empty_cue_then_orphan_text,
+    sample_webvtt_empty_cue_then_region,
+    sample_webvtt_empty_cue_then_style,
+    sample_webvtt_empty_last_cue,
     sample_webvtt_from_dfxp,
     sample_webvtt_from_dfxp_with_positioning_and_style,
     sample_webvtt_from_dfxp_with_style,
@@ -233,11 +243,13 @@ from tests.fixtures.webvtt import (  # noqa: F401
     sample_webvtt_last_cue_zero_start,
     sample_webvtt_multi_lang_de,
     sample_webvtt_multi_lang_en,
+    sample_webvtt_negative_shift,
     sample_webvtt_no_blank_after_header,
     sample_webvtt_no_header,
     sample_webvtt_note_with_arrow,
     sample_webvtt_numeric_entities,
     sample_webvtt_output_long_cue,
+    sample_webvtt_overlapping_cues,
     sample_webvtt_style_with_arrow,
     sample_webvtt_timestamps,
     sample_webvtt_with_bom,

{pycaption-2.3.13 → pycaption-2.3.14}/tests/fixtures/dfxp.py

@@ -1638,3 +1638,17 @@ def sample_dfxp_with_nbsp_indentation():
   </div>
  </body>
 </tt>"""
+
+
+@pytest.fixture(scope="session")
+def sample_dfxp_overlapping_cues():
+    return """\
+<?xml version="1.0" encoding="utf-8"?>
+<tt xml:lang="en" xmlns="http://www.w3.org/ns/ttml">
+ <body>
+  <div xml:lang="en-US">
+   <p begin="00:00:00.500" end="00:00:03.000">A</p>
+   <p begin="00:00:01.000" end="00:00:01.800">B</p>
+  </div>
+ </body>
+</tt>"""

{pycaption-2.3.13 → pycaption-2.3.14}/tests/fixtures/webvtt.py

@@ -343,6 +343,124 @@ Transcribed by Celestials
 """
 
 
+@pytest.fixture(scope="session")
+def sample_webvtt_empty_cue_then_id():
+    return """WEBVTT
+
+cue-1
+00:00.000 --> 00:02.000
+
+cue-2
+00:04.000 --> 00:05.000
+C
+"""
+
+
+@pytest.fixture(scope="session")
+def sample_webvtt_empty_cue_then_note():
+    return """WEBVTT
+
+00:00.000 --> 00:02.000
+
+NOTE hello
+
+00:04.000 --> 00:05.000
+C
+"""
+
+
+@pytest.fixture(scope="session")
+def sample_webvtt_empty_cue_then_style():
+    return """WEBVTT
+
+00:00.000 --> 00:02.000
+
+STYLE
+::cue { color: red }
+
+00:04.000 --> 00:05.000
+C
+"""
+
+
+@pytest.fixture(scope="session")
+def sample_webvtt_empty_cue_then_region():
+    return """WEBVTT
+
+00:00.000 --> 00:02.000
+
+REGION
+id:r1
+
+00:04.000 --> 00:05.000
+C
+"""
+
+
+@pytest.fixture(scope="session")
+def sample_webvtt_empty_cue_multiple_blanks():
+    return """WEBVTT
+
+00:00.000 --> 00:02.000
+
+
+
+cue-2
+00:04.000 --> 00:05.000
+C
+"""
+
+
+@pytest.fixture(scope="session")
+def sample_webvtt_empty_last_cue():
+    return """WEBVTT
+
+cue-1
+00:00.000 --> 00:02.000
+A
+
+cue-2
+00:03.000 --> 00:04.000
+"""
+
+
+@pytest.fixture(scope="session")
+def sample_webvtt_empty_cue_then_duplicate_id():
+    return """WEBVTT
+
+cue-1
+00:00.000 --> 00:02.000
+
+cue-1
+00:04.000 --> 00:05.000
+C
+"""
+
+
+@pytest.fixture(scope="session")
+def sample_webvtt_empty_cue_then_orphan_text():
+    return """WEBVTT
+
+00:00.000 --> 00:02.000
+
+hello
+world
+
+00:04.000 --> 00:05.000
+C
+"""
+
+
+@pytest.fixture(scope="session")
+def sample_webvtt_empty_cue_only_orphan_text():
+    return """WEBVTT
+
+00:00.000 --> 00:02.000
+
+hello
+"""
+
+
 @pytest.fixture(scope="session")
 def sample_webvtt_multi_lang_en():
     return """WEBVTT
@@ -594,3 +712,29 @@ def sample_webvtt_style_with_arrow():
 @pytest.fixture(scope="session")
 def sample_webvtt_numeric_entities():
     return "WEBVTT\n\n" "00:00:01.000 --> 00:00:03.000\n" "© and ♫\n"
+
+
+@pytest.fixture(scope="session")
+def sample_webvtt_negative_shift():
+    return (
+        "WEBVTT\n\n"
+        "00:00:00.500 --> 00:00:01.500\n"
+        "Straddles zero\n\n"
+        "00:00:01.000 --> 00:00:01.800\n"
+        "Fully before zero\n\n"
+        "00:00:03.000 --> 00:00:05.000\n"
+        "After zero\n"
+    )
+
+
+@pytest.fixture(scope="session")
+def sample_webvtt_overlapping_cues():
+    return (
+        "WEBVTT\n\n"
+        "00:00:00.500 --> 00:00:01.500\n"
+        "A\n\n"
+        "00:00:01.000 --> 00:00:01.800\n"
+        "B\n\n"
+        "00:00:03.000 --> 00:00:05.000\n"
+        "C\n"
+    )

{pycaption-2.3.13 → pycaption-2.3.14}/tests/mixins.py

@@ -4,6 +4,7 @@ import pytest
 
 from bs4 import BeautifulSoup
 
+from pycaption import SAMIReader
 from pycaption.exceptions import InvalidInputError
 
 
@@ -176,6 +177,24 @@ class SAMITestingMixIn:
 
         assert self._strip_blanks(first_items) == self._strip_blanks(second_items)
 
+    def assert_sami_syncs_equal(self, sami, expected):
+        """Assert the SYNCs as (start, [(class, text), ...]); "" is a blank.
+
+        Start values must strictly increase, and the output must read back.
+        """
+        syncs = [
+            (
+                int(sync["start"]),
+                [(" ".join(p["class"]), p.text.strip()) for p in sync.find_all("p")],
+            )
+            for sync in BeautifulSoup(sami, "lxml").select("sync")
+        ]
+        starts = [start for start, _ in syncs]
+
+        assert starts == sorted(set(starts))
+        assert syncs == expected
+        SAMIReader().read(sami)
+
 
 class MicroDVDTestingMixIn:
     """

{pycaption-2.3.13 → pycaption-2.3.14}/tests/test_sami.py

@@ -11,7 +11,7 @@ from pycaption import (
 from pycaption.base import Caption, CaptionList, CaptionNode, CaptionSet
 from pycaption.exceptions import CaptionReadTimingError
 from pycaption.geometry import HorizontalAlignmentEnum, Size, UnitEnum  # noqa
-from tests.mixins import ReaderTestingMixIn
+from tests.mixins import ReaderTestingMixIn, SAMITestingMixIn
 
 
 class TestSAMIReader(ReaderTestingMixIn):
@@ -269,3 +269,124 @@ class TestSAMIWriterNbspIndentation:
             '"The Story Knife."',
             "\xa0\xa0Part one",
         ]
+
+
+def _captions(*cues):
+    """Build a CaptionList from (start_ms, end_ms, text) tuples."""
+    return CaptionList(
+        [
+            Caption(start * 1000, end * 1000, [CaptionNode.create_text(text)])
+            for start, end, text in cues
+        ]
+    )
+
+
+PARTIAL_OVERLAP = [(500, 1500, "A"), (1000, 1800, "B"), (3000, 5000, "C")]
+TOUCHING = [(500, 1000, "A"), (1000, 1800, "B")]
+
+
+class TestSAMIWriterOverlappingCues(SAMITestingMixIn):
+    """Overlapping cues are merged so SYNC start values never decrease."""
+
+    def _write(self, **languages):
+        return SAMIWriter().write(
+            CaptionSet(
+                {
+                    lang.replace("_", "-"): _captions(*cues)
+                    for lang, cues in languages.items()
+                }
+            )
+        )
+
+    def test_partial_overlap(self):
+        sami = self._write(en_US=PARTIAL_OVERLAP)
+
+        self.assert_sami_syncs_equal(
+            sami,
+            [
+                (500, [("en-US", "A")]),
+                (1000, [("en-US", "A"), ("en-US", "B")]),
+                (1500, [("en-US", "B")]),
+                (1800, [("en-US", "")]),
+                (3000, [("en-US", "C")]),
+                (5000, [("en-US", "")]),
+            ],
+        )
+
+    def test_nested_overlap(self):
+        sami = self._write(en_US=[(500, 3000, "A"), (1000, 1800, "B")])
+
+        self.assert_sami_syncs_equal(
+            sami,
+            [
+                (500, [("en-US", "A")]),
+                (1000, [("en-US", "A"), ("en-US", "B")]),
+                (1800, [("en-US", "A")]),
+                (3000, [("en-US", "")]),
+            ],
+        )
+
+    def test_same_start(self):
+        sami = self._write(en_US=[(0, 500, "A"), (0, 800, "B")])
+
+        self.assert_sami_syncs_equal(
+            sami,
+            [
+                (0, [("en-US", "A"), ("en-US", "B")]),
+                (500, [("en-US", "B")]),
+                (800, [("en-US", "")]),
+            ],
+        )
+
+    def test_touching_cues_are_unchanged(self):
+        sami = self._write(en_US=TOUCHING)
+
+        self.assert_sami_syncs_equal(
+            sami,
+            [
+                (500, [("en-US", "A")]),
+                (1000, [("en-US", "B")]),
+                (1800, [("en-US", "")]),
+            ],
+        )
+
+    def test_overlap_only_in_second_language(self):
+        sami = self._write(en_US=TOUCHING, de_DE=PARTIAL_OVERLAP)
+
+        self.assert_sami_syncs_equal(
+            sami,
+            [
+                (500, [("en-US", "A"), ("de-DE", "A")]),
+                (1000, [("en-US", "B"), ("de-DE", "A"), ("de-DE", "B")]),
+                (1500, [("de-DE", "B")]),
+                (1800, [("en-US", ""), ("de-DE", "")]),
+                (3000, [("de-DE", "C")]),
+                (5000, [("de-DE", "")]),
+            ],
+        )
+
+    def test_cues_out_of_input_order(self):
+        sami = self._write(en_US=[(3000, 5000, "C"), (500, 1500, "A")])
+
+        self.assert_sami_syncs_equal(
+            sami,
+            [
+                (500, [("en-US", "A")]),
+                (1500, [("en-US", "")]),
+                (3000, [("en-US", "C")]),
+                (5000, [("en-US", "")]),
+            ],
+        )
+
+    def test_zero_length_cue_is_dropped(self):
+        sami = self._write(en_US=[(0, 1000, "A"), (2000, 2000, "Z"), (3000, 4000, "B")])
+
+        self.assert_sami_syncs_equal(
+            sami,
+            [
+                (0, [("en-US", "A")]),
+                (1000, [("en-US", "")]),
+                (3000, [("en-US", "B")]),
+                (4000, [("en-US", "")]),
+            ],
+        )

{pycaption-2.3.13 → pycaption-2.3.14}/tests/test_sami_conversion.py

@@ -118,6 +118,40 @@ class TestWebVTTtoSAMI(SAMITestingMixIn):
         self.assert_sami_captions_equal(sample_sami, result)
 
 
+class TestOverlappingCuesToSAMI(SAMITestingMixIn):
+    def test_overlapping_webvtt_gives_in_order_syncs(
+        self, sample_webvtt_overlapping_cues
+    ):
+        caption_set = WebVTTReader().read(sample_webvtt_overlapping_cues)
+        result = SAMIWriter().write(caption_set)
+
+        self.assert_sami_syncs_equal(
+            result,
+            [
+                (500, [("en-US", "A")]),
+                (1000, [("en-US", "A"), ("en-US", "B")]),
+                (1500, [("en-US", "B")]),
+                (1800, [("en-US", "")]),
+                (3000, [("en-US", "C")]),
+                (5000, [("en-US", "")]),
+            ],
+        )
+
+    def test_overlapping_dfxp_gives_in_order_syncs(self, sample_dfxp_overlapping_cues):
+        caption_set = DFXPReader().read(sample_dfxp_overlapping_cues)
+        result = SAMIWriter().write(caption_set)
+
+        self.assert_sami_syncs_equal(
+            result,
+            [
+                (500, [("en-US", "A")]),
+                (1000, [("en-US", "A"), ("en-US", "B")]),
+                (1800, [("en-US", "A")]),
+                (3000, [("en-US", "")]),
+            ],
+        )
+
+
 class TestWebVTTtoSAMIStyles(SAMITestingMixIn):
     """Tests for WebVTT structured style/layout → SAMI conversion."""
 

{pycaption-2.3.13 → pycaption-2.3.14}/tests/test_webvtt.py

@@ -79,6 +79,115 @@ class TestWebVTTReader(ReaderTestingMixIn):
         assert cue.start == 16985000
         assert cue.end == 18737000
 
+    def test_negative_shift_clamps_cue_crossing_zero(
+        self, sample_webvtt_negative_shift
+    ):
+        captions = WebVTTReader(time_shift_milliseconds=-1000).read(
+            sample_webvtt_negative_shift
+        )
+        cue = captions.get_captions("en-US")[0]
+
+        assert cue.get_text() == "Straddles zero"
+        assert cue.start == 0
+        assert cue.end == 500000
+
+    def test_negative_shift_keeps_cue_starting_exactly_at_zero(
+        self, sample_webvtt_negative_shift
+    ):
+        captions = WebVTTReader(time_shift_milliseconds=-1000).read(
+            sample_webvtt_negative_shift
+        )
+        cue = captions.get_captions("en-US")[1]
+
+        assert cue.get_text() == "Fully before zero"
+        assert cue.start == 0
+        assert cue.end == 800000
+
+    def test_negative_shift_drops_cues_ending_at_or_before_zero(
+        self, sample_webvtt_negative_shift
+    ):
+        # -1500: "Straddles zero" ends exactly at 0, "Fully before zero"
+        # crosses 0. -2000: both end before 0.
+        captions = WebVTTReader(time_shift_milliseconds=-1500).read(
+            sample_webvtt_negative_shift
+        )
+        assert [c.get_text() for c in captions.get_captions("en-US")] == [
+            "Fully before zero",
+            "After zero",
+        ]
+
+        captions = WebVTTReader(time_shift_milliseconds=-2000).read(
+            sample_webvtt_negative_shift
+        )
+        cues = captions.get_captions("en-US")
+
+        assert [c.get_text() for c in cues] == ["After zero"]
+        assert cues[0].start == 1000000
+        assert cues[0].end == 3000000
+
+    def test_negative_shift_leaves_cue_after_zero_unchanged(
+        self, sample_webvtt_negative_shift
+    ):
+        captions = WebVTTReader(time_shift_milliseconds=-1000).read(
+            sample_webvtt_negative_shift
+        )
+        cue = captions.get_captions("en-US")[2]
+
+        assert cue.start == 2000000
+        assert cue.end == 4000000
+
+    def test_negative_shift_drops_last_cue_without_trailing_blank_line(self):
+        captions = WebVTTReader(time_shift_milliseconds=-3500).read(
+            "WEBVTT\n\n00:00:03.000 --> 00:00:04.000\nKept\n\n"
+            "00:00:03.000 --> 00:00:03.500\nDropped"
+        )
+
+        assert [c.get_text() for c in captions.get_captions("en-US")] == ["Kept"]
+
+    def test_negative_shift_dropping_every_cue_raises_no_captions(
+        self, sample_webvtt_negative_shift
+    ):
+        with pytest.raises(CaptionReadNoCaptions):
+            WebVTTReader(time_shift_milliseconds=-5000).read(
+                sample_webvtt_negative_shift
+            )
+
+    def test_negative_shift_clamping_passes_strict_timing_validation(
+        self, sample_webvtt_negative_shift
+    ):
+        captions = WebVTTReader(
+            ignore_timing_errors=False, time_shift_milliseconds=-1000
+        ).read(sample_webvtt_negative_shift)
+
+        assert [c.start for c in captions.get_captions("en-US")] == [
+            0,
+            0,
+            2000000,
+        ]
+
+    def test_negative_shift_still_rejects_inverted_dropped_cue(self):
+        with pytest.raises(CaptionReadError):
+            WebVTTReader(
+                ignore_timing_errors=False, time_shift_milliseconds=-5000
+            ).read("WEBVTT\n\n00:00:02.000 --> 00:00:01.000\nInverted\n")
+
+    def test_negative_float_shift_clamps(self, sample_webvtt_negative_shift):
+        captions = WebVTTReader(time_shift_milliseconds=-1000.5).read(
+            sample_webvtt_negative_shift
+        )
+        cues = captions.get_captions("en-US")
+
+        assert cues[0].start == 0
+        assert cues[0].end == 499500
+        assert cues[1].start == 0
+
+    def test_zero_shift_keeps_cue_at_zero(self):
+        captions = WebVTTReader(time_shift_milliseconds=0).read(
+            "WEBVTT\n\n00:00:00.000 --> 00:00:00.000\nZero length\n"
+        )
+
+        assert len(captions.get_captions("en-US")) == 1
+
     def test_webvtt_cue_components_parsed_from_text(self):
         nodes = self.reader._parse_cue_text(
             "<c vIntro><b>Wikipedia</b> is a great adventure. <i>It may have "
@@ -189,6 +298,74 @@ class TestWebVTTReader(ReaderTestingMixIn):
     def test_webvtt_empty_cue(self, sample_webvtt_empty_cue):
         assert 1 == len(self.reader.read(sample_webvtt_empty_cue).get_captions("en-US"))
 
+    @pytest.mark.parametrize("ignore_timing_errors", [True, False])
+    @pytest.mark.parametrize(
+        "fixture_name",
+        [
+            "sample_webvtt_empty_cue_then_id",
+            "sample_webvtt_empty_cue_then_note",
+            "sample_webvtt_empty_cue_then_style",
+            "sample_webvtt_empty_cue_then_region",
+            "sample_webvtt_empty_cue_multiple_blanks",
+        ],
+    )
+    def test_blank_line_closes_empty_cue(
+        self, request, fixture_name, ignore_timing_errors
+    ):
+        captions = WebVTTReader(ignore_timing_errors=ignore_timing_errors).read(
+            request.getfixturevalue(fixture_name)
+        )
+
+        assert [
+            (c.start, c.end, c.get_text()) for c in captions.get_captions("en-US")
+        ] == [(4000000, 5000000, "C")]
+
+    def test_empty_last_cue_is_dropped(self, sample_webvtt_empty_last_cue):
+        captions = self.reader.read(sample_webvtt_empty_last_cue)
+
+        assert [
+            (c.start, c.end, c.get_text()) for c in captions.get_captions("en-US")
+        ] == [(0, 2000000, "A")]
+
+    @pytest.mark.parametrize("ignore_timing_errors", [True, False])
+    def test_empty_cue_id_counts_for_duplicate_warning(
+        self, sample_webvtt_empty_cue_then_duplicate_id, ignore_timing_errors
+    ):
+        reader = WebVTTReader(ignore_timing_errors=ignore_timing_errors)
+        with pytest.warns(CaptionReadWarning, match="Duplicate cue identifier 'cue-1'"):
+            captions = reader.read(sample_webvtt_empty_cue_then_duplicate_id)
+
+        assert [c.get_text() for c in captions.get_captions("en-US")] == ["C"]
+
+    def test_dropped_empty_cue_before_zero_is_closed(self):
+        captions = WebVTTReader(time_shift_milliseconds=-2000).read(
+            "WEBVTT\n\n00:00.000 --> 00:01.000\n\ncue-2\n00:03.000 --> 00:04.000\nC\n"
+        )
+
+        assert [
+            (c.start, c.end, c.get_text()) for c in captions.get_captions("en-US")
+        ] == [(1000000, 2000000, "C")]
+
+    @pytest.mark.parametrize("ignore_timing_errors", [True, False])
+    def test_orphan_text_after_empty_cue_is_ignored(
+        self, sample_webvtt_empty_cue_then_orphan_text, ignore_timing_errors
+    ):
+        captions = WebVTTReader(ignore_timing_errors=ignore_timing_errors).read(
+            sample_webvtt_empty_cue_then_orphan_text
+        )
+
+        assert [
+            (c.start, c.end, c.get_text()) for c in captions.get_captions("en-US")
+        ] == [(4000000, 5000000, "C")]
+
+    @pytest.mark.parametrize("ignore_timing_errors", [True, False])
+    def test_only_orphan_text_after_empty_cue_raises_no_captions(
+        self, sample_webvtt_empty_cue_only_orphan_text, ignore_timing_errors
+    ):
+        reader = WebVTTReader(ignore_timing_errors=ignore_timing_errors)
+        with pytest.raises(CaptionReadNoCaptions):
+            reader.read(sample_webvtt_empty_cue_only_orphan_text)
+
 
 class TestWebVTTWriter:
     def setup_method(self):

{pycaption-2.3.13 → pycaption-2.3.14}/tests/test_webvtt_conversion.py

@@ -2,6 +2,8 @@ import re
 
 from xml.etree import ElementTree
 
+import pytest
+
 from pycaption import (
     DFXPReader,
     DFXPWriter,
@@ -108,6 +110,30 @@ class TestWebVTTtoWebVTT(WebVTTTestingMixIn):
         assert re.match(expected_timestamp_line_pattern, results[5])
 
 
+class TestWebVTTEmptyCueConversion:
+    @pytest.mark.parametrize(
+        "writer", [WebVTTWriter, SRTWriter, DFXPWriter, SAMIWriter]
+    )
+    @pytest.mark.parametrize("ignore_timing_errors", [True, False])
+    @pytest.mark.parametrize(
+        "fixture_name, leaked_text",
+        [
+            ("sample_webvtt_empty_cue_then_id", "cue-2"),
+            ("sample_webvtt_empty_cue_then_note", "hello"),
+            ("sample_webvtt_empty_cue_multiple_blanks", "cue-2"),
+        ],
+    )
+    def test_no_leak_after_empty_cue(
+        self, request, fixture_name, leaked_text, ignore_timing_errors, writer
+    ):
+        caption_set = WebVTTReader(ignore_timing_errors=ignore_timing_errors).read(
+            request.getfixturevalue(fixture_name)
+        )
+        results = writer().write(caption_set)
+
+        assert leaked_text not in results
+
+
 #     # TODO: Write a test that includes a WebVTT file with style tags
 #     # That will fail because the styles used in the cues are not tracked.
 
@@ -1383,3 +1409,31 @@ class TestMultipleLayoutsPerCaption:
         assert len(cues) == 2
         assert cues[0][1] == ["plain"]
         assert cues[1][1] == ["styled<i>"]
+
+
+class TestWebVTTNegativeTimeShiftConversion:
+    @pytest.mark.parametrize("shift", [-1000, -1500, -2000])
+    @pytest.mark.parametrize(
+        "writer", [WebVTTWriter, SRTWriter, DFXPWriter, SAMIWriter]
+    )
+    def test_no_wrapped_timestamp_written(
+        self, sample_webvtt_negative_shift, writer, shift
+    ):
+        caption_set = WebVTTReader(time_shift_milliseconds=shift).read(
+            sample_webvtt_negative_shift
+        )
+        output = writer().write(caption_set)
+
+        assert "23:59:" not in output
+        assert 'start="-' not in output
+
+    @pytest.mark.parametrize("shift", [-1000, -1500, -2000])
+    def test_webvtt_output_end_after_start(self, sample_webvtt_negative_shift, shift):
+        caption_set = WebVTTReader(time_shift_milliseconds=shift).read(
+            sample_webvtt_negative_shift
+        )
+        output = WebVTTWriter().write(caption_set)
+        timings = re.findall(r"(\S+) --> (\S+)", output)
+
+        assert timings
+        assert all(start < end for start, end in timings)