pycaption 2.3.8__tar.gz → 2.3.10__tar.gz

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

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

{pycaption-2.3.8 → pycaption-2.3.10}/pycaption/dfxp/writer.py

@@ -216,36 +216,275 @@ class DFXPWriter(BaseWriter):
     def _recreate_text(self, caption, dfxp, caption_set=None, lang=None):
         """Serialize all nodes of a caption into DFXP inline markup.
 
-        Handles text nodes, line breaks (<br/>), and style spans.
+        Handles text nodes, line breaks (<br/>), and style spans.  Nodes are
+        first split into runs sharing one region; a run whose region is not
+        the one already in effect is wrapped in a <span> carrying it, so text
+        renders at its own position instead of inheriting the one on the
+        enclosing <p>, and a <br/> between two nodes of one region stays
+        inside that region.  A run holding no visible text takes no wrapper:
+        there is nothing for the region to place.
 
         :rtype: str
         """
         line = ""
         self._span_stack = []
+        paragraph = self.region_creator.get_positioning_info(lang, caption_set, caption)
+        paragraph_region, _ = paragraph
+
+        for region_id, region_attribs, nodes, wrappable in self._group_nodes_by_region(
+            caption, paragraph, caption_set, lang
+        ):
+            wrap = (
+                wrappable
+                and region_id != self._innermost_region(paragraph_region)
+                and self._holds_visible_text(nodes)
+            )
+            if wrap:
+                attrs = {"region": region_id}
+                if self.write_inline_positioning:
+                    attrs.update(region_attribs)
+                attr_str = " ".join(f'{k}="{v}"' for k, v in attrs.items())
+                line += f"<span {attr_str}>"
 
-        for node in caption.nodes:
-            if node.type_ == CaptionNode.TEXT:
-                line += escape(node.content)
+            for node in nodes:
+                if node.type_ == CaptionNode.TEXT:
+                    line += escape(node.content)
 
-            elif node.type_ == CaptionNode.BREAK:
-                line = line.rstrip() + "<br/>\n    "
+                elif node.type_ == CaptionNode.BREAK:
+                    line = line.rstrip() + "<br/>\n    "
 
-            elif node.type_ == CaptionNode.STYLE:
-                line = self._recreate_span(line, node, dfxp, caption_set, caption, lang)
+                elif node.type_ == CaptionNode.STYLE:
+                    line = self._recreate_span(
+                        line, node, dfxp, caption_set, caption, lang
+                    )
+
+            if wrap:
+                line = line.rstrip() + "</span> "
 
         while self._span_stack:
-            line = line.rstrip() + "</span> "
-            self._span_stack.pop()
+            emitted, _ = self._span_stack.pop()
+            if emitted:
+                line = line.rstrip() + "</span> "
 
         return line.rstrip()
 
+    def _group_nodes_by_region(self, caption, paragraph, caption_set, lang):
+        """Split a caption's nodes into consecutive runs sharing one region.
+
+        Line breaks are neutral: a run absorbs one only when it continues
+        past it, so a break between two nodes of the same region ends up
+        inside that region's span rather than outside it.  Breaks left over
+        between two runs form a run of their own, which is never wrapped.
+        A run is split again around any style tag whose partner falls
+        outside it, so one such tag costs only itself a wrapper.
+
+        :param paragraph: (region_id, positioning attributes) of the enclosing <p>
+        :return: (region_id, positioning_attributes, nodes, wrappable) per run
+        :rtype: list[tuple[str | None, dict, list[CaptionNode], bool]]
+        """
+        resolved, partners = self._resolve_node_regions(
+            caption, paragraph, caption_set, lang
+        )
+
+        groups = []
+        current = None
+        pending = []
+
+        for index, (region_id, region_attribs) in enumerate(resolved):
+            if region_id is None:
+                pending.append(index)
+                continue
+
+            if current and region_id == current[0]:
+                current[2].extend(pending)
+            else:
+                if current:
+                    groups.append(current)
+                if pending:
+                    groups.append((None, {}, pending))
+                current = [region_id, region_attribs, []]
+            pending = []
+            current[2].append(index)
+
+        if current:
+            groups.append(current)
+        if pending:
+            groups.append((None, {}, pending))
+
+        return [
+            (
+                region_id,
+                region_attribs,
+                [caption.nodes[index] for index in segment],
+                region_id is not None
+                and self._is_wrappable(segment, partners, caption.nodes),
+            )
+            for region_id, region_attribs, indices in groups
+            for segment in self._split_at_crossing_styles(
+                indices, partners, caption.nodes
+            )
+        ]
+
+    @staticmethod
+    def _holds_visible_text(nodes):
+        """Check whether a run has any text for a region to place.
+
+        A run of nothing but style tags and breaks renders nothing, so a
+        wrapper carrying its region would be an empty span.
+
+        :rtype: bool
+        """
+        return any(
+            node.type_ == CaptionNode.TEXT and node.content.strip() for node in nodes
+        )
+
+    @staticmethod
+    def _crosses_run(index, partners, nodes, run):
+        """Check whether the node at an index leaves the run it belongs to.
+
+        A style tag whose partner sits outside the run does: a span wrapping
+        it would cross that tag's own span and produce invalid XML.  A
+        closing tag with no partner at all is the exception — nothing was
+        opened for it, so it writes no tag and crosses nothing.
+
+        :param run: the indices making up the run
+        :type run: set[int]
+        :rtype: bool
+        """
+        node = nodes[index]
+        if node.type_ != CaptionNode.STYLE:
+            return False
+
+        if not node.start and index not in partners:
+            return False
+
+        return partners.get(index) not in run
+
+    @classmethod
+    def _split_at_crossing_styles(cls, indices, partners, nodes):
+        """Split a run around style tags whose partner sits outside it.
+
+        A span wrapping such a tag would cross another span and produce
+        invalid XML, but only that tag is in the way — the nodes beside it
+        still deserve their own region, so they come back as runs of their
+        own instead of losing their position along with it.
+
+        :rtype: list[list[int]]
+        """
+        run = set(indices)
+        segments = [[]]
+
+        for index in indices:
+            if cls._crosses_run(index, partners, nodes, run):
+                segments += [[index], []]
+            else:
+                segments[-1].append(index)
+
+        return [segment for segment in segments if segment]
+
+    def _resolve_node_regions(self, caption, paragraph, caption_set, lang):
+        """Resolve the region every node of a caption belongs to.
+
+        A node's own layout wins; lacking one it takes the region in effect
+        around it — the innermost enclosing style span's, else the
+        paragraph's.  For a closing style node that is its own opener's
+        region, so a span is never separated from its own end tag.  Line
+        breaks belong to no region and resolve to None, as does a closing
+        tag with nothing open — it writes no tag at all.  A region travels
+        with the attributes that describe it, so a span reinstating one can
+        also write it inline.
+
+        :param paragraph: (region_id, positioning attributes) of the <p>
+        :return: a (region_id, positioning_attributes) pair per node, plus a
+            map pairing the index of each style tag with its partner's
+        :rtype: tuple[list[tuple[str | None, dict]], dict]
+        """
+        creator = self.region_creator
+        resolved = []
+        partners = {}
+        open_styles = []
+
+        for index, node in enumerate(caption.nodes):
+            in_effect = open_styles[-1][1] if open_styles else paragraph
+
+            if node.type_ == CaptionNode.BREAK:
+                resolved.append((None, {}))
+
+            elif node.type_ == CaptionNode.TEXT:
+                own = (None, {})
+                if node.content.strip():
+                    own = creator.get_node_positioning_info(node.layout_info)
+                resolved.append(own if own[0] else in_effect)
+
+            elif node.start:
+                if node.layout_info:
+                    region = creator.get_positioning_info(
+                        lang, caption_set, caption, node
+                    )
+                else:
+                    region = in_effect
+                open_styles.append((index, region))
+                resolved.append(region)
+
+            elif open_styles:
+                opener, _ = open_styles.pop()
+                partners[opener] = index
+                partners[index] = opener
+                resolved.append(in_effect)
+
+            else:
+                resolved.append((None, {}))
+
+        return resolved, partners
+
+    @classmethod
+    def _is_wrappable(cls, indices, partners, nodes):
+        """Check whether a run of nodes can take a <span> holding its region.
+
+        No style tag in the run may leave it, or the wrapping span would
+        cross a style span and produce invalid XML — which is what rules out
+        a tag split off on its own.  A run that is nothing but one style span
+        already writes any region of its own on that span, so it needs no
+        wrapper.
+
+        :rtype: bool
+        """
+        run = set(indices)
+        for index in indices:
+            if cls._crosses_run(index, partners, nodes, run):
+                return False
+
+        first = nodes[indices[0]]
+
+        return not (
+            first.type_ == CaptionNode.STYLE
+            and first.start
+            and partners.get(indices[0]) == indices[-1]
+        )
+
+    def _innermost_region(self, default):
+        """Return the region in effect at the current point in the caption.
+
+        The innermost open span carrying a region wins; with no such span,
+        the region on the enclosing <p> applies.
+
+        :param default: region of the enclosing <p>
+        :rtype: str
+        """
+        for _, region_id in reversed(self._span_stack):
+            if region_id:
+                return region_id
+
+        return default
+
     def _recreate_span(
         self, line, node, dfxp, caption_set=None, caption=None, lang=None
     ):
         """Open or close a <span> element for a style node.
 
         Supports nested spans via a stack.  Opening pushes onto the stack;
-        closing pops the most recent span.
+        closing pops the most recent span.  Each entry records whether a tag
+        was actually emitted and which region it carries, if any.
 
         :param line: the accumulated markup string so far
         :type line: str
@@ -254,6 +493,7 @@ class DFXPWriter(BaseWriter):
         """
         if node.start:
             attrs = _recreate_style(node.content, dfxp)
+            region_id = None
             if node.layout_info:
                 region_id, region_attribs = self.region_creator.get_positioning_info(
                     lang, caption_set, caption, node
@@ -265,13 +505,13 @@ class DFXPWriter(BaseWriter):
             if attrs:
                 attr_str = " ".join(f'{k}="{v}"' for k, v in attrs.items())
                 line += f"<span {attr_str}>"
-                self._span_stack.append(True)
+                self._span_stack.append((True, region_id))
             else:
-                self._span_stack.append(False)
+                self._span_stack.append((False, None))
 
         else:
             if self._span_stack:
-                had_span = self._span_stack.pop()
+                had_span, _ = self._span_stack.pop()
                 if had_span:
                     line = line.rstrip() + "</span> "
 
@@ -331,7 +571,12 @@ class RegionCreator:
         """Create <region> tags in the <layout> section for each Layout.
 
         Skips Layout objects that have no positioning data (no origin,
-        extent, padding, alignment, or writing_direction).
+        extent, padding, alignment, or writing_direction).  A line alignment
+        on its own is not positioning data: it is what a WebVTT ``line``
+        setting leaves behind when its value yields no line to place the cue
+        at — ``line:auto,start``, or a value the grammar discards outright —
+        so the cue keeps the default placement rather than taking a vertical
+        one from the qualifier alone.
 
         :param unique_layouts: iterable of geometry.Layout instances
         :type dfxp: BeautifulSoup
@@ -450,6 +695,26 @@ class RegionCreator:
 
         return region_id, positioning_attributes
 
+    def get_node_positioning_info(self, layout_info):
+        """Return (region_id, positioning_attributes) for a node's own layout.
+
+        Unlike get_positioning_info, this neither cascades to the caption and
+        the caption set nor falls back to the default region: a layout without
+        a region of its own yields (None, {}).
+
+        :type layout_info: geometry.Layout | None
+        :rtype: tuple[str | None, dict]
+        """
+        region_id = self._region_map.get(layout_info)
+        if not region_id:
+            return None, {}
+
+        self._assigned_region_ids.add(region_id)
+
+        return region_id, _convert_layout_to_attributes(
+            layout_info, self._fallback_alignment
+        )
+
     def cleanup_regions(self):
         """Remove <region> tags that were never assigned to any element."""
         layout_tag = self._dfxp.find("layout")

{pycaption-2.3.8 → pycaption-2.3.10}/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.10}/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.10}/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.10}/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.10}/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)