pycaption 2.3.7__tar.gz → 2.3.8__tar.gz

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

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

{pycaption-2.3.7 → pycaption-2.3.8}/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.8}/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.8}/pycaption/sami/reader.py

@@ -263,7 +263,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.8}/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."""

{pycaption-2.3.7 → pycaption-2.3.8}/pycaption/webvtt/reader.py

@@ -30,6 +30,7 @@ from .constants import (
     ALIGN_SETTING_MAP,
     CUE_SETTING_PATTERN,
     KNOWN_TAGS,
+    LINE_ALIGN_MAP,
     LINE_GRID_SIZE,
     LINE_HEIGHT_VH,
     POSITION_ALIGN_MAP,
@@ -354,10 +355,35 @@ class WebVTTReader(BaseReader):
         :returns: Caption instance.
         """
         self._close_unclosed_tags(nodes, open_tags)
+        self._adjust_default_line_position(nodes, layout_info)
         caption = Caption(start, end, nodes, layout_info=layout_info)
         self._check_line_overflow(caption)
         return caption
 
+    @staticmethod
+    def _adjust_default_line_position(nodes, layout_info):
+        """Adjust the default origin.y for multi-line cues.
+
+        When position: is set but line: is absent, origin.y defaults to
+        the last grid row. For multi-line cues this would extend beyond
+        the viewport. Push the top edge up by one row per extra line so
+        the bottom line stays at the viewport bottom.
+        """
+        if not layout_info or not layout_info.origin:
+            return
+        if not layout_info.webvtt_positioning:
+            return
+        if "line:" in layout_info.webvtt_positioning:
+            return
+        num_lines = sum(1 for n in nodes if n.type_ == CaptionNode.BREAK) + 1
+        if num_lines <= 1:
+            return
+        adjusted_y = (LINE_GRID_SIZE - num_lines) / LINE_GRID_SIZE * 100
+        layout_info.origin = Point(
+            layout_info.origin.x,
+            Size(max(0, adjusted_y), UnitEnum.PERCENT),
+        )
+
     @staticmethod
     def _check_line_overflow(caption):
         """Emit a CaptionReadWarning if a multiline cue's line:%
@@ -368,6 +394,8 @@ class WebVTTReader(BaseReader):
         layout = caption.layout_info
         if not layout or not layout.origin:
             return
+        if not layout.webvtt_positioning or "line:" not in layout.webvtt_positioning:
+            return
         origin_y = layout.origin.y
         if origin_y is None or origin_y.unit != UnitEnum.PERCENT:
             return
@@ -822,7 +850,7 @@ class WebVTTReader(BaseReader):
         position_value, position_align = WebVTTReader._split_alignment(
             parsed.get("position", "")
         )
-        line_value, _ = WebVTTReader._split_alignment(parsed.get("line", ""))
+        line_value, line_align = WebVTTReader._split_alignment(parsed.get("line", ""))
 
         origin_x = WebVTTReader._parse_percent_value(position_value)
         origin_y = WebVTTReader._parse_line_value(line_value)
@@ -834,11 +862,17 @@ class WebVTTReader(BaseReader):
         pos_alignment = (
             POSITION_ALIGN_MAP.get(position_align) if position_align else None
         )
+        ln_alignment = LINE_ALIGN_MAP.get(line_align) if line_align else None
 
         origin = None
-        if origin_y is not None:
+        if origin_y is not None or origin_x is not None:
             x = origin_x if origin_x is not None else Size(0, UnitEnum.PERCENT)
-            origin = Point(x, origin_y)
+            y = (
+                origin_y
+                if origin_y is not None
+                else Size((LINE_GRID_SIZE - 1) / LINE_GRID_SIZE * 100, UnitEnum.PERCENT)
+            )
+            origin = Point(x, y)
 
         extent = None
         if extent_horizontal is not None:
@@ -850,6 +884,7 @@ class WebVTTReader(BaseReader):
             alignment=alignment,
             writing_direction=writing_direction,
             position_alignment=pos_alignment,
+            line_alignment=ln_alignment,
             webvtt_positioning=cue_settings,
             inherit_from=inherit_from,
         )
@@ -1006,9 +1041,8 @@ class WebVTTReader(BaseReader):
     def _parse_css_declarations(declarations):
         """Parse CSS declaration text into pycaption's style dict.
 
-        Only maps properties pycaption can represent: font-style,
-        font-weight, text-decoration, color, background-color.
-        All other properties are silently ignored.
+        Maps recognized CSS properties to pycaption's internal style dict.
+        Unrecognized properties are silently ignored.
 
         :param declarations: CSS declarations string (between braces).
         :returns: Dict of recognized style properties.
@@ -1034,6 +1068,16 @@ class WebVTTReader(BaseReader):
                 props["color"] = prop_value
             elif prop_name == "background-color":
                 props["background-color"] = prop_value
+            elif prop_name == "font-family":
+                props["font-family"] = prop_value.replace('"', "").replace("'", "")
+            elif prop_name == "font-size":
+                props["font-size"] = prop_value
+            elif prop_name == "text-shadow":
+                props["text-shadow"] = prop_value
+            elif prop_name == "opacity":
+                props["opacity"] = prop_value
+            elif prop_name == "line-height":
+                props["line-height"] = prop_value
 
         return props
 
@@ -1066,8 +1110,8 @@ class WebVTTReader(BaseReader):
     def _apply_cascade(content, styles, base_style):
         """Merge base and class-resolved styles into a node's content dict.
 
-        Resolution order: base (::cue) → each class in order. Existing
-        keys in content are not overwritten (inline > cascade).
+        Resolution order: base (::cue) → single class → compound selectors.
+        Existing keys in content are not overwritten (inline > cascade).
 
         :param content: The STYLE node's content dict (mutated in place).
         :param styles: Full styles dict with class entries.
@@ -1085,6 +1129,12 @@ class WebVTTReader(BaseReader):
             if class_style:
                 resolved.update(class_style)
 
+        if len(classes) > 1:
+            class_set = set(classes)
+            for key, style in styles.items():
+                if "." in key and set(key.split(".")).issubset(class_set):
+                    resolved.update(style)
+
         for key, value in resolved.items():
             if key not in content:
                 content[key] = value
@@ -1108,6 +1158,9 @@ class WebVTTReader(BaseReader):
             "background-color",
             "font-family",
             "font-size",
+            "text-shadow",
+            "opacity",
+            "line-height",
         }
         base_text_props = {
             k: v for k, v in base_style.items() if k in _VISUAL_KEYS and v

{pycaption-2.3.7 → pycaption-2.3.8}/pycaption/webvtt/writer.py

@@ -229,9 +229,17 @@ class WebVTTWriter(BaseWriter):
                 css_prop, css_val = cls._INTERNAL_TO_CSS[k]
                 declarations.append(f"{css_prop}: {css_val}")
             elif k not in cls._INTERNAL_STYLE_KEYS:
+                if k == "font-family":
+                    v = cls._quote_font_family(v)
                 declarations.append(f"{k}: {v}")
         return "; ".join(declarations)
 
+    @staticmethod
+    def _quote_font_family(value):
+        """Re-quote multi-word font names for valid CSS output."""
+        parts = [p.strip() for p in value.split(",")]
+        return ", ".join(f'"{p}"' if " " in p else p for p in parts)
+
     _STYLE_TO_TAG = {
         "italics": ("<i>", "</i>"),
         "underline": ("<u>", "</u>"),
@@ -442,7 +450,10 @@ class WebVTTWriter(BaseWriter):
         if left_offset is not None:
             cue_settings += f" position:{left_offset}"
         if top_offset is not None:
-            cue_settings += f" line:{top_offset}"
+            line_part = f" line:{top_offset}"
+            if layout.line_alignment:
+                line_part += f",{layout.line_alignment.value}"
+            cue_settings += line_part
         if cue_width is not None:
             cue_settings += f" size:{cue_width}"
 

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

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

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

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

{pycaption-2.3.7 → pycaption-2.3.8}/tests/test_dfxp.py

@@ -183,6 +183,7 @@ class TestDFXPReader(ReaderTestingMixIn):
                 (HorizontalAlignmentEnum.START, VerticalAlignmentEnum.BOTTOM),
                 None,
                 None,
+                None,
             ),
             (
                 ((40, UnitEnum.PERCENT), (40, UnitEnum.PERCENT)),
@@ -191,6 +192,7 @@ class TestDFXPReader(ReaderTestingMixIn):
                 (HorizontalAlignmentEnum.START, VerticalAlignmentEnum.BOTTOM),
                 None,
                 None,
+                None,
             ),
             (
                 ((10, UnitEnum.PERCENT), (70, UnitEnum.PERCENT)),
@@ -199,6 +201,7 @@ class TestDFXPReader(ReaderTestingMixIn):
                 (HorizontalAlignmentEnum.START, VerticalAlignmentEnum.BOTTOM),
                 None,
                 None,
+                None,
             ),
         ]
         actual_layouts = [

{pycaption-2.3.7 → pycaption-2.3.8}/tests/test_sami.py

@@ -121,6 +121,22 @@ class TestSAMIReader(ReaderTestingMixIn):
 
         assert caption.layout_info.alignment.horizontal == HorizontalAlignmentEnum.LEFT
 
+    def test_text_align_recognized_after_other_property(self):
+        sami = (
+            '<SAMI><HEAD><STYLE TYPE="Text/css">\n'
+            "P { margin-left: 20px; }\n"
+            ".ENCC { Name: 'Subtitles'; Lang: en-US; SAMIType: CC; }\n"
+            "</STYLE></HEAD><BODY>\n"
+            '<SYNC start="100">\n'
+            '<P class="ENCC" Style="color:white; text-align:right;">'
+            "Hello</P>\n"
+            "</SYNC></BODY></SAMI>"
+        )
+        caption_set = self.reader.read(sami)
+        caption = caption_set.get_captions("en-US")[0]
+
+        assert caption.layout_info.alignment.horizontal == HorizontalAlignmentEnum.RIGHT
+
     def test_sami_including_hexadecimal_charref(
         self, sample_sami_including_hexadecimal_charref
     ):

{pycaption-2.3.7 → pycaption-2.3.8}/tests/test_scc.py

@@ -173,6 +173,7 @@ class TestSCCReader(ReaderTestingMixIn):
                 (HorizontalAlignmentEnum.LEFT, VerticalAlignmentEnum.TOP),
                 None,
                 None,
+                None,
             ),
             (
                 ((10.0, UnitEnum.PERCENT), (83.0, UnitEnum.PERCENT)),
@@ -181,6 +182,7 @@ class TestSCCReader(ReaderTestingMixIn):
                 (HorizontalAlignmentEnum.LEFT, VerticalAlignmentEnum.TOP),
                 None,
                 None,
+                None,
             ),
         ]
 
@@ -199,6 +201,7 @@ class TestSCCReader(ReaderTestingMixIn):
                         (HorizontalAlignmentEnum.LEFT, VerticalAlignmentEnum.TOP),
                         None,
                         None,
+                        None,
                     )
                 ]
             },
@@ -211,6 +214,7 @@ class TestSCCReader(ReaderTestingMixIn):
                         (HorizontalAlignmentEnum.LEFT, VerticalAlignmentEnum.TOP),
                         None,
                         None,
+                        None,
                     )
                 ]
             },

{pycaption-2.3.7 → pycaption-2.3.8}/tests/test_webvtt.py

@@ -10,12 +10,14 @@ from pycaption import (
     DFXPReader,
     DFXPWriter,
     SAMIReader,
+    SAMIWriter,
     WebVTTReader,
     WebVTTWriter,
 )
 from pycaption.base import CaptionNode
 from pycaption.geometry import (
     HorizontalAlignmentEnum,
+    LineAlignmentEnum,
     PositionAlignmentEnum,
     Size,
     UnitEnum,
@@ -781,13 +783,17 @@ class TestWebVTTCueSettingsParsing:
         expected = "position:10% line:80% size:60% align:start"
         assert layout.webvtt_positioning == expected
 
-    def test_position_only_no_origin(self):
+    def test_position_only_uses_default_y(self):
         vtt = "WEBVTT\n\n00:00:01.000 --> 00:00:03.000 position:50%\nHello\n"
         captions = self.reader.read(vtt)
         cue = captions.get_captions("en-US")[0]
         layout = cue.layout_info
 
-        assert layout.origin is None
+        expected_y = (15 - 1) / 15 * 100  # ~93.33%
+        assert layout.origin is not None
+        assert layout.origin.x == Size(50, UnitEnum.PERCENT)
+        assert layout.origin.y.unit == UnitEnum.PERCENT
+        assert abs(layout.origin.y.value - expected_y) < 0.01
         assert layout.webvtt_positioning == "position:50%"
 
     def test_region_with_cue_override(self):
@@ -958,6 +964,90 @@ Hello
         layout = cue.layout_info
 
         assert layout.origin.y == Size(80, UnitEnum.PERCENT)
+        assert layout.line_alignment == LineAlignmentEnum.CENTER
+
+    def test_line_alignment_end_stored(self):
+        vtt = "WEBVTT\n\n00:00:01.000 --> 00:00:03.000 line:80%,end\nHello\n"
+        captions = self.reader.read(vtt)
+        cue = captions.get_captions("en-US")[0]
+
+        assert cue.layout_info.line_alignment == LineAlignmentEnum.END
+
+    def test_line_alignment_none_when_absent(self):
+        vtt = "WEBVTT\n\n00:00:01.000 --> 00:00:03.000 line:80%\nHello\n"
+        captions = self.reader.read(vtt)
+        cue = captions.get_captions("en-US")[0]
+
+        assert cue.layout_info.line_alignment is None
+
+    def test_default_line_adjusts_for_multiline_cue(self):
+        vtt = (
+            "WEBVTT\n\n"
+            "00:00:01.000 --> 00:00:03.000 position:50%\n"
+            "Line one\nLine two\nLine three\n"
+        )
+        captions = self.reader.read(vtt)
+        cue = captions.get_captions("en-US")[0]
+
+        assert cue.layout_info.origin.y == Size(80, UnitEnum.PERCENT)
+
+    def test_default_line_unchanged_for_single_line_cue(self):
+        vtt = "WEBVTT\n\n00:00:01.000 --> 00:00:03.000 position:50%\nHello\n"
+        captions = self.reader.read(vtt)
+        cue = captions.get_captions("en-US")[0]
+
+        assert cue.layout_info.origin.y == Size((14 / 15) * 100, UnitEnum.PERCENT)
+
+    def test_line_only_origin_x_defaults_to_zero(self):
+        vtt = "WEBVTT\n\n00:00:01.000 --> 00:00:03.000 line:80%\nHello\n"
+        captions = self.reader.read(vtt)
+        cue = captions.get_captions("en-US")[0]
+        layout = cue.layout_info
+
+        assert layout.origin is not None
+        assert layout.origin.x == Size(0, UnitEnum.PERCENT)
+        assert layout.origin.y == Size(80, UnitEnum.PERCENT)
+
+    def test_neither_position_nor_line_origin_is_none(self):
+        vtt = "WEBVTT\n\n00:00:01.000 --> 00:00:03.000\nHello\n"
+        captions = self.reader.read(vtt)
+        cue = captions.get_captions("en-US")[0]
+
+        assert cue.layout_info is None or cue.layout_info.origin is None
+
+    def test_position_only_dfxp_output_has_horizontal(self):
+        vtt = "WEBVTT\n\n00:00:01.000 --> 00:00:03.000 position:70%\nHello\n"
+        captions = self.reader.read(vtt)
+        output = DFXPWriter().write(captions)
+
+        assert "70%" in output
+        assert "tts:origin" in output
+
+    def test_position_only_sami_output_has_margin_left(self):
+        vtt = "WEBVTT\n\n00:00:01.000 --> 00:00:03.000 position:70%\nHello\n"
+        captions = self.reader.read(vtt)
+        output = SAMIWriter().write(captions)
+
+        assert "margin-left" in output
+
+    def test_position_only_no_false_overflow_warning(self):
+        vtt = (
+            "WEBVTT\n\n"
+            "00:00:01.000 --> 00:00:03.000 position:70%\n"
+            "Line one\n"
+            "Line two\n"
+        )
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("always")
+            self.reader.read(vtt)
+
+        overflow_warnings = [
+            w
+            for w in caught
+            if issubclass(w.category, CaptionReadWarning)
+            and "extends beyond viewport" in str(w.message)
+        ]
+        assert len(overflow_warnings) == 0
 
 
 class TestWebVTTStyleBlockParsing:
@@ -985,6 +1075,213 @@ class TestWebVTTStyleBlockParsing:
         assert "yellow" in styles
         assert styles["yellow"] == {"color": "yellow", "italics": True}
 
+    def test_font_family_comma_separated_parsed(self):
+        vtt = (
+            "WEBVTT\n\n"
+            "STYLE\n"
+            '::cue { font-family: Arial, "Helvetica Neue", sans-serif }\n\n'
+            "00:00:01.000 --> 00:00:03.000\n"
+            "<c.any>Hello</c>\n"
+        )
+        captions = self.reader.read(vtt)
+        styles = dict(captions.get_styles())
+
+        assert styles["::cue"] == {"font-family": "Arial, Helvetica Neue, sans-serif"}
+
+    def test_quoted_font_family_roundtrips_with_quotes(self):
+        from pycaption import WebVTTWriter
+
+        vtt = (
+            "WEBVTT\n\n"
+            "STYLE\n"
+            '::cue(.fancy) { font-family: "Courier New", monospace }\n\n'
+            "00:00:01.000 --> 00:00:03.000\n"
+            "<c.fancy>Hello</c>\n"
+        )
+        captions = self.reader.read(vtt)
+        result = WebVTTWriter().write(captions)
+
+        assert 'font-family: "Courier New", monospace' in result
+
+    def test_font_size_parsed(self):
+        vtt = (
+            "WEBVTT\n\n"
+            "STYLE\n"
+            "::cue { font-size: 120% }\n\n"
+            "00:00:01.000 --> 00:00:03.000\n"
+            "<c.any>Hello</c>\n"
+        )
+        captions = self.reader.read(vtt)
+        styles = dict(captions.get_styles())
+
+        assert styles["::cue"] == {"font-size": "120%"}
+
+    def test_class_font_properties(self):
+        vtt = (
+            "WEBVTT\n\n"
+            "STYLE\n"
+            "::cue(.custom) { font-family: Arial; font-size: 1.2em }\n\n"
+            "00:00:01.000 --> 00:00:03.000\n"
+            "<c.custom>Hello</c>\n"
+        )
+        captions = self.reader.read(vtt)
+        cue = captions.get_captions("en-US")[0]
+
+        for node in cue.nodes:
+            if node.type_ == CaptionNode.STYLE and node.start:
+                assert node.content["font-family"] == "Arial"
+                assert node.content["font-size"] == "1.2em"
+                break
+
+    def test_text_shadow_parsed(self):
+        vtt = (
+            "WEBVTT\n\n"
+            "STYLE\n"
+            "::cue { text-shadow: 2px 2px 4px black }\n\n"
+            "00:00:01.000 --> 00:00:03.000\n"
+            "<c.any>Hello</c>\n"
+        )
+        captions = self.reader.read(vtt)
+        styles = dict(captions.get_styles())
+
+        assert styles["::cue"] == {"text-shadow": "2px 2px 4px black"}
+
+    def test_opacity_parsed(self):
+        vtt = (
+            "WEBVTT\n\n"
+            "STYLE\n"
+            "::cue { opacity: 0.8 }\n\n"
+            "00:00:01.000 --> 00:00:03.000\n"
+            "<c.any>Hello</c>\n"
+        )
+        captions = self.reader.read(vtt)
+        styles = dict(captions.get_styles())
+
+        assert styles["::cue"] == {"opacity": "0.8"}
+
+    def test_line_height_parsed(self):
+        vtt = (
+            "WEBVTT\n\n"
+            "STYLE\n"
+            "::cue { line-height: 1.5 }\n\n"
+            "00:00:01.000 --> 00:00:03.000\n"
+            "<c.any>Hello</c>\n"
+        )
+        captions = self.reader.read(vtt)
+        styles = dict(captions.get_styles())
+
+        assert styles["::cue"] == {"line-height": "1.5"}
+
+    def test_compound_selector_parsed(self):
+        vtt = (
+            "WEBVTT\n\n"
+            "STYLE\n"
+            "::cue(.bold.yellow) { color: yellow }\n\n"
+            "00:00:01.000 --> 00:00:03.000\n"
+            "<c.bold.yellow>Hello</c>\n"
+        )
+        captions = self.reader.read(vtt)
+        styles = dict(captions.get_styles())
+
+        assert "bold.yellow" in styles
+        assert styles["bold.yellow"] == {"color": "yellow"}
+
+    def test_compound_selector_cascades_to_span(self):
+        vtt = (
+            "WEBVTT\n\n"
+            "STYLE\n"
+            "::cue(.bold.yellow) { color: yellow }\n\n"
+            "00:00:01.000 --> 00:00:03.000\n"
+            "<c.bold.yellow>Hello</c>\n"
+        )
+        captions = self.reader.read(vtt)
+        cue = captions.get_captions("en-US")[0]
+
+        for node in cue.nodes:
+            if node.type_ == CaptionNode.STYLE and node.start:
+                assert node.content.get("color") == "yellow"
+                break
+
+    def test_compound_selector_no_partial_match(self):
+        vtt = (
+            "WEBVTT\n\n"
+            "STYLE\n"
+            "::cue(.bold.yellow) { color: yellow }\n\n"
+            "00:00:01.000 --> 00:00:03.000\n"
+            "<c.bold>Hello</c>\n"
+        )
+        captions = self.reader.read(vtt)
+        cue = captions.get_captions("en-US")[0]
+
+        for node in cue.nodes:
+            if node.type_ == CaptionNode.STYLE and node.start:
+                assert "color" not in node.content
+                break
+
+    def test_compound_selector_vtt_roundtrip(self):
+        from pycaption import WebVTTWriter
+
+        vtt = (
+            "WEBVTT\n\n"
+            "STYLE\n"
+            "::cue(.bold.yellow) { color: yellow }\n\n"
+            "00:00:01.000 --> 00:00:03.000\n"
+            "<c.bold.yellow>Hello</c>\n"
+        )
+        captions = self.reader.read(vtt)
+        result = WebVTTWriter().write(captions)
+
+        assert "::cue(.bold.yellow)" in result
+
+    def test_compound_selector_three_classes(self):
+        vtt = (
+            "WEBVTT\n\n"
+            "STYLE\n"
+            "::cue(.a.b.c) { color: red }\n\n"
+            "00:00:01.000 --> 00:00:03.000\n"
+            "<c.a.b.c>Hello</c>\n"
+        )
+        captions = self.reader.read(vtt)
+        cue = captions.get_captions("en-US")[0]
+
+        for node in cue.nodes:
+            if node.type_ == CaptionNode.STYLE and node.start:
+                assert node.content.get("color") == "red"
+                break
+
+    def test_compound_selector_superset_span(self):
+        vtt = (
+            "WEBVTT\n\n"
+            "STYLE\n"
+            "::cue(.bold.yellow) { color: gold }\n\n"
+            "00:00:01.000 --> 00:00:03.000\n"
+            "<c.bold.yellow.italic>Hello</c>\n"
+        )
+        captions = self.reader.read(vtt)
+        cue = captions.get_captions("en-US")[0]
+
+        for node in cue.nodes:
+            if node.type_ == CaptionNode.STYLE and node.start:
+                assert node.content.get("color") == "gold"
+                break
+
+    def test_compound_selector_overrides_single(self):
+        vtt = (
+            "WEBVTT\n\n"
+            "STYLE\n"
+            "::cue(.bold) { color: white }\n"
+            "::cue(.bold.yellow) { color: gold }\n\n"
+            "00:00:01.000 --> 00:00:03.000\n"
+            "<c.bold.yellow>Hello</c>\n"
+        )
+        captions = self.reader.read(vtt)
+        cue = captions.get_captions("en-US")[0]
+
+        for node in cue.nodes:
+            if node.type_ == CaptionNode.STYLE and node.start:
+                assert node.content.get("color") == "gold"
+                break
+
     def test_cascade_specificity(self, sample_webvtt_with_style_block_cascade):
         captions = self.reader.read(sample_webvtt_with_style_block_cascade)
         cue = captions.get_captions("en-US")[0]

{pycaption-2.3.7 → pycaption-2.3.8}/tests/test_webvtt_conversion.py

@@ -303,6 +303,32 @@ class TestWebVTTCueSettingsConversion:
 
         assert "position:50% line:80% align:center" in result
 
+    def test_line_alignment_center_to_dfxp(self):
+        vtt = "WEBVTT\n\n" "00:00:01.000 --> 00:00:03.000 line:50%,center\n" "Hello\n"
+        caption_set = WebVTTReader().read(vtt)
+        result = DFXPWriter().write(caption_set)
+
+        assert 'tts:displayAlign="center"' in result
+
+    def test_line_alignment_vtt_non_passthrough_roundtrip(self):
+        vtt = "WEBVTT\n\n" "00:00:01.000 --> 00:00:03.000 line:80%,center\n" "Hello\n"
+        caption_set = WebVTTReader().read(vtt)
+        for caption in caption_set.get_captions("en-US"):
+            caption.layout_info.webvtt_positioning = None
+        result = WebVTTWriter().write(caption_set)
+
+        assert "line:80%,center" in result
+
+    def test_line_alignment_absent_no_qualifier_in_vtt_output(self):
+        vtt = "WEBVTT\n\n" "00:00:01.000 --> 00:00:03.000 line:80%\n" "Hello\n"
+        caption_set = WebVTTReader().read(vtt)
+        for caption in caption_set.get_captions("en-US"):
+            caption.layout_info.webvtt_positioning = None
+        result = WebVTTWriter().write(caption_set)
+
+        assert "line:80%" in result
+        assert "line:80%," not in result
+
     def test_style_block_to_sami_no_invalid_selector(self):
         vtt = (
             "WEBVTT\n\n"
@@ -537,6 +563,113 @@ class TestWebVTTtoDFXPStyles:
 
         assert 'tts:textDecoration="underline"' in result
 
+    def test_font_family_to_dfxp(self):
+        vtt = (
+            "WEBVTT\n\n"
+            "STYLE\n"
+            "::cue(.fancy) { font-family: Arial }\n\n"
+            "00:00:01.000 --> 00:00:03.000\n"
+            "<c.fancy>Hello styled</c>\n"
+        )
+        caption_set = WebVTTReader().read(vtt)
+        result = DFXPWriter().write(caption_set)
+
+        assert 'tts:fontFamily="Arial"' in result
+
+    def test_quoted_font_family_to_valid_dfxp(self):
+        vtt = (
+            "WEBVTT\n\n"
+            "STYLE\n"
+            '::cue(.fancy) { font-family: "Helvetica Neue", Arial, sans-serif }\n\n'
+            "00:00:01.000 --> 00:00:03.000\n"
+            "<c.fancy>Hello styled</c>\n"
+        )
+        caption_set = WebVTTReader().read(vtt)
+        result = DFXPWriter().write(caption_set)
+
+        assert 'tts:fontFamily="Helvetica Neue, Arial, sans-serif"' in result
+        from lxml import etree
+
+        etree.fromstring(result.encode("utf-8"))
+
+    def test_font_size_to_dfxp(self):
+        vtt = (
+            "WEBVTT\n\n"
+            "STYLE\n"
+            "::cue(.big) { font-size: 120% }\n\n"
+            "00:00:01.000 --> 00:00:03.000\n"
+            "<c.big>Hello styled</c>\n"
+        )
+        caption_set = WebVTTReader().read(vtt)
+        result = DFXPWriter().write(caption_set)
+
+        assert 'tts:fontSize="120%"' in result
+
+    def test_text_shadow_to_dfxp(self):
+        vtt = (
+            "WEBVTT\n\n"
+            "STYLE\n"
+            "::cue(.shadow) { text-shadow: 2px 2px 4px black }\n\n"
+            "00:00:01.000 --> 00:00:03.000\n"
+            "<c.shadow>Hello styled</c>\n"
+        )
+        caption_set = WebVTTReader().read(vtt)
+        result = DFXPWriter().write(caption_set)
+
+        assert 'tts:textOutline="black 4px"' in result
+
+    def test_text_shadow_no_blur_to_dfxp(self):
+        vtt = (
+            "WEBVTT\n\n"
+            "STYLE\n"
+            "::cue(.shadow) { text-shadow: 1px 1px black }\n\n"
+            "00:00:01.000 --> 00:00:03.000\n"
+            "<c.shadow>Hello styled</c>\n"
+        )
+        caption_set = WebVTTReader().read(vtt)
+        result = DFXPWriter().write(caption_set)
+
+        assert 'tts:textOutline="black 1px"' in result
+
+    def test_opacity_to_dfxp(self):
+        vtt = (
+            "WEBVTT\n\n"
+            "STYLE\n"
+            "::cue(.faded) { opacity: 0.8 }\n\n"
+            "00:00:01.000 --> 00:00:03.000\n"
+            "<c.faded>Hello styled</c>\n"
+        )
+        caption_set = WebVTTReader().read(vtt)
+        result = DFXPWriter().write(caption_set)
+
+        assert 'tts:opacity="0.8"' in result
+
+    def test_line_height_to_dfxp(self):
+        vtt = (
+            "WEBVTT\n\n"
+            "STYLE\n"
+            "::cue(.spaced) { line-height: 1.5 }\n\n"
+            "00:00:01.000 --> 00:00:03.000\n"
+            "<c.spaced>Hello styled</c>\n"
+        )
+        caption_set = WebVTTReader().read(vtt)
+        result = DFXPWriter().write(caption_set)
+
+        assert 'tts:lineHeight="1.5"' in result
+
+    def test_compound_selector_to_dfxp(self):
+        vtt = (
+            "WEBVTT\n\n"
+            "STYLE\n"
+            "::cue(.bold.yellow) { color: yellow }\n\n"
+            "00:00:01.000 --> 00:00:03.000\n"
+            "<c.bold.yellow>Hello styled</c>\n"
+        )
+        caption_set = WebVTTReader().read(vtt)
+        result = DFXPWriter().write(caption_set)
+
+        assert 'tts:color="yellow"' in result
+
     def test_classes_not_in_dfxp_output(self):
         from lxml import etree