pycaption 2.3.7__tar.gz → 2.3.9__tar.gz

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

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

{pycaption-2.3.7 → pycaption-2.3.9}/pycaption/dfxp/writer.py

@@ -4,13 +4,14 @@ Serializes pycaption CaptionSet objects into DFXP/TTML XML documents,
 including style elements, region-based positioning, and writing direction.
 """
 
+import re
 from copy import deepcopy
 from xml.sax.saxutils import escape
 
 from bs4 import BeautifulSoup
 
 from ..base import BaseWriter, CaptionNode
-from ..geometry import HorizontalAlignmentEnum, WritingDirectionEnum
+from ..geometry import HorizontalAlignmentEnum, LineAlignmentEnum, WritingDirectionEnum
 from .constants import (
     DFXP_ATTR_XML_ID,
     DFXP_ATTR_XML_LANG,
@@ -30,6 +31,12 @@ _WRITING_DIRECTION_TO_DFXP = {
     WritingDirectionEnum.VERTICAL_LR: "tblr",
 }
 
+_LINE_ALIGNMENT_TO_DISPLAY_ALIGN = {
+    LineAlignmentEnum.START: "before",
+    LineAlignmentEnum.CENTER: "center",
+    LineAlignmentEnum.END: "after",
+}
+
 
 class DFXPWriter(BaseWriter):
     """Converts a CaptionSet to DFXP/TTML format.
@@ -454,12 +461,42 @@ class RegionCreator:
                 region.extract()
 
 
+_CSS_LENGTH_RE = re.compile(r"^-?[\d.]+(?:px|em|%|pt|rem|c)?$")
+_CSS_COLOR_RE = re.compile(r"^(?:#[0-9a-fA-F]{3,8}|rgba?\([^)]+\)|[a-zA-Z]{3,})$")
+
+
+def _text_shadow_to_outline(value):
+    """Best-effort conversion of CSS text-shadow to tts:textOutline.
+
+    Extracts the color and a representative thickness from the first shadow
+    in the list. Returns "color thickness" or None if unparseable.
+    """
+    first_shadow = value.split(",")[0].strip()
+    tokens = first_shadow.split()
+    color = None
+    lengths = []
+    for token in tokens:
+        if _CSS_LENGTH_RE.match(token):
+            lengths.append(token)
+        elif _CSS_COLOR_RE.match(token):
+            color = token
+    if not lengths:
+        return None
+    if len(lengths) >= 3:
+        thickness = lengths[2]
+    else:
+        thickness = lengths[0]
+    if color:
+        return f"{color} {thickness}"
+    return thickness
+
+
 def _recreate_style(content, dfxp):
     """Convert an internal style dict to DFXP/TTS style attributes.
 
     Maps pycaption's internal keys (class, italics, bold, underline, color,
-    background-color, font-family, font-size, text-align, display-align)
-    to their tts: namespace equivalents.
+    background-color, font-family, font-size, text-shadow, text-align,
+    display-align) to their tts: namespace equivalents.
 
     :param content: internal style dictionary
     :type content: dict
@@ -487,10 +524,18 @@ def _recreate_style(content, dfxp):
         dfxp_style["tts:fontFamily"] = content["font-family"]
     if "font-size" in content:
         dfxp_style["tts:fontSize"] = content["font-size"]
+    if "text-shadow" in content:
+        outline = _text_shadow_to_outline(content["text-shadow"])
+        if outline:
+            dfxp_style["tts:textOutline"] = outline
     if "color" in content:
         dfxp_style["tts:color"] = content["color"]
     if "background-color" in content:
         dfxp_style["tts:backgroundColor"] = content["background-color"]
+    if "opacity" in content:
+        dfxp_style["tts:opacity"] = content["opacity"]
+    if "line-height" in content:
+        dfxp_style["tts:lineHeight"] = content["line-height"]
     if "display-align" in content:
         dfxp_style["tts:displayAlign"] = content["display-align"]
 
@@ -536,4 +581,9 @@ def _convert_layout_to_attributes(layout, fallback_alignment=None):
     if writing_mode:
         result["tts:writingMode"] = writing_mode
 
+    if layout.line_alignment:
+        display_align = _LINE_ALIGNMENT_TO_DISPLAY_ALIGN.get(layout.line_alignment)
+        if display_align:
+            result["tts:displayAlign"] = display_align
+
     return result

{pycaption-2.3.7 → pycaption-2.3.9}/pycaption/geometry.py

@@ -68,6 +68,15 @@ class PositionAlignmentEnum(Enum):
     LINE_RIGHT = "line-right"
 
 
+class LineAlignmentEnum(Enum):
+    """WebVTT line alignment: how the cue box is positioned relative to
+    the line setting value (start, center, or end of the cue box)."""
+
+    START = "start"
+    CENTER = "center"
+    END = "end"
+
+
 class WritingDirectionEnum(Enum):
     """Specifies WebVTT writing direction (vertical cue setting)."""
 
@@ -609,6 +618,7 @@ class Layout:
         webvtt_positioning=None,
         writing_direction=None,
         position_alignment=None,
+        line_alignment=None,
         inherit_from=None,
     ):
         """
@@ -638,6 +648,10 @@ class Layout:
         :param position_alignment: Which edge of the cue box the position
             percentage anchors to (line-left, center, or line-right).
 
+        :type line_alignment: LineAlignmentEnum
+        :param line_alignment: How the cue box is vertically aligned relative
+            to the line position (start, center, or end).
+
         :type inherit_from: Layout
         :param inherit_from: A Layout with the positioning parameters to be
             used if not specified by the positioning arguments,
@@ -650,6 +664,7 @@ class Layout:
         self.webvtt_positioning = webvtt_positioning
         self.writing_direction = writing_direction
         self.position_alignment = position_alignment
+        self.line_alignment = line_alignment
 
         if inherit_from:
             for attr_name in [
@@ -659,6 +674,7 @@ class Layout:
                 "alignment",
                 "writing_direction",
                 "position_alignment",
+                "line_alignment",
             ]:
                 attr = getattr(self, attr_name)
                 if not attr:
@@ -674,6 +690,7 @@ class Layout:
                 self.webvtt_positioning,
                 self.writing_direction,
                 self.position_alignment,
+                self.line_alignment,
             )
         )
 
@@ -692,6 +709,7 @@ class Layout:
             None if not self.alignment else self.alignment.serialized(),
             self.writing_direction,
             self.position_alignment,
+            self.line_alignment,
         )
 
     def __eq__(self, other: object) -> bool:
@@ -704,6 +722,7 @@ class Layout:
             and self.alignment == other.alignment
             and self.writing_direction == other.writing_direction
             and self.position_alignment == other.position_alignment
+            and self.line_alignment == other.line_alignment
         )
 
     def __hash__(self):
@@ -714,6 +733,7 @@ class Layout:
             + hash(self.alignment) * 5
             + hash(self.writing_direction) * 19
             + hash(self.position_alignment) * 23
+            + hash(self.line_alignment) * 29
             + 17
         )
 
@@ -735,6 +755,7 @@ class Layout:
             "alignment": self.alignment,
             "writing_direction": self.writing_direction,
             "position_alignment": self.position_alignment,
+            "line_alignment": self.line_alignment,
         }
         for attr_name in ["origin", "extent", "padding"]:
             attr = getattr(self, attr_name)
@@ -786,6 +807,7 @@ class Layout:
             padding=self.padding,
             alignment=self.alignment,
             writing_direction=self.writing_direction,
+            line_alignment=self.line_alignment,
         )
 
     def _resolve_position_alignment(self):

{pycaption-2.3.7 → 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.7 → 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)
@@ -263,7 +269,7 @@ class SAMIReader(BaseReader):
         for style in styles:
             style = style.split(":")
             if len(style) == 2:
-                css_property, value = style
+                css_property, value = style[0].strip(), style[1]
             else:
                 continue
             if css_property == "text-align":

{pycaption-2.3.7 → 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.7 → 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.7 → 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.7 → 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.7 → pycaption-2.3.9}/pycaption/webvtt/constants.py

@@ -6,7 +6,7 @@ docstrings below each pattern explain what they capture and give examples.
 
 import re
 
-from ..geometry import HorizontalAlignmentEnum, PositionAlignmentEnum
+from ..geometry import HorizontalAlignmentEnum, LineAlignmentEnum, PositionAlignmentEnum
 
 TIMING_LINE_PATTERN = re.compile(r"^(\S+)\s+-->\s+(\S+)(?:\s+(.*?))?\s*$")
 """
@@ -60,7 +60,9 @@ Matches individual cue settings from the timing line, including optional
 comma-separated alignment qualifiers per W3C WebVTT spec:
 position:50%  position:50%,line-left  line:80%,center  align:center
 """
-STYLE_SELECTOR_PATTERN = re.compile(r"::cue(?:\((\.?[\w-]+)\))?\s*\{([^}]*)\}")
+STYLE_SELECTOR_PATTERN = re.compile(
+    r"::cue(?:\((\.[\w-]+(?:\.[\w-]+)*|[\w-]+)\))?\s*\{([^}]*)\}"
+)
 """
 Matches ::cue selectors with their declaration blocks:
 ::cue { color: white }           -> group(1)=None
@@ -111,6 +113,13 @@ POSITION_ALIGN_MAP = {
 }
 """Maps WebVTT positionAlign qualifier strings to PositionAlignmentEnum."""
 
+LINE_ALIGN_MAP = {
+    "start": LineAlignmentEnum.START,
+    "center": LineAlignmentEnum.CENTER,
+    "end": LineAlignmentEnum.END,
+}
+"""Maps WebVTT lineAlign qualifier strings to LineAlignmentEnum."""
+
 
 def _is_note_start(line):
     """Return True if the line begins a WebVTT NOTE block."""