pycaption 2.3.8__tar.gz → 2.3.9__tar.gz

{pycaption-2.3.8/pycaption.egg-info → pycaption-2.3.9}/PKG-INFO

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

{pycaption-2.3.8 → pycaption-2.3.9}/pycaption/sami/parser.py

@@ -174,6 +174,10 @@ class SAMIParser(HTMLParser):
         :rtype: str | None
         """
         for attr, value in attrs:
+            if value is None:
+                # A valueless attribute (e.g. a bare ``class``) carries no
+                # language information; skip it rather than crashing.
+                continue
             if attr.lower() == "lang":
                 return value[:2]
             if attr.lower() == "class":

{pycaption-2.3.8 → pycaption-2.3.9}/pycaption/sami/reader.py

@@ -142,7 +142,13 @@ class SAMIReader(BaseReader):
                 raise CaptionReadTimingError(
                     f"Missing start time on the following line: {p.parent}."
                 )
-            milliseconds = int(float(start_str))
+            try:
+                milliseconds = int(float(start_str))
+            except ValueError:
+                raise CaptionReadTimingError(
+                    f"Invalid start time {start_str!r} on the following "
+                    f"line: {p.parent}."
+                )
             start = milliseconds * 1000
 
             self._backfill_end_times(captions, start)

{pycaption-2.3.8 → pycaption-2.3.9}/pycaption/scc/reader.py

@@ -100,6 +100,7 @@ from .constants import (
     SPECIAL_CHARS,
 )
 from .specialized_collections import (
+    PUNCTUATION_PREFIXES,
     CaptionCreator,
     InstructionNodeCreator,
     NotifyingDict,
@@ -302,23 +303,28 @@ class SCCReader(BaseReader):
             word = word.strip()
             if len(word) == 4:
                 # Look ahead for the next command, skipping the duplicate
-                # that SCC uses for error-correction (same word repeated).
+                # that SCC uses for error-correction (same word repeated), to
+                # tell whether it decodes to punctuation.
                 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)
+                next_is_punctuation = (
+                    next_command is not None
+                    and next_command[:2] in PUNCTUATION_PREFIXES
+                )
+                self._translate_word(word=word, next_is_punctuation=next_is_punctuation)
 
-    def _translate_word(self, word, next_command=None):
+    def _translate_word(self, word, next_is_punctuation=False):
         """Dispatch a single 4-char hex word as command, special char, or text."""
         if self._handle_double_command(word):
             # count frames for timing
             self.time_translator._frames += 1
             return
         if word in COMMANDS or self._is_pac_command(word):
-            self._translate_command(word=word, next_command=next_command)
+            self._translate_command(word=word, next_is_punctuation=next_is_punctuation)
 
         # second, check if word is a special character
         elif word in SPECIAL_CHARS:
@@ -392,7 +398,7 @@ class SCCReader(BaseReader):
 
     _ROLL_UP_DEPTH = {"9425": 2, "9426": 3, "94a7": 4}
 
-    def _translate_command(self, word, next_command=None):
+    def _translate_command(self, word, next_is_punctuation=False):
         """Route a CEA-608 control command to the appropriate handler."""
         if word == "9420":
             self._cmd_pop_on()
@@ -409,7 +415,11 @@ class SCCReader(BaseReader):
         elif word == "942c":
             self._cmd_erase_displayed()
         else:
-            self.buffer.interpret_command(command=word, next_command=next_command)
+            self.buffer.interpret_command(
+                command=word,
+                next_is_punctuation=next_is_punctuation,
+                is_paint_on=self.buffer_dict.active_key == "paint",
+            )
 
     def _cmd_pop_on(self):
         """Handle Resume Caption Loading [RCL] - switch to pop-on mode."""

{pycaption-2.3.8 → pycaption-2.3.9}/pycaption/scc/specialized_collections.py

@@ -32,7 +32,7 @@ from .constants import (
 PopOnCue = collections.namedtuple("PopOnCue", "buffer, start, end")
 
 # First two hex chars of SCC codes that produce punctuation ['.', '!', '?', ',']
-_PUNCTUATION_PREFIXES = frozenset(["ae", "a1", "bf", "2c"])
+PUNCTUATION_PREFIXES = frozenset(["ae", "a1", "bf", "2c"])
 
 
 class PreCaption:
@@ -412,7 +412,7 @@ class InstructionNodeCreator:
             # only remaining possibility is plain text
             return "plaintext"
 
-    def interpret_command(self, command, next_command=None):
+    def interpret_command(self, command, next_is_punctuation=False, is_paint_on=False):
         """Given a command determines whether to turn italics on or off,
         or to set the positioning
 
@@ -420,9 +420,15 @@ class InstructionNodeCreator:
 
         :type command: str
         or a PAC_TAB_OFFSET_COMMANDS
-        :type next_command: the command that follows next
+        :type next_is_punctuation: bool
+        :param next_is_punctuation: whether the command right after this one
+            decodes to punctuation (comma, period, etc.)
+        :type is_paint_on: bool
+        :param is_paint_on: whether this command is being interpreted while
+            in paint-on mode, where a row+1 jump paired with a large column
+            jump indicates an unrelated, independently-positioned region
         """
-        self._update_positioning(command)
+        self._update_positioning(command, is_paint_on)
 
         if command == "94a1":
             self.handle_backspace("94a1")
@@ -434,7 +440,7 @@ class InstructionNodeCreator:
             self._handle_style_command(command)
 
         if command in MID_ROW_CODES and command not in PAC_TAB_OFFSET_COMMANDS:
-            self._handle_mid_row_spacing(next_command)
+            self._handle_mid_row_spacing(next_is_punctuation)
 
     def _handle_background_color(self):
         """Strip trailing space before a background color code (CEA-608 rule)."""
@@ -460,9 +466,7 @@ class InstructionNodeCreator:
         if self.last_style is not None and self.last_style != "italics off":
             return
         self._emit_pending_breaks(position)
-        self._collection.append(
-            _InstructionNode.create_italics_style(position)
-        )
+        self._collection.append(_InstructionNode.create_italics_style(position))
         self.last_style = "italics on"
 
     def _close_italics(self, position):
@@ -482,24 +486,29 @@ class InstructionNodeCreator:
         if not self._position_tracer.is_linebreak_required():
             return
         for _ in range(self._position_tracer._breaks_required):
-            self._collection.append(
-                _InstructionNode.create_break(position=position)
-            )
+            self._collection.append(_InstructionNode.create_break(position=position))
         self._position_tracer.acknowledge_linebreak_consumed()
 
-    def _handle_mid_row_spacing(self, next_command):
+    def _handle_mid_row_spacing(self, next_is_punctuation):
         """Insert spacing around mid-row code style transitions."""
-        next_is_punctuation = next_command and next_command[:2] in _PUNCTUATION_PREFIXES
+        if self._position_tracer.is_repositioning_required():
+            # A repositioning is already pending with no text written at the
+            # current position — that position is about to be abandoned, so
+            # padding it with a decorative space would wrongly consume the
+            # pending repositioning before the real content arrives.
+            return
         prev_text_node = self.get_previous_text_node()
         if not prev_text_node:
             return
         prev_node_is_break = any(
             x.is_explicit_break()
-            for x in self._collection[self._collection.index(prev_text_node):]
+            for x in self._collection[self._collection.index(prev_text_node) :]
         )
-        if (prev_node_is_break
-                or prev_text_node.text[-1].isspace()
-                or next_is_punctuation):
+        if (
+            prev_node_is_break
+            or prev_text_node.text[-1].isspace()
+            or next_is_punctuation
+        ):
             return
 
         if self.last_style == "italics off":
@@ -507,10 +516,11 @@ class InstructionNodeCreator:
         else:
             prev_text_node.text = prev_text_node.text + " "
 
-    def _update_positioning(self, command):
+    def _update_positioning(self, command, is_paint_on=False):
         """Sets the positioning information to use for the next nodes
 
         :type command: str
+        :type is_paint_on: bool
         """
         is_offset = False
         if command in PAC_TAB_OFFSET_COMMANDS:
@@ -529,7 +539,9 @@ class InstructionNodeCreator:
         offset_after_break = is_offset and self.has_break_before(self._collection)
         if not offset_after_break:
             # Tab offsets after line breaks will be ignored to avoid repositioning
-            self._position_tracer.update_positioning(positioning)
+            self._position_tracer.update_positioning(
+                positioning, column_jump_forces_reposition=is_paint_on
+            )
 
     def __iter__(self):
         return iter(_format_italics(self._collection))

{pycaption-2.3.8 → pycaption-2.3.9}/pycaption/scc/state_machines.py

@@ -25,17 +25,39 @@ class _PositioningTracker:
         # next positioning is actually a Tab Offset
         self._last_column = None
 
-    def update_positioning(self, positioning):
+    def update_positioning(self, positioning, column_jump_forces_reposition=False):
         """Being notified of a position change, updates the internal state,
         to as to be able to tell if it was a trivial change (a simple line
         break) or not.
 
         Strategy:
-        - Small jumps (1-3 rows): Use line breaks to preserve visual spacing
-        - Large jumps (4+ rows): Use repositioning (creates new cue)
+        - A jump to the very next row (row + 1): Use a single line break —
+          this is simple text wrapping onto the next line. Exception: if
+          paired with a column jump bigger than a tab offset in paint-on
+          mode (see ``column_jump_forces_reposition``), it's treated as a
+          repositioning instead, since paint-on is the only mode that can
+          display independent, simultaneously-timed regions one row apart.
+        - Any other row jump (a skipped row, or a jump backwards): Use
+          repositioning (creates new cue). A skipped row is not an
+          intentional blank line to preserve — CEA-608 PACs only declare an
+          absolute row position; nothing in the spec says a gap between two
+          rows must be rendered as a blank line downstream, and WebVTT/HTML
+          renderers draw a real, often background-filled line for each
+          break, which previously produced a visible black bar between two
+          lines of text that were never meant to have a gap between them.
 
         :type positioning: tuple[int]
         :param positioning: a tuple (row, col)
+
+        :type column_jump_forces_reposition: bool
+        :param column_jump_forces_reposition: when True, a row+1 jump
+            paired with a column jump larger than a tab offset (>3 columns)
+            is treated as a repositioning rather than a break. Only
+            paint-on mode can display independent, simultaneously-timed
+            regions at unrelated columns, so callers should only set this
+            for paint-on buffers — pop-on and roll-up buffers legitimately
+            use large column shifts between buffered/wrapped lines of the
+            same cue.
         """
         current = self._positions[-1]
 
@@ -51,24 +73,31 @@ class _PositioningTracker:
         new_row, new_col = positioning
         is_tab_offset = new_row == row and col + 1 <= new_col <= col + 3
 
-        # Threshold for when to use breaks vs repositioning
-        # Jumps of 4+ rows will trigger repositioning instead of adding breaks
-        max_breaks_threshold = 3
-
         # Handle row jumps
         if new_row > row:
-            row_diff = new_row - row
-
-            # Small jumps (1-3 rows): Use line breaks to preserve visual spacing
-            if row_diff <= max_breaks_threshold:
+            is_large_column_jump = (
+                column_jump_forces_reposition and abs(new_col - col) > 3
+            )
+
+            # A jump to the very next row: use a line break. But if a
+            # repositioning was already pending and unconsumed (no text was
+            # ever written at the current position), this row jump is
+            # continuing that same unresolved position change, not wrapping
+            # text — so it must stay a repositioning rather than become a
+            # break. Likewise, in paint-on mode, pairing the row+1 jump
+            # with a column jump bigger than a tab offset means the new PAC
+            # almost certainly targets an unrelated, independently-positioned
+            # region rather than wrapping the current text.
+            if (
+                new_row == row + 1
+                and not self._repositioning_required
+                and not is_large_column_jump
+            ):
                 self._positions.append((new_row, col))
-                # Add breaks equal to row difference
-                # Row N -> N+1: 1 break
-                # Row N -> N+2: 2 breaks (preserves 1 blank line)
-                # Row N -> N+3: 3 breaks (preserves 2 blank lines)
-                self._breaks_required = row_diff
+                self._breaks_required = 1
                 self._last_column = new_col
-            # Large jumps (4+ rows): Use repositioning (new cue)
+            # A skipped row, a jump backwards, or a row+1 jump with a large
+            # paint-on column jump: use repositioning (new cue)
             else:
                 # Reset position - this triggers repositioning
                 self._positions = [positioning]
@@ -165,7 +194,7 @@ class DefaultProvidingPositionTracker(_PositioningTracker):
         except CaptionReadSyntaxError:
             return self.default
 
-    def update_positioning(self, positioning):
+    def update_positioning(self, positioning, column_jump_forces_reposition=False):
         """If called, sets this positioning as the default, then delegates
         to the super class.
 
@@ -175,4 +204,4 @@ class DefaultProvidingPositionTracker(_PositioningTracker):
         if positioning:
             self.default = positioning
 
-        super().update_positioning(positioning)
+        super().update_positioning(positioning, column_jump_forces_reposition)

{pycaption-2.3.8 → pycaption-2.3.9}/pycaption/srt.py

@@ -6,7 +6,7 @@ from .base import (
     BaseReader, BaseWriter, Caption, CaptionList, CaptionNode, CaptionSet,
     merge_caption_list,
 )
-from .exceptions import CaptionReadNoCaptions
+from .exceptions import CaptionReadNoCaptions, CaptionReadSyntaxError
 from .geometry import HorizontalAlignmentEnum
 
 
@@ -21,6 +21,8 @@ class SRTReader(BaseReader):
         """
         content = self._decode_content(content)
         lines = content.splitlines()
+        if len(lines) < 2:
+            return False
         if lines[0].isdigit() and "-->" in lines[1]:
             return True
         else:
@@ -47,6 +49,11 @@ class SRTReader(BaseReader):
 
             end_line = self._find_text_line(start_line, lines)
 
+            if start_line + 1 >= len(lines) or "-->" not in lines[start_line + 1]:
+                raise CaptionReadSyntaxError(
+                    "Missing or malformed timing line after caption number "
+                    f"{lines[start_line]!r}."
+                )
             timing = lines[start_line + 1].split("-->")
             start = self._srttomicro(timing[0].strip(" \r\n"))
             end = self._srttomicro(timing[1].strip(" \r\n"))
@@ -81,15 +88,18 @@ class SRTReader(BaseReader):
     def _srttomicro(stamp):
         """Convert an SRT timestamp (HH:MM:SS,mmm) to microseconds."""
         timesplit = stamp.split(":")
-        if "," not in timesplit[2]:
-            timesplit[2] += ",000"
-        secsplit = timesplit[2].split(",")
-        microseconds = (
-            int(timesplit[0]) * 3600000000
-            + int(timesplit[1]) * 60000000
-            + int(secsplit[0]) * 1000000
-            + int(secsplit[1]) * 1000
-        )
+        try:
+            if "," not in timesplit[2]:
+                timesplit[2] += ",000"
+            secsplit = timesplit[2].split(",")
+            microseconds = (
+                int(timesplit[0]) * 3600000000
+                + int(timesplit[1]) * 60000000
+                + int(secsplit[0]) * 1000000
+                + int(secsplit[1]) * 1000
+            )
+        except (IndexError, ValueError):
+            raise CaptionReadSyntaxError(f"Invalid SRT timestamp: {stamp!r}.")
 
         return microseconds
 

{pycaption-2.3.8 → pycaption-2.3.9/pycaption.egg-info}/PKG-INFO

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

{pycaption-2.3.8 → pycaption-2.3.9}/setup.py

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

{pycaption-2.3.8 → pycaption-2.3.9}/tests/conftest.py

@@ -117,10 +117,18 @@ from tests.fixtures.scc import (  # noqa: F401
     sample_scc_multiple_positioning,
     sample_scc_no_explicit_end_to_last_caption,
     sample_scc_paint_on_edm,
+    sample_scc_paint_on_row_and_column_jump_in_one_pac,
+    sample_scc_paint_on_row_plus_one_large_column_jump,
     sample_scc_pop_on,
+    sample_scc_pop_on_row_and_column_jump_in_one_pac,
+    sample_scc_pop_on_row_plus_one_large_column_jump,
     sample_scc_produces_captions_with_start_and_end_time_the_same,
+    sample_scc_roll_up_row_and_column_jump_in_one_pac,
+    sample_scc_roll_up_row_plus_one_large_column_jump,
     sample_scc_roll_up_ru2,
     sample_scc_roll_up_ru3,
+    sample_scc_row_jump_with_pending_reposition,
+    sample_scc_row_skip_does_not_preserve_blank_line,
     sample_scc_special_and_extended_characters,
     sample_scc_tab_offset,
     sample_scc_with_ampersand_character,

{pycaption-2.3.8 → pycaption-2.3.9}/tests/fixtures/scc.py

@@ -1,6 +1,123 @@
 import pytest
 
 
+# Real-world bytes reproducing the "phantom BREAK" bug: two independent,
+# simultaneously-timed paint-on captions ("Always by her side" / "And
+# Trini!") whose PAC sequence has a small row jump (13 -> 15) combined
+# with a same-row column jump (col 4 -> 24) that was left unconsumed
+# (no text written) before the row jump landed.
+@pytest.fixture(scope="session")
+def sample_scc_row_jump_with_pending_reposition():
+    return """\
+Scenarist_SCC V1.0
+
+00:00:21:11 9420 942f 94ae 9420 13f2 91ae 9137 20c1 ecf7 6179 7320 6279 2068 e5f2 2073 e964 e520 9137 137c 9723 9120 94f4 9723 c16e 6420 54f2 e96e e9a1
+
+00:00:25:00 942c 942c 942f 942f
+"""
+
+
+# Real-world-equivalent bytes reproducing the phantom BREAK bug in its most
+# direct form: a single paint-on PAC jumps both row (13 -> 15, a skipped
+# row) and column (28 -> 8, far beyond a tab offset) in one step, with no
+# intervening column-only PAC and no pending unconsumed repositioning to
+# key off of. The row skip alone is already enough to force a new cue; the
+# column jump is incidental.
+@pytest.fixture(scope="session")
+def sample_scc_paint_on_row_and_column_jump_in_one_pac():
+    return """\
+Scenarist_SCC V1.0
+
+00:00:20:00 9429 9429 13fe 13fe c1c2 94f4 94f4 43c4 942c 942c
+"""
+
+
+# Same row-skip PAC pattern as
+# sample_scc_paint_on_row_and_column_jump_in_one_pac, but in pop-on mode
+# (9420 instead of 9429). A skipped row forces a new cue regardless of
+# buffer mode, so this must also split into two cues, not stay joined by
+# BREAK nodes.
+@pytest.fixture(scope="session")
+def sample_scc_pop_on_row_and_column_jump_in_one_pac():
+    return """\
+Scenarist_SCC V1.0
+
+00:00:20:00 9420 9420 13fe 13fe c1c2 94f4 94f4 43c4 942c 942c 942f 942f
+"""
+
+
+# Same row-skip PAC pattern again, but in roll-up mode (9425/RU2 instead of
+# 9429). Same as pop-on: the skipped row alone forces a new cue, so this
+# also splits into two cues rather than staying joined by BREAK nodes.
+@pytest.fixture(scope="session")
+def sample_scc_roll_up_row_and_column_jump_in_one_pac():
+    return """\
+Scenarist_SCC V1.0
+
+00:00:20:00 9425 9425 13fe 13fe c1c2 94f4 94f4 43c4 942c 942c
+"""
+
+
+# Real-world-equivalent bytes: a single paint-on PAC jumps to the very next
+# row (5 -> 6, not a skip) but combined with a large column jump (0 -> 20,
+# far beyond a tab offset), with no intervening column-only PAC and no
+# pending unconsumed repositioning to key off of. Unlike a simple text wrap
+# onto the next line (which stays at roughly the same column), this pattern
+# indicates a second, independently-positioned region drawn one row below
+# the first — the same "two side-by-side captions in paint-on mode" bug
+# class this branch fixes for skipped rows, but for a row+1 jump instead.
+@pytest.fixture(scope="session")
+def sample_scc_paint_on_row_plus_one_large_column_jump():
+    return """\
+Scenarist_SCC V1.0
+
+00:00:20:00 9429 9429 1540 1540 c1c2 157a 157a 43c4 942c 942c
+"""
+
+
+# Same row+1-plus-large-column-jump PAC pattern as
+# sample_scc_paint_on_row_plus_one_large_column_jump, but in pop-on mode
+# (9420 instead of 9429). column_jump_forces_reposition is only passed as
+# True for paint-on buffers, so pop-on's large column shift between the
+# wrapped lines is treated as legitimate same-cue formatting rather than an
+# independent region — this must stay a single caption joined by a BREAK
+# node, even though the column jump is identical to the paint-on case.
+@pytest.fixture(scope="session")
+def sample_scc_pop_on_row_plus_one_large_column_jump():
+    return """\
+Scenarist_SCC V1.0
+
+00:00:20:00 9420 9420 1540 1540 c1c2 157a 157a 43c4 942c 942c 942f 942f
+"""
+
+
+# Same row+1-plus-large-column-jump PAC pattern again, but in roll-up mode
+# (9425/RU2 instead of 9429). Like pop-on, roll-up is exempt from the
+# column-jump check, so this must also stay a single caption joined by a
+# BREAK node rather than being split like the paint-on case.
+@pytest.fixture(scope="session")
+def sample_scc_roll_up_row_plus_one_large_column_jump():
+    return """\
+Scenarist_SCC V1.0
+
+00:00:20:00 9425 9425 1540 1540 c1c2 157a 157a 43c4 942c 942c
+"""
+
+
+# Real-world bytes: a single pop-on cue whose text skips a row (row 1 -> 3)
+# with no preceding same-row PAC and no large-enough column jump to be
+# mistaken for an independent region. This must split into two independently-
+# positioned cues with no BREAK node joining them, since a skipped row is
+# not an intentional blank line to preserve in the rendered cue.
+@pytest.fixture(scope="session")
+def sample_scc_row_skip_does_not_preserve_blank_line():
+    return """\
+Scenarist_SCC V1.0
+
+00:00:20:00 9420 9420 9152 9152 9723 9723 c1c2 92d0 92d0 43c4 942c 942c 942f 942f
+"""
+
+
 @pytest.fixture(scope="session")
 def sample_scc_created_dfxp_with_wrongly_closing_spans():
     return """\

{pycaption-2.3.8 → pycaption-2.3.9}/tests/test_base.py

@@ -6,7 +6,6 @@ from pycaption.exceptions import CaptionReadSyntaxError
 from pycaption.scc.state_machines import _PositioningTracker
 
 
-
 class TestCaptionReadError:
     def test_str_includes_class_name_and_message(self):
         err = CaptionReadError("bad data")
@@ -83,19 +82,23 @@ class TestPositioningTracker:
         assert tracker._breaks_required == 1
         assert not tracker.is_repositioning_required()
 
-    def test_two_row_jump_creates_two_breaks(self):
+    def test_two_row_jump_triggers_repositioning_not_breaks(self):
+        # Skips row 2 -> not a simple wrap onto the next line, so it must
+        # become a repositioning (new cue), not a break.
         tracker = _PositioningTracker((1, 0))
         tracker.update_positioning((3, 0))
 
-        assert tracker._breaks_required == 2
-        assert tracker.is_linebreak_required()
+        assert not tracker.is_linebreak_required()
+        assert tracker.is_repositioning_required()
+        assert tracker._breaks_required == 0
 
-    def test_three_row_jump_creates_three_breaks(self):
+    def test_three_row_jump_triggers_repositioning_not_breaks(self):
         tracker = _PositioningTracker((1, 0))
         tracker.update_positioning((4, 0))
 
-        assert tracker._breaks_required == 3
-        assert tracker.is_linebreak_required()
+        assert not tracker.is_linebreak_required()
+        assert tracker.is_repositioning_required()
+        assert tracker._breaks_required == 0
 
     def test_four_row_jump_triggers_repositioning_not_breaks(self):
         tracker = _PositioningTracker((1, 0))
@@ -107,8 +110,8 @@ class TestPositioningTracker:
 
     def test_acknowledge_linebreak_consumed_resets_counter(self):
         tracker = _PositioningTracker((1, 0))
-        tracker.update_positioning((3, 0))
-        assert tracker._breaks_required == 2
+        tracker.update_positioning((2, 0))
+        assert tracker._breaks_required == 1
 
         tracker.acknowledge_linebreak_consumed()
 
@@ -122,6 +125,76 @@ class TestPositioningTracker:
 
         assert not tracker.is_repositioning_required()
 
+    def test_pending_repositioning_is_preserved_across_small_row_jump(self):
+        tracker = _PositioningTracker((13, 4))
+        # Same-row column jump with no text written: leaves a repositioning
+        # pending and unconsumed.
+        tracker.update_positioning((13, 24))
+        assert tracker.is_repositioning_required()
+
+        # A small row jump on top of that pending, unconsumed repositioning
+        # must not be reinterpreted as a trivial line break.
+        tracker.update_positioning((15, 8))
+
+        assert tracker.is_repositioning_required()
+        assert not tracker.is_linebreak_required()
+        assert tracker._breaks_required == 0
+
+    def test_row_jump_without_pending_repositioning_still_creates_breaks(self):
+        tracker = _PositioningTracker((14, 10))
+        tracker.update_positioning((15, 1))
+
+        assert tracker.is_linebreak_required()
+        assert tracker._breaks_required == 1
+        assert not tracker.is_repositioning_required()
+
+    def test_paint_on_row_plus_one_with_large_column_jump_forces_reposition(self):
+        # A row+1 jump normally stays a break, but a large column jump
+        # alongside it in paint-on mode signals an unrelated, independently-
+        # positioned region one row below, so it must reposition instead.
+        tracker = _PositioningTracker((13, 0))
+        tracker.update_positioning((14, 20), column_jump_forces_reposition=True)
+
+        assert tracker.is_repositioning_required()
+        assert not tracker.is_linebreak_required()
+
+    def test_row_plus_one_with_large_column_jump_stays_break_outside_paint_on(self):
+        # The same large column jump must NOT force a repositioning when
+        # column_jump_forces_reposition is left at its default (pop-on and
+        # roll-up buffers legitimately use large column shifts between
+        # wrapped lines of the same cue).
+        tracker = _PositioningTracker((13, 0))
+        tracker.update_positioning((14, 20))
+
+        assert not tracker.is_repositioning_required()
+        assert tracker.is_linebreak_required()
+
+    def test_paint_on_column_jump_boundary_at_tab_offset_threshold(self):
+        """A column jump of exactly 3 (matching the tab-offset threshold
+        used elsewhere) alongside a row+1 jump must stay a break; one
+        column beyond that, a jump of 4, must force a repositioning.
+        Checked in both the positive (rightward) and negative (leftward)
+        column directions, since the implementation compares by absolute
+        value.
+        """
+        tracker = _PositioningTracker((13, 0))
+        tracker.update_positioning((14, 3), column_jump_forces_reposition=True)
+        assert not tracker.is_repositioning_required()
+        assert tracker.is_linebreak_required()
+
+        tracker = _PositioningTracker((13, 0))
+        tracker.update_positioning((14, 4), column_jump_forces_reposition=True)
+        assert tracker.is_repositioning_required()
+
+        tracker = _PositioningTracker((13, 10))
+        tracker.update_positioning((14, 7), column_jump_forces_reposition=True)
+        assert not tracker.is_repositioning_required()
+        assert tracker.is_linebreak_required()
+
+        tracker = _PositioningTracker((13, 10))
+        tracker.update_positioning((14, 6), column_jump_forces_reposition=True)
+        assert tracker.is_repositioning_required()
+
     def test_reset_for_new_caption_clears_all_state(self):
         tracker = _PositioningTracker((1, 0))
         tracker.update_positioning((3, 0))