tag. Technically, this step shouldn't be
# skipped, but it would make the reader read in O(n^2) (half an hour
# for 1500 timed captions)
- if element.name not in ('div', 'body', 'tt'):
+ if element.name not in ("div", "body", "tt"):
for style in element.contents:
- if getattr(style, 'name', None) == 'style':
+ if getattr(style, "name", None) == "style":
nested_styles.extend(
cls._get_style_reference_chain(style, styling_section)
)
- referenced_style_id = element.get('style')
+ referenced_style_id = element.get("style")
referenced_styles = []
if referenced_style_id and styling_section:
referenced_style = styling_section.findChild(
- 'style', {'xml:id': referenced_style_id}
+ "style", {"xml:id": referenced_style_id}
)
referenced_styles = cls._get_style_reference_chain(
@@ -786,12 +814,10 @@ def _get_style_reference_chain(cls, style, styling_tag):
if not styling_tag:
return result
- reference = style.get('style')
+ reference = style.get("style")
if reference:
- referenced_styles = styling_tag.findChildren(
- 'style', {'xml:id': reference}
- )
+ referenced_styles = styling_tag.findChildren("style", {"xml:id": reference})
if len(referenced_styles) == 1:
return result + cls._get_style_reference_chain(
@@ -827,47 +853,49 @@ def scrape_positioning_info(self, element=None, even_invalid=False):
"""
usable_elem = element if even_invalid else None
- origin = self._find_attribute(
- usable_elem, 'tts:origin', Point.from_xml_attribute, ['auto']
- ) or DFXP_DEFAULT_REGION.origin
+ origin = (
+ self._find_attribute(
+ usable_elem, "tts:origin", Point.from_xml_attribute, ["auto"]
+ )
+ or DFXP_DEFAULT_REGION.origin
+ )
extent = self._find_attribute(
- usable_elem, 'tts:extent', Stretch.from_xml_attribute, ['auto'])
+ usable_elem, "tts:extent", Stretch.from_xml_attribute, ["auto"]
+ )
if not extent:
extent = self._find_root_extent() or DFXP_DEFAULT_REGION.extent
- padding = self._find_attribute(
- usable_elem, 'tts:padding', Padding.from_xml_attribute
- ) or DFXP_DEFAULT_REGION.padding
+ padding = (
+ self._find_attribute(usable_elem, "tts:padding", Padding.from_xml_attribute)
+ or DFXP_DEFAULT_REGION.padding
+ )
# tts:textAlign is a special attribute, which can not be ignored when
# specified on the element itself (only
nodes matter)
# On elements like it is also read, because this was legacy
# behavior.
- if getattr(element, 'name', None) in ('span', 'p'):
+ if getattr(element, "name", None) in ("span", "p"):
text_align_source = element
else:
text_align_source = None
- text_align = (
- self._find_attribute(text_align_source, 'tts:textAlign')
- or _create_external_horizontal_alignment(
+ text_align = self._find_attribute(
+ text_align_source, "tts:textAlign"
+ ) or _create_external_horizontal_alignment(
DFXP_DEFAULT_REGION.alignment.horizontal
)
- )
- display_align = (
- self._find_attribute(usable_elem, 'tts:displayAlign')
- or _create_external_vertical_alignment(
- DFXP_DEFAULT_REGION.alignment.vertical
- )
- )
+ display_align = self._find_attribute(
+ usable_elem, "tts:displayAlign"
+ ) or _create_external_vertical_alignment(DFXP_DEFAULT_REGION.alignment.vertical)
alignment = _create_internal_alignment(text_align, display_align)
return origin, extent, padding, alignment
- def _find_attribute_on_element_or_styles(self, attribute_name, element,
- factory, ignore, ignorecase):
+ def _find_attribute_on_element_or_styles(
+ self, attribute_name, element, factory, ignore, ignorecase
+ ):
"""Look up the given attribute on the element, and all the styles
referenced by it.
@@ -886,8 +914,7 @@ def _find_attribute_on_element_or_styles(self, attribute_name, element,
)
if value is None:
# Does a referenced style of the element have it?
- for style in self._get_style_sources(
- self._styling_section, element):
+ for style in self._get_style_sources(self._styling_section, element):
value = _get_object_from_attribute(
style, attribute_name, factory, ignore, ignorecase
)
@@ -895,8 +922,9 @@ def _find_attribute_on_element_or_styles(self, attribute_name, element,
break
return value
- def _find_attribute(self, element, attribute_name, factory=lambda x: x,
- ignore=(), ignorecase=True):
+ def _find_attribute(
+ self, element, attribute_name, factory=lambda x: x, ignore=(), ignorecase=True
+ ):
"""Try to find the `attribute_name` specified on the element, all its
parents and all their styles (and referenced styles).
@@ -918,7 +946,8 @@ def _find_attribute(self, element, attribute_name, factory=lambda x: x,
# Does the element itself have it inline, or any of its styles?
if element:
value = self._find_attribute_on_element_or_styles(
- attribute_name, element, factory, ignore, ignorecase)
+ attribute_name, element, factory, ignore, ignorecase
+ )
if value is None:
# Do any of the element's parents have the attribute?
@@ -952,7 +981,7 @@ def _find_root_extent(self):
if extent is None:
root = self.root_element
extent = _get_object_from_attribute(
- root, 'tts:extent', Stretch.from_xml_attribute
+ root, "tts:extent", Stretch.from_xml_attribute
)
if extent is not None:
@@ -1047,15 +1076,18 @@ def _create_unique_regions(unique_layouts, dfxp, id_factory):
:rtype: dict
"""
region_map = {}
- layout_section = dfxp.find('layout')
+ layout_section = dfxp.find("layout")
for region_spec in unique_layouts:
if (
- region_spec.origin or region_spec.extent
- or region_spec.padding or region_spec.alignment):
- new_region = dfxp.new_tag('region')
+ region_spec.origin
+ or region_spec.extent
+ or region_spec.padding
+ or region_spec.alignment
+ ):
+ new_region = dfxp.new_tag("region")
new_id = id_factory()
- new_region['xml:id'] = new_id
+ new_region["xml:id"] = new_id
region_map[region_spec] = new_id
region_attribs = _convert_layout_to_attributes(region_spec)
@@ -1071,29 +1103,31 @@ def create_document_regions(self):
"""
# Creates the default region
default_region_map = self._create_unique_regions(
- [DFXP_DEFAULT_REGION],
- self._dfxp, lambda: DFXP_DEFAULT_REGION_ID
+ [DFXP_DEFAULT_REGION], self._dfxp, lambda: DFXP_DEFAULT_REGION_ID
)
unique_regions = self._collect_unique_regions(
- self._caption_set, DFXP_DEFAULT_REGION)
+ self._caption_set, DFXP_DEFAULT_REGION
+ )
# Create the document specified regions
self._region_map = self._create_unique_regions(
- unique_regions, self._dfxp, self._get_new_id)
+ unique_regions, self._dfxp, self._get_new_id
+ )
self._region_map.update(default_region_map)
- def _get_new_id(self, prefix='r'):
+ def _get_new_id(self, prefix="r"):
"""Return new, unique ids (use an internal counter).
:type prefix: str
"""
- new_id = f'{prefix}{self._id_seed}'
+ new_id = f"{prefix}{self._id_seed}"
self._id_seed += 1
return new_id
def get_positioning_info(
- self, lang, caption_set=None, caption=None, caption_node=None):
+ self, lang, caption_set=None, caption=None, caption_node=None
+ ):
"""For the given element will return a valid region ID, used for
assigning to the element, and a dict containing the positioning
attributes of that region (useful for inline non-standard positioning)
@@ -1147,37 +1181,37 @@ def get_positioning_info(
def cleanup_regions(self):
"""Remove the unused regions from the output file"""
- layout_tag = self._dfxp.find('layout')
+ layout_tag = self._dfxp.find("layout")
if not layout_tag:
return
- regions = layout_tag.findChildren('region')
+ regions = layout_tag.findChildren("region")
if not regions:
return
for region in regions:
- if region.attrs.get('xml:id') not in self._assigned_region_ids:
+ if region.attrs.get("xml:id") not in self._assigned_region_ids:
region.extract()
def _recreate_style(content, dfxp):
dfxp_style = {}
- if 'class' in content:
- if dfxp.find("style", {"xml:id": content['class']}):
- dfxp_style['style'] = content['class']
- if 'text-align' in content:
- dfxp_style['tts:textAlign'] = content['text-align']
- if 'italics' in content:
- dfxp_style['tts:fontStyle'] = 'italic'
- if 'font-family' in content:
- dfxp_style['tts:fontFamily'] = content['font-family']
- if 'font-size' in content:
- dfxp_style['tts:fontSize'] = content['font-size']
- if 'color' in content:
- dfxp_style['tts:color'] = content['color']
- if 'display-align' in content:
- dfxp_style['tts:displayAlign'] = content['display-align']
+ if "class" in content:
+ if dfxp.find("style", {"xml:id": content["class"]}):
+ dfxp_style["style"] = content["class"]
+ if "text-align" in content:
+ dfxp_style["tts:textAlign"] = content["text-align"]
+ if "italics" in content:
+ dfxp_style["tts:fontStyle"] = "italic"
+ if "font-family" in content:
+ dfxp_style["tts:fontFamily"] = content["font-family"]
+ if "font-size" in content:
+ dfxp_style["tts:fontSize"] = content["font-size"]
+ if "color" in content:
+ dfxp_style["tts:color"] = content["color"]
+ if "display-align" in content:
+ dfxp_style["tts:displayAlign"] = content["display-align"]
return dfxp_style
@@ -1204,8 +1238,7 @@ def _create_internal_alignment(text_align, display_align):
if not (text_align or display_align):
return None
- return Alignment.from_horizontal_and_vertical_align(
- text_align, display_align)
+ return Alignment.from_horizontal_and_vertical_align(text_align, display_align)
def _create_external_horizontal_alignment(horizontal_component):
@@ -1218,15 +1251,15 @@ def _create_external_horizontal_alignment(horizontal_component):
result = None
if horizontal_component == HorizontalAlignmentEnum.LEFT:
- result = 'left'
+ result = "left"
if horizontal_component == HorizontalAlignmentEnum.CENTER:
- result = 'center'
+ result = "center"
if horizontal_component == HorizontalAlignmentEnum.RIGHT:
- result = 'right'
+ result = "right"
if horizontal_component == HorizontalAlignmentEnum.START:
- result = 'start'
+ result = "start"
if horizontal_component == HorizontalAlignmentEnum.END:
- result = 'end'
+ result = "end"
return result
@@ -1241,11 +1274,11 @@ def _create_external_vertical_alignment(vertical_component):
result = None
if vertical_component == VerticalAlignmentEnum.TOP:
- result = 'before'
+ result = "before"
if vertical_component == VerticalAlignmentEnum.CENTER:
- result = 'center'
+ result = "center"
if vertical_component == VerticalAlignmentEnum.BOTTOM:
- result = 'after'
+ result = "after"
return result
@@ -1265,21 +1298,20 @@ def _create_external_alignment(alignment):
if not (alignment.horizontal or alignment.vertical):
return result
- horizontal_alignment = _create_external_horizontal_alignment(
- alignment.horizontal)
+ horizontal_alignment = _create_external_horizontal_alignment(alignment.horizontal)
if horizontal_alignment:
- result['tts:textAlign'] = horizontal_alignment
+ result["tts:textAlign"] = horizontal_alignment
- vertical_alignment = _create_external_vertical_alignment(
- alignment.vertical)
+ vertical_alignment = _create_external_vertical_alignment(alignment.vertical)
if vertical_alignment:
- result['tts:displayAlign'] = vertical_alignment
+ result["tts:displayAlign"] = vertical_alignment
return result
-def _get_object_from_attribute(tag, attr_name, factory,
- ignore_vals=(), ignorecase=True):
+def _get_object_from_attribute(
+ tag, attr_name, factory, ignore_vals=(), ignorecase=True
+):
"""For the xml `tag`, tries to retrieve the attribute `attr_name` and
pass that to the factory in order to get a result. If the value of the
attribute is in the `ignore_vals` iterable, returns None.
@@ -1291,7 +1323,7 @@ def _get_object_from_attribute(tag, attr_name, factory,
:param ignore_vals: iterable of attribute values to ignore
:raise CaptionReadSyntaxError: if the attribute has some crazy value
"""
- if not hasattr(tag, 'has_attr'):
+ if not hasattr(tag, "has_attr"):
return
attr_value = None
@@ -1329,13 +1361,13 @@ def _convert_layout_to_attributes(layout):
return _create_external_alignment(DFXP_DEFAULT_REGION.alignment)
if layout.origin:
- result['tts:origin'] = layout.origin.to_xml_attribute()
+ result["tts:origin"] = layout.origin.to_xml_attribute()
if layout.extent:
- result['tts:extent'] = layout.extent.to_xml_attribute()
+ result["tts:extent"] = layout.extent.to_xml_attribute()
if layout.padding:
- result['tts:padding'] = layout.padding.to_xml_attribute()
+ result["tts:padding"] = layout.padding.to_xml_attribute()
if layout.alignment:
result.update(_create_external_alignment(layout.alignment))
diff --git a/pycaption/dfxp/extras.py b/pycaption/dfxp/extras.py
index 70a60c82..dfc4fa7f 100644
--- a/pycaption/dfxp/extras.py
+++ b/pycaption/dfxp/extras.py
@@ -6,10 +6,10 @@
from bs4 import BeautifulSoup
-from .base import DFXPWriter, DFXP_DEFAULT_REGION
from ..base import BaseWriter, CaptionNode, merge_concurrent_captions
+from .base import DFXP_DEFAULT_REGION, DFXPWriter
-LEGACY_DFXP_BASE_MARKUP = '''
+LEGACY_DFXP_BASE_MARKUP = """
@@ -18,33 +18,30 @@
-'''
+"""
LEGACY_DFXP_DEFAULT_STYLE = {
- 'color': 'white',
- 'font-family': 'monospace',
- 'font-size': '1c',
+ "color": "white",
+ "font-family": "monospace",
+ "font-size": "1c",
}
-LEGACY_DFXP_DEFAULT_STYLE_ID = 'default'
-LEGACY_DFXP_DEFAULT_REGION_ID = 'bottom'
+LEGACY_DFXP_DEFAULT_STYLE_ID = "default"
+LEGACY_DFXP_DEFAULT_REGION_ID = "bottom"
-LEGACY_DFXP_DEFAULT_REGION = {
- 'text-align': 'center',
- 'display-align': 'after'
-}
+LEGACY_DFXP_DEFAULT_REGION = {"text-align": "center", "display-align": "after"}
class SinglePositioningDFXPWriter(DFXPWriter):
"""
A dfxp writer, that ignores all positioning, using a single provided value
"""
- def __init__(self, default_positioning=DFXP_DEFAULT_REGION,
- *args, **kwargs):
+
+ def __init__(self, default_positioning=DFXP_DEFAULT_REGION, *args, **kwargs):
super().__init__(*args, **kwargs)
self.default_positioning = default_positioning
- def write(self, captions_set, force=''):
+ def write(self, captions_set, force=""):
"""Writes a DFXP file using the positioning provided in the initializer
:type captions_set: pycaption.base.CaptionSet
@@ -52,7 +49,8 @@ def write(self, captions_set, force=''):
:rtype: str
"""
captions_set = self._create_single_positioning_caption_set(
- captions_set, self.default_positioning)
+ captions_set, self.default_positioning
+ )
return super().write(captions_set, force) # noqa
@@ -80,42 +78,45 @@ def _create_single_positioning_caption_set(caption_set, positioning):
caption.layout_info = positioning
for node in caption.nodes:
- if hasattr(node, 'layout_info'):
+ if hasattr(node, "layout_info"):
node.layout_info = positioning
for _, style in caption_set.get_styles():
- if 'text-align' in style:
- style.pop('text-align')
+ if "text-align" in style:
+ style.pop("text-align")
return caption_set
class LegacyDFXPWriter(BaseWriter):
"""Ported the legacy DFXPWriter from 0.4.5"""
+
def __init__(self, *args, **kw):
self.p_style = False
self.open_span = False
- def write(self, caption_set, force=''):
+ def write(self, caption_set, force=""):
caption_set = deepcopy(caption_set)
caption_set = merge_concurrent_captions(caption_set)
- dfxp = BeautifulSoup(LEGACY_DFXP_BASE_MARKUP, 'lxml-xml')
- dfxp.find('tt')['xml:lang'] = "en"
+ dfxp = BeautifulSoup(LEGACY_DFXP_BASE_MARKUP, "lxml-xml")
+ dfxp.find("tt")["xml:lang"] = "en"
for style_id, style in caption_set.get_styles():
if style != {}:
dfxp = self._recreate_styling_tag(style_id, style, dfxp)
if not caption_set.get_styles():
dfxp = self._recreate_styling_tag(
- LEGACY_DFXP_DEFAULT_STYLE_ID, LEGACY_DFXP_DEFAULT_STYLE, dfxp)
+ LEGACY_DFXP_DEFAULT_STYLE_ID, LEGACY_DFXP_DEFAULT_STYLE, dfxp
+ )
# XXX For now we will always use this default region. In the future if
# regions are provided, they will be kept
dfxp = self._recreate_region_tag(
- LEGACY_DFXP_DEFAULT_REGION_ID, LEGACY_DFXP_DEFAULT_REGION, dfxp)
+ LEGACY_DFXP_DEFAULT_REGION_ID, LEGACY_DFXP_DEFAULT_REGION, dfxp
+ )
- body = dfxp.find('body')
+ body = dfxp.find("body")
if force:
langs = [self._force_language(force, caption_set.get_languages())]
@@ -123,17 +124,18 @@ def write(self, caption_set, force=''):
langs = caption_set.get_languages()
for lang in langs:
- div = dfxp.new_tag('div')
- div['xml:lang'] = lang
+ div = dfxp.new_tag("div")
+ div["xml:lang"] = lang
for caption in caption_set.get_captions(lang):
if caption.style:
caption_style = caption.style
- caption_style.update(
- {'region': LEGACY_DFXP_DEFAULT_REGION_ID})
+ caption_style.update({"region": LEGACY_DFXP_DEFAULT_REGION_ID})
else:
- caption_style = {'class': LEGACY_DFXP_DEFAULT_STYLE_ID,
- 'region': LEGACY_DFXP_DEFAULT_REGION_ID}
+ caption_style = {
+ "class": LEGACY_DFXP_DEFAULT_STYLE_ID,
+ "region": LEGACY_DFXP_DEFAULT_REGION_ID,
+ }
p = self._recreate_p_tag(caption, caption_style, dfxp)
div.append(p)
@@ -151,29 +153,29 @@ def _force_language(self, force, langs):
return langs[-1]
def _recreate_region_tag(self, region_id, styling, dfxp):
- dfxp_region = dfxp.new_tag('region')
- dfxp_region.attrs.update({'xml:id': region_id})
+ dfxp_region = dfxp.new_tag("region")
+ dfxp_region.attrs.update({"xml:id": region_id})
attributes = self._recreate_style(styling, dfxp)
dfxp_region.attrs.update(attributes)
- new_tag = dfxp.new_tag('region')
- new_tag.attrs.update({'xml:id': region_id})
+ new_tag = dfxp.new_tag("region")
+ new_tag.attrs.update({"xml:id": region_id})
if dfxp_region != new_tag:
- dfxp.find('layout').append(dfxp_region)
+ dfxp.find("layout").append(dfxp_region)
return dfxp
def _recreate_styling_tag(self, style, content, dfxp):
- dfxp_style = dfxp.new_tag('style')
- dfxp_style.attrs.update({'xml:id': style})
+ dfxp_style = dfxp.new_tag("style")
+ dfxp_style.attrs.update({"xml:id": style})
attributes = self._recreate_style(content, dfxp)
dfxp_style.attrs.update(attributes)
- new_tag = dfxp.new_tag('style')
- new_tag.attrs.update({'xml:id': style})
+ new_tag = dfxp.new_tag("style")
+ new_tag.attrs.update({"xml:id": style})
if dfxp_style != new_tag:
- dfxp.find('styling').append(dfxp_style)
+ dfxp.find("styling").append(dfxp_style)
return dfxp
@@ -184,21 +186,21 @@ def _recreate_p_tag(self, caption, caption_style, dfxp):
p.string = self._recreate_text(caption, dfxp)
if dfxp.find("style", {"xml:id": "p"}):
- p['style'] = 'p'
+ p["style"] = "p"
p.attrs.update(self._recreate_style(caption_style, dfxp))
return p
def _recreate_text(self, caption, dfxp):
- line = ''
+ line = ""
for node in caption.nodes:
if node.type_ == CaptionNode.TEXT:
- line += escape(node.content) + ' '
+ line += escape(node.content) + " "
elif node.type_ == CaptionNode.BREAK:
- line = line.rstrip() + '
\n '
+ line = line.rstrip() + "
\n "
elif node.type_ == CaptionNode.STYLE:
line = self._recreate_span(line, node, dfxp)
@@ -207,7 +209,7 @@ def _recreate_text(self, caption, dfxp):
def _recreate_span(self, line, node, dfxp):
if node.start:
- styles = ''
+ styles = ""
content_with_style = self._recreate_style(node.content, dfxp)
for style, value in list(content_with_style.items()):
@@ -215,12 +217,12 @@ def _recreate_span(self, line, node, dfxp):
if styles:
if self.open_span:
- line = line.rstrip() + ' '
- line += f''
+ line = line.rstrip() + " "
+ line += f""
self.open_span = True
elif self.open_span:
- line = line.rstrip() + ' '
+ line = line.rstrip() + " "
self.open_span = False
return line
@@ -228,23 +230,23 @@ def _recreate_span(self, line, node, dfxp):
def _recreate_style(self, content, dfxp):
dfxp_style = {}
- if 'region' in content:
- if dfxp.find('region', {'xml:id': content['region']}):
- dfxp_style['region'] = content['region']
- if 'class' in content:
- if dfxp.find("style", {"xml:id": content['class']}):
- dfxp_style['style'] = content['class']
- if 'text-align' in content:
- dfxp_style['tts:textAlign'] = content['text-align']
- if 'italics' in content:
- dfxp_style['tts:fontStyle'] = 'italic'
- if 'font-family' in content:
- dfxp_style['tts:fontFamily'] = content['font-family']
- if 'font-size' in content:
- dfxp_style['tts:fontSize'] = content['font-size']
- if 'color' in content:
- dfxp_style['tts:color'] = content['color']
- if 'display-align' in content:
- dfxp_style['tts:displayAlign'] = content['display-align']
+ if "region" in content:
+ if dfxp.find("region", {"xml:id": content["region"]}):
+ dfxp_style["region"] = content["region"]
+ if "class" in content:
+ if dfxp.find("style", {"xml:id": content["class"]}):
+ dfxp_style["style"] = content["class"]
+ if "text-align" in content:
+ dfxp_style["tts:textAlign"] = content["text-align"]
+ if "italics" in content:
+ dfxp_style["tts:fontStyle"] = "italic"
+ if "font-family" in content:
+ dfxp_style["tts:fontFamily"] = content["font-family"]
+ if "font-size" in content:
+ dfxp_style["tts:fontSize"] = content["font-size"]
+ if "color" in content:
+ dfxp_style["tts:color"] = content["color"]
+ if "display-align" in content:
+ dfxp_style["tts:displayAlign"] = content["display-align"]
return dfxp_style
diff --git a/pycaption/exceptions.py b/pycaption/exceptions.py
index 0474c05d..7afcf2f3 100644
--- a/pycaption/exceptions.py
+++ b/pycaption/exceptions.py
@@ -2,8 +2,9 @@ class CaptionReadError(Exception):
"""
Generic error raised when the reading of the caption file failed.
"""
+
def __str__(self):
- return f'{self.__class__.__name__}({self.args[0]})'
+ return f"{self.__class__.__name__}({self.args[0]})"
class CaptionReadNoCaptions(CaptionReadError):
diff --git a/pycaption/geometry.py b/pycaption/geometry.py
index f5cc8b07..b6375ac4 100644
--- a/pycaption/geometry.py
+++ b/pycaption/geometry.py
@@ -10,7 +10,7 @@
import re
from enum import Enum
-from .exceptions import RelativizationError, CaptionReadSyntaxError
+from .exceptions import CaptionReadSyntaxError, RelativizationError
class UnitEnum(Enum):
@@ -22,11 +22,12 @@ class UnitEnum(Enum):
if unit == UnitEnum.CELL :
...
"""
- PIXEL = 'px'
- EM = 'em'
- PERCENT = '%'
- CELL = 'c'
- PT = 'pt'
+
+ PIXEL = "px"
+ EM = "em"
+ PERCENT = "%"
+ CELL = "c"
+ PT = "pt"
class VerticalAlignmentEnum(Enum):
@@ -37,18 +38,20 @@ class VerticalAlignmentEnum(Enum):
if alignment == VerticalAlignmentEnum.BOTTOM:
...
"""
- TOP = 'top'
- CENTER = 'center'
- BOTTOM = 'bottom'
+
+ TOP = "top"
+ CENTER = "center"
+ BOTTOM = "bottom"
class HorizontalAlignmentEnum(Enum):
"""Enumeration object specifying the horizontal alignment preferences"""
- LEFT = 'left'
- CENTER = 'center'
- RIGHT = 'right'
- START = 'start'
- END = 'end'
+
+ LEFT = "left"
+ CENTER = "center"
+ RIGHT = "right"
+ START = "start"
+ END = "end"
class Alignment:
@@ -63,11 +66,7 @@ def __init__(self, horizontal, vertical):
self.vertical = vertical
def __hash__(self):
- return hash(
- hash(self.horizontal) * 83
- + hash(self.vertical) * 89
- + 97
- )
+ return hash(hash(self.horizontal) * 83 + hash(self.vertical) * 89 + 97)
def __eq__(self, other):
return (
@@ -85,27 +84,26 @@ def serialized(self):
return self.horizontal, self.vertical
@classmethod
- def from_horizontal_and_vertical_align(cls, text_align=None,
- display_align=None):
+ def from_horizontal_and_vertical_align(cls, text_align=None, display_align=None):
horizontal_obj = None
vertical_obj = None
- if text_align == 'left':
+ if text_align == "left":
horizontal_obj = HorizontalAlignmentEnum.LEFT
- if text_align == 'start':
+ if text_align == "start":
horizontal_obj = HorizontalAlignmentEnum.START
- if text_align == 'center':
+ if text_align == "center":
horizontal_obj = HorizontalAlignmentEnum.CENTER
- if text_align == 'right':
+ if text_align == "right":
horizontal_obj = HorizontalAlignmentEnum.RIGHT
- if text_align == 'end':
+ if text_align == "end":
horizontal_obj = HorizontalAlignmentEnum.END
- if display_align == 'before':
+ if display_align == "before":
vertical_obj = VerticalAlignmentEnum.TOP
- if display_align == 'center':
+ if display_align == "center":
vertical_obj = VerticalAlignmentEnum.CENTER
- if display_align == 'after':
+ if display_align == "after":
vertical_obj = VerticalAlignmentEnum.BOTTOM
if not any([horizontal_obj, vertical_obj]):
@@ -125,7 +123,7 @@ def from_xml_attribute(cls, attribute):
:type attribute: str
"""
- horizontal, vertical = attribute.split(' ')
+ horizontal, vertical = attribute.split(" ")
horizontal = Size.from_string(horizontal)
vertical = Size.from_string(vertical)
@@ -146,8 +144,8 @@ def __init__(self, horizontal, vertical):
"""
for parameter in [horizontal, vertical]:
if not isinstance(parameter, Size):
- raise ValueError("Stretch must be initialized with two valid "
- "Size objects.")
+ raise ValueError("Stretch must be initialized with two valid "
+ "Size objects.")
self.horizontal = horizontal
self.vertical = vertical
@@ -158,18 +156,17 @@ def is_measured_in(self, measure_unit):
:return: True/False
"""
return (
- self.horizontal.unit == measure_unit
- and self.vertical.unit == measure_unit
+ self.horizontal.unit == measure_unit and self.vertical.unit == measure_unit
)
def __repr__(self):
- return f''
+ return f""
def serialized(self):
"""Returns a tuple of the useful attributes of this object"""
return (
None if not self.horizontal else self.horizontal.serialized(),
- None if not self.vertical else self.vertical.serialized()
+ None if not self.vertical else self.vertical.serialized(),
)
def __eq__(self, other):
@@ -181,20 +178,16 @@ def __eq__(self, other):
)
def __hash__(self):
- return hash(
- hash(self.horizontal) * 59
- + hash(self.vertical) * 61
- + 67
- )
+ return hash(hash(self.horizontal) * 59 + hash(self.vertical) * 61 + 67)
def __bool__(self):
return True if self.horizontal or self.vertical else False
def to_xml_attribute(self, **kwargs):
"""Returns a string representation of this object as an xml attribute"""
- return '{horizontal} {vertical}'.format(
+ return "{horizontal} {vertical}".format(
horizontal=self.horizontal.to_xml_attribute(),
- vertical=self.vertical.to_xml_attribute()
+ vertical=self.vertical.to_xml_attribute(),
)
def is_relative(self):
@@ -215,7 +208,7 @@ def as_percentage_of(self, video_width, video_height):
"""
return Stretch(
self.horizontal.as_percentage_of(video_width=video_width),
- self.vertical.as_percentage_of(video_height=video_height)
+ self.vertical.as_percentage_of(video_height=video_height),
)
@@ -256,7 +249,7 @@ def from_extent(cls, extent, origin):
@property
def extent(self):
"""How wide this rectangle stretches (horizontally and vertically)"""
- if hasattr(self, '_extent'):
+ if hasattr(self, "_extent"):
return self._extent
else:
return self._p1 - self._p2
@@ -264,7 +257,7 @@ def extent(self):
@property
def origin(self):
"""Out of its 4 points, returns the one closest to the origin"""
- if hasattr(self, '_origin'):
+ if hasattr(self, "_origin"):
return self._origin
else:
return Point.align_from_origin(self._p1, self._p2)[0]
@@ -274,7 +267,7 @@ def origin(self):
@property
def lower_right_point(self):
"""The point furthest from the origin from the rectangle's 4 points"""
- if hasattr(self, '_p2'):
+ if hasattr(self, "_p2"):
return Point.align_from_origin(self._p1, self._p2)[1]
else:
return self.origin.add_extent(self.extent)
@@ -288,11 +281,7 @@ def __eq__(self, other):
)
def __hash__(self):
- return hash(
- hash(self.origin) * 71
- + hash(self.extent) * 73
- + 79
- )
+ return hash(hash(self.origin) * 71 + hash(self.extent) * 73 + 79)
class Point(TwoDimensionalObject):
@@ -305,14 +294,13 @@ def __init__(self, x, y):
"""
for parameter in [x, y]:
if not isinstance(parameter, Size):
- raise ValueError("Point must be initialized with two valid "
+ raise ValueError("Point must be initialized with two valid "
"Size objects.")
self.x = x
self.y = y
def __sub__(self, other):
- """Returns an Stretch object, if the other point's units are compatible
- """
+ """Returns an Stretch object, if the other point's units are compatible"""
return Stretch(abs(self.x - other.x), abs(self.y - other.y))
def add_stretch(self, stretch):
@@ -339,7 +327,7 @@ def as_percentage_of(self, video_width, video_height):
"""
return Point(
self.x.as_percentage_of(video_width=video_width),
- self.y.as_percentage_of(video_height=video_height)
+ self.y.as_percentage_of(video_height=video_height),
)
@classmethod
@@ -355,17 +343,19 @@ def align_from_origin(cls, p1, p2):
if p1.x >= p2.x and p1.y >= p2.y:
return p2
else:
- return (Point(min(p1.x, p2.x), min(p1.y, p2.y)),
- Point(max(p1.x, p2.x), max(p1.y, p2.y)))
+ return (
+ Point(min(p1.x, p2.x), min(p1.y, p2.y)),
+ Point(max(p1.x, p2.x), max(p1.y, p2.y)),
+ )
def __repr__(self):
- return f''
+ return f""
def serialized(self):
"""Returns the "useful" values of this object."""
return (
None if not self.x else self.x.serialized(),
- None if not self.y else self.y.serialized()
+ None if not self.y else self.y.serialized(),
)
def __eq__(self, other):
@@ -377,18 +367,14 @@ def __eq__(self, other):
)
def __hash__(self):
- return hash(
- hash(self.x) * 51
- + hash(self.y) * 53
- + 57
- )
+ return hash(hash(self.x) * 51 + hash(self.y) * 53 + 57)
def __bool__(self):
return True if self.x or self.y else False
def to_xml_attribute(self, **kwargs):
"""Returns a string representation of this object as an xml attribute"""
- return f'{self.x.to_xml_attribute()} {self.y.to_xml_attribute()}'
+ return f"{self.x.to_xml_attribute()} {self.y.to_xml_attribute()}"
class Size:
@@ -455,12 +441,14 @@ def as_percentage_of(self, video_width=None, video_height=None):
# The input must be valid so that any conversion can be done
if not (video_width or video_height):
raise RelativizationError(
- "At least one of video width or height"
- " must be given as a reference")
+ "At least one of video width or height"
+ " must be given as a reference"
+ )
elif video_width and video_height:
raise RelativizationError(
"Only one of video width or height can be given as reference"
- " per value being converted")
+ " per value being converted"
+ )
if unit == UnitEnum.EM:
# TODO: Implement proper conversion of em in function of font-size
@@ -504,13 +492,15 @@ def from_string(cls, string):
"""
size_pattern = re.compile(
r"^(((?P\d+(\.\d+)?)(?P"
- fr"{'|'.join([unit.value for unit in UnitEnum])}))|0)$")
+ rf"{'|'.join([unit.value for unit in UnitEnum])}))|0)$"
+ )
match = size_pattern.search(string)
if not match:
raise CaptionReadSyntaxError(
f"Invalid size: {string}. Please make sure the provided value "
"is a number followed by one of the supported units: "
- f"{', '.join([unit.value for unit in UnitEnum])}.")
+ f"{', '.join([unit.value for unit in UnitEnum])}."
+ )
unit = match.group("unit")
if unit:
value = match.group("value")
@@ -520,19 +510,18 @@ def from_string(cls, string):
return cls(match.group(0), UnitEnum.PIXEL)
def __repr__(self):
- return f''
+ return f""
def __str__(self):
value = round(self.value, 2)
if value.is_integer():
s = f"{int(value)}"
else:
- s = f"{value:.2f}".rstrip('0').rstrip('.')
+ s = f"{value:.2f}".rstrip("0").rstrip(".")
return f"{s}{self.unit.value}"
def to_xml_attribute(self, **kwargs):
- """Returns a string representation of this object, as an xml attribute
- """
+ """Returns a string representation of this object, as an xml attribute"""
return str(self)
def serialized(self):
@@ -548,11 +537,7 @@ def __eq__(self, other):
)
def __hash__(self):
- return hash(
- hash(self.value) * 41
- + hash(self.unit) * 43
- + 47
- )
+ return hash(hash(self.value) * 41 + hash(self.unit) * 43 + 47)
def __bool__(self):
return self.unit in UnitEnum and self.value is not None
@@ -579,7 +564,7 @@ def __init__(self, before=None, after=None, start=None, end=None):
self.start = start # left
self.end = end # right
- for attr in ['before', 'after', 'start', 'end']:
+ for attr in ["before", "after", "start", "end"]:
# Ensure that a Padding object always explicitly defines all
# four possible paddings
if not isinstance(getattr(self, attr), Size):
@@ -600,7 +585,7 @@ def from_xml_attribute(cls, attribute):
:param attribute: a string like object, representing a dfxp attr. value
:return: a Padding object
"""
- values_list = attribute.split(' ')
+ values_list = attribute.split(" ")
sizes = []
for value in values_list:
@@ -615,11 +600,13 @@ def from_xml_attribute(cls, attribute):
elif len(sizes) == 4:
return cls(sizes[0], sizes[2], sizes[3], sizes[1])
else:
- raise ValueError(f'The provided value "{attribute}" could not be '
- "parsed into the a padding. Check out "
- "http://www.w3.org/TR/ttaf1-dfxp/"
- "#style-attribute-padding for the definition "
- "and examples")
+ raise ValueError(
+ f'The provided value "{attribute}" could not be '
+ "parsed into the a padding. Check out "
+ "http://www.w3.org/TR/ttaf1-dfxp/"
+ "#style-attribute-padding for the definition "
+ "and examples"
+ )
def __repr__(self):
return (
@@ -633,7 +620,7 @@ def serialized(self):
None if not self.before else self.before.serialized(),
None if not self.after else self.after.serialized(),
None if not self.start else self.start.serialized(),
- None if not self.end else self.end.serialized()
+ None if not self.end else self.end.serialized(),
)
def __eq__(self, other):
@@ -656,8 +643,8 @@ def __hash__(self):
)
def to_xml_attribute(
- self, attribute_order=('before', 'end', 'after', 'start'),
- **kwargs):
+ self, attribute_order=("before", "end", "after", "start"), **kwargs
+ ):
"""Returns a string representation of this object as an xml attribute
TODO - should extend the attribute_order tuple to contain 4 tuples,
@@ -671,22 +658,21 @@ def to_xml_attribute(
string_list = []
for attrib in attribute_order:
if hasattr(self, attrib):
- string_list.append(
- getattr(self, attrib).to_xml_attribute())
+ string_list.append(getattr(self, attrib).to_xml_attribute())
except AttributeError:
# A Padding object with attributes set to None is considered
# invalid. All four possible paddings must be set. If one of them
# is not, this error is raised.
raise ValueError("The attribute order specified is invalid.")
- return ' '.join(string_list)
+ return " ".join(string_list)
def as_percentage_of(self, video_width, video_height):
return Padding(
self.before.as_percentage_of(video_height=video_height),
self.after.as_percentage_of(video_height=video_height),
self.start.as_percentage_of(video_width=video_width),
- self.end.as_percentage_of(video_width=video_width)
+ self.end.as_percentage_of(video_width=video_width),
)
def is_relative(self):
@@ -710,8 +696,15 @@ class Layout:
specific for each caption type.
"""
- def __init__(self, origin=None, extent=None, padding=None, alignment=None,
- webvtt_positioning=None, inherit_from=None):
+ def __init__(
+ self,
+ origin=None,
+ extent=None,
+ padding=None,
+ alignment=None,
+ webvtt_positioning=None,
+ inherit_from=None,
+ ):
"""
:type origin: Point
:param origin: The point on the screen which is the top left vertex
@@ -745,16 +738,21 @@ def __init__(self, origin=None, extent=None, padding=None, alignment=None,
self.webvtt_positioning = webvtt_positioning
if inherit_from:
- for attr_name in ['origin', 'extent', 'padding', 'alignment']:
+ for attr_name in ["origin", "extent", "padding", "alignment"]:
attr = getattr(self, attr_name)
if not attr:
setattr(self, attr_name, getattr(inherit_from, attr_name))
def __bool__(self):
- return any([
- self.origin, self.extent, self.padding, self.alignment,
- self.webvtt_positioning
- ])
+ return any(
+ [
+ self.origin,
+ self.extent,
+ self.padding,
+ self.alignment,
+ self.webvtt_positioning,
+ ]
+ )
def __repr__(self):
return (
@@ -768,7 +766,7 @@ def serialized(self):
None if not self.origin else self.origin.serialized(),
None if not self.extent else self.extent.serialized(),
None if not self.padding else self.padding.serialized(),
- None if not self.alignment else self.alignment.serialized()
+ None if not self.alignment else self.alignment.serialized(),
)
def __eq__(self, other):
@@ -807,16 +805,15 @@ def is_relative(self):
return is_relative
def as_percentage_of(self, video_width, video_height):
- params = {'alignment': self.alignment}
+ params = {"alignment": self.alignment}
# We don't need to preserve webvtt_positioning on Layout
# transformations because, if it is set, the WebVTT writer
# returns as soon as it's found and the transformations are
# never triggered.
- for attr_name in ['origin', 'extent', 'padding']:
+ for attr_name in ["origin", "extent", "padding"]:
attr = getattr(self, attr_name)
if attr:
- params[attr_name] = attr.as_percentage_of(video_width,
- video_height)
+ params[attr_name] = attr.as_percentage_of(video_width, video_height)
return Layout(**params)
def fit_to_screen(self):
@@ -853,8 +850,10 @@ def fit_to_screen(self):
found_absolute_unit = True
if found_absolute_unit:
- raise ValueError("Units must be relativized before extent "
- "can be calculated based on origin.")
+ raise ValueError(
+ "Units must be relativized before extent "
+ "can be calculated based on origin."
+ )
new_horizontal = self.extent.horizontal
new_vertical = self.extent.vertical
diff --git a/pycaption/microdvd.py b/pycaption/microdvd.py
index 6c31ca15..e0564225 100644
--- a/pycaption/microdvd.py
+++ b/pycaption/microdvd.py
@@ -2,11 +2,18 @@
from copy import deepcopy
from .base import (
- BaseReader, BaseWriter, CaptionSet, CaptionList, Caption, CaptionNode,
DEFAULT_LANGUAGE_CODE,
+ BaseReader,
+ BaseWriter,
+ Caption,
+ CaptionList,
+ CaptionNode,
+ CaptionSet,
)
from .exceptions import (
- CaptionReadNoCaptions, CaptionReadSyntaxError, CaptionReadTimingError,
+ CaptionReadNoCaptions,
+ CaptionReadSyntaxError,
+ CaptionReadTimingError,
InvalidInputError,
)
@@ -17,7 +24,7 @@ def detect(self, content):
def read(self, content, lang=DEFAULT_LANGUAGE_CODE):
if not isinstance(content, str):
- raise InvalidInputError('The content is not a unicode string.')
+ raise InvalidInputError("The content is not a unicode string.")
lines = content.splitlines()
captions = CaptionList()
@@ -28,26 +35,24 @@ def read(self, content, lang=DEFAULT_LANGUAGE_CODE):
m = re.match(r"{(\d+)}{(\d+)}(.*)", line)
if not m:
- raise CaptionReadSyntaxError(
- "Line does not match expected format")
+ raise CaptionReadSyntaxError("Line does not match expected format")
start, end, txt = m.groups()
- if start == '0' and end == '0':
+ if start == "0" and end == "0":
try:
fps = float(txt)
continue
except ValueError:
- raise CaptionReadTimingError(
- 'FPS information is not provided')
+ raise CaptionReadTimingError("FPS information is not provided")
caption_start = self._framestomicro(int(start), fps)
caption_end = self._framestomicro(int(end), fps)
nodes = []
- for line in txt.split('|'):
+ for line in txt.split("|"):
# skip extra blank lines
- if line != '':
+ if line != "":
nodes.append(CaptionNode.create_text(line))
nodes.append(CaptionNode.create_break())
@@ -67,7 +72,7 @@ def read(self, content, lang=DEFAULT_LANGUAGE_CODE):
return caption_set
def _framestomicro(self, framenum, fps=25.0):
- return int(framenum / fps * (10 ** 6))
+ return int(framenum / fps * (10**6))
class MicroDVDWriter(BaseWriter):
@@ -77,34 +82,32 @@ def write(self, caption_set):
captions = []
for lang in caption_set.get_languages():
- captions.append(
- self._recreate_lang(caption_set.get_captions(lang))
- )
+ captions.append(self._recreate_lang(caption_set.get_captions(lang)))
- return ''.join(captions)
+ return "".join(captions)
def _microtoframes(self, micro, fps=25.0):
- return int(micro * fps / (10 ** 6))
+ return int(micro * fps / (10**6))
def _recreate_lang(self, captions):
- sub = ''
+ sub = ""
for caption in captions:
start = self._microtoframes(caption.start)
end = self._microtoframes(caption.end)
- sub += f'{{{start}}}{{{end}}}'
+ sub += f"{{{start}}}{{{end}}}"
- new_content = ''
+ new_content = ""
for node in caption.nodes:
new_content = self._recreate_line(new_content, node)
# Eliminate excessive line breaks
- new_content = new_content.strip() + '\n'
- while '\n\n' in new_content:
- new_content = new_content.replace('\n\n', '\n')
+ new_content = new_content.strip() + "\n"
+ while "\n\n" in new_content:
+ new_content = new_content.replace("\n\n", "\n")
# Break unnecessary on last line
- while '|\n' in new_content:
- new_content = new_content.replace('|\n', '\n')
+ while "|\n" in new_content:
+ new_content = new_content.replace("|\n", "\n")
sub += new_content
@@ -114,6 +117,6 @@ def _recreate_line(self, sub, line):
if line.type_ == CaptionNode.TEXT:
return sub + line.content
elif line.type_ == CaptionNode.BREAK:
- return sub + '|'
+ return sub + "|"
else:
return sub
diff --git a/pycaption/sami.py b/pycaption/sami.py
index b310bbcc..69fcf8fe 100644
--- a/pycaption/sami.py
+++ b/pycaption/sami.py
@@ -36,37 +36,45 @@
"""
import re
-from xml.dom import SyntaxErr
from collections import deque
from copy import deepcopy
from html.entities import name2codepoint
from html.parser import HTMLParser
from logging import FATAL
+from xml.dom import SyntaxErr
from xml.sax.saxutils import escape
from bs4 import BeautifulSoup, NavigableString
-from cssutils import parseString, log, css as cssutils_css
+from cssutils import css as cssutils_css
+from cssutils import log, parseString
from .base import (
- BaseReader, BaseWriter, CaptionSet, CaptionList, Caption, CaptionNode,
DEFAULT_LANGUAGE_CODE,
+ BaseReader,
+ BaseWriter,
+ Caption,
+ CaptionList,
+ CaptionNode,
+ CaptionSet,
)
from .exceptions import (
- CaptionReadNoCaptions, CaptionReadSyntaxError, InvalidInputError,
- CaptionReadTimingError
+ CaptionReadNoCaptions,
+ CaptionReadSyntaxError,
+ CaptionReadTimingError,
+ InvalidInputError,
)
-from .geometry import Layout, Alignment, Padding, Size
+from .geometry import Alignment, Layout, Padding, Size
# change cssutils default logging
log.setLevel(FATAL)
-SAMI_BASE_MARKUP = '''
+SAMI_BASE_MARKUP = """
-'''
+"""
class SAMIReader(BaseReader):
@@ -76,43 +84,37 @@ def __init__(self, *args, **kw):
self.first_alignment = None
def detect(self, content):
- if ' tags
- global_layout = self._build_layout(doc_styles.get('p', {}))
+ global_layout = self._build_layout(doc_styles.get("p", {}))
caption_dict = {}
for language in doc_langs:
lang_layout = None
for target, styling in list(doc_styles.items()):
- if target not in ['p', 'sync', 'span']:
- if styling.get('lang', None) == language:
+ if target not in ["p", "sync", "span"]:
+ if styling.get("lang", None) == language:
lang_layout = self._build_layout(
- doc_styles.get(target, {}),
- inherit_from=global_layout
+ doc_styles.get(target, {}), inherit_from=global_layout
)
break
lang_layout = lang_layout or global_layout
- lang_captions = self._translate_lang(
- language, sami_soup, lang_layout)
+ lang_captions = self._translate_lang(language, sami_soup, lang_layout)
caption_dict[language] = lang_captions
- caption_set = CaptionSet(
- caption_dict,
- layout_info=global_layout
- )
+ caption_set = CaptionSet(caption_dict, layout_info=global_layout)
# Convert styles from CSS to internal representation
for style in list(doc_styles.items()):
@@ -146,14 +148,14 @@ def _build_layout(self, styles, inherit_from=None):
something.
"""
alignment = Alignment.from_horizontal_and_vertical_align(
- text_align=styles.get('text-align')
+ text_align=styles.get("text-align")
)
return self._get_layout_class()(
origin=None,
extent=None,
padding=self._get_padding(styles),
alignment=alignment,
- inherit_from=inherit_from
+ inherit_from=inherit_from,
)
@staticmethod
@@ -162,17 +164,17 @@ def _get_layout_class():
return Layout
def _get_padding(self, styles):
- margin_before = self._get_size(styles, 'margin-top')
- margin_after = self._get_size(styles, 'margin-bottom')
- margin_start = self._get_size(styles, 'margin-left')
- margin_end = self._get_size(styles, 'margin-right')
+ margin_before = self._get_size(styles, "margin-top")
+ margin_after = self._get_size(styles, "margin-bottom")
+ margin_start = self._get_size(styles, "margin-left")
+ margin_end = self._get_size(styles, "margin-right")
if not any([margin_before, margin_after, margin_start, margin_end]):
return None
return Padding(
before=margin_before, # top
after=margin_after, # bottom
start=margin_start, # left
- end=margin_end # right
+ end=margin_end, # right
)
def _get_size(self, styles, style_label):
@@ -191,11 +193,12 @@ def _translate_lang(self, language, sami_soup, parent_layout):
captions = CaptionList(layout_info=parent_layout)
milliseconds = 0
- for p in sami_soup.select(f'p[lang|={language}]'):
- start_str = p.parent.get('start')
+ for p in sami_soup.select(f"p[lang|={language}]"):
+ start_str = p.parent.get("start")
if not start_str:
raise CaptionReadTimingError(
- f"Missing start time on the following line: {p.parent}.")
+ f"Missing start time on the following line: {p.parent}."
+ )
milliseconds = int(float(start_str))
start = milliseconds * 1000
end = 0
@@ -211,19 +214,16 @@ def _translate_lang(self, language, sami_soup, parent_layout):
if p.get_text().strip():
self.first_alignment = None
styles = self._translate_attrs(p)
- layout_info = self._build_layout(styles,
- inherit_from=parent_layout)
+ layout_info = self._build_layout(styles, inherit_from=parent_layout)
self.line = []
self._translate_tag(p, layout_info)
caption_layout = self._get_layout_class()(
- alignment=self.first_alignment,
- inherit_from=layout_info
+ alignment=self.first_alignment, inherit_from=layout_info
)
for node in self.line:
node.layout_info = Layout(
- alignment=self.first_alignment,
- inherit_from=node.layout_info
+ alignment=self.first_alignment, inherit_from=node.layout_info
)
self.first_alignment = None
@@ -237,12 +237,12 @@ def _translate_lang(self, language, sami_soup, parent_layout):
return captions
def _get_style_name_from_tag(self, tag):
- if tag == 'i':
- return 'italics'
- elif tag == 'b':
- return 'bold'
- elif tag == 'u':
- return 'underline'
+ if tag == "i":
+ return "italics"
+ elif tag == "b":
+ return "bold"
+ elif tag == "u":
+ return "underline"
def _translate_tag(self, tag, inherit_from=None):
"""
@@ -262,20 +262,17 @@ def _translate_tag(self, tag, inherit_from=None):
tag_text = result.groups()[0]
self.line.append(CaptionNode.create_text(tag_text, inherit_from))
# convert line breaks
- elif tag.name == 'br':
+ elif tag.name == "br":
self.line.append(CaptionNode.create_break(inherit_from))
# convert italics, bold, and underline
- elif tag.name == 'i' or tag.name == 'b' or tag.name == 'u':
+ elif tag.name == "i" or tag.name == "b" or tag.name == "u":
style_name = self._get_style_name_from_tag(tag.name)
- self.line.append(
- CaptionNode.create_style(True, {style_name: True})
- )
+ self.line.append(CaptionNode.create_style(True, {style_name: True}))
# recursively call function for any children elements
for a in tag.contents:
self._translate_tag(a, inherit_from)
- self.line.append(
- CaptionNode.create_style(False, {style_name: True}))
- elif tag.name == 'span':
+ self.line.append(CaptionNode.create_style(False, {style_name: True}))
+ elif tag.name == "span":
self._translate_span(tag, inherit_from)
else:
# recursively call function for any children elements
@@ -307,12 +304,12 @@ def _translate_attrs(self, tag):
attrs = {}
css_attrs = tag.attrs
- if 'class' in css_attrs:
- attrs['class'] = css_attrs['class'][0].lower()
- if 'id' in css_attrs:
- attrs['class'] = css_attrs['id'].lower()
- if 'style' in css_attrs:
- styles = css_attrs['style'].split(';')
+ if "class" in css_attrs:
+ attrs["class"] = css_attrs["class"][0].lower()
+ if "id" in css_attrs:
+ attrs["class"] = css_attrs["id"].lower()
+ if "style" in css_attrs:
+ styles = css_attrs["style"].split(";")
attrs.update(self._translate_style(attrs, styles))
return attrs
@@ -320,12 +317,12 @@ def _translate_attrs(self, tag):
# convert attributes from inline CSS
def _translate_style(self, attrs, styles):
for style in styles:
- style = style.split(':')
+ style = style.split(":")
if len(style) == 2:
css_property, value = style
else:
continue
- if css_property == 'text-align':
+ if css_property == "text-align":
self._save_first_alignment(value.strip())
else:
self._translate_css_property(attrs, css_property, value)
@@ -342,20 +339,20 @@ def _translate_parsed_style(self, styles):
return attrs
def _translate_css_property(self, attrs, css_property, value):
- if css_property == 'font-family':
- attrs['font-family'] = value.strip()
- elif css_property == 'font-size':
- attrs['font-size'] = value.strip()
- elif css_property == 'font-style' and value.strip() == 'italic':
- attrs['italics'] = True
- elif css_property == 'text-decoration' and value.strip() == 'underline':
- attrs['underline'] = True
- elif css_property == 'font-weight' and value.strip() == 'bold':
- attrs['bold'] = True
- elif css_property == 'lang':
- attrs['lang'] = value.strip()
- elif css_property == 'color':
- attrs['color'] = value.strip()
+ if css_property == "font-family":
+ attrs["font-family"] = value.strip()
+ elif css_property == "font-size":
+ attrs["font-size"] = value.strip()
+ elif css_property == "font-style" and value.strip() == "italic":
+ attrs["italics"] = True
+ elif css_property == "text-decoration" and value.strip() == "underline":
+ attrs["underline"] = True
+ elif css_property == "font-weight" and value.strip() == "bold":
+ attrs["bold"] = True
+ elif css_property == "lang":
+ attrs["lang"] = value.strip()
+ elif css_property == "color":
+ attrs["color"] = value.strip()
def _save_first_alignment(self, align):
"""
@@ -376,8 +373,9 @@ def _save_first_alignment(self, align):
:param align: A unicode string representing a CSS text-align value
"""
if not self.first_alignment:
- self.first_alignment = \
- Alignment.from_horizontal_and_vertical_align(text_align=align)
+ self.first_alignment = Alignment.from_horizontal_and_vertical_align(
+ text_align=align
+ )
class SAMIWriter(BaseWriter):
@@ -391,7 +389,8 @@ def write(self, caption_set):
sami = BeautifulSoup(SAMI_BASE_MARKUP, "lxml-xml")
caption_set.layout_info = self._relativize_and_fit_to_screen(
- caption_set.layout_info)
+ caption_set.layout_info
+ )
primary = None
@@ -402,26 +401,26 @@ def write(self, caption_set):
caption_set.set_layout_info(
lang,
- self._relativize_and_fit_to_screen(
- caption_set.get_layout_info(lang))
+ self._relativize_and_fit_to_screen(caption_set.get_layout_info(lang)),
)
for caption in caption_set.get_captions(lang):
# Loop through all captions/nodes and apply transformations to
# layout in function of the provided or default settings
caption.layout_info = self._relativize_and_fit_to_screen(
- caption.layout_info)
+ caption.layout_info
+ )
for node in caption.nodes:
node.layout_info = self._relativize_and_fit_to_screen(
- node.layout_info)
- sami = self._recreate_p_tag(
- caption, sami, lang, primary, caption_set)
+ node.layout_info
+ )
+ sami = self._recreate_p_tag(caption, sami, lang, primary, caption_set)
stylesheet = self._recreate_stylesheet(caption_set)
- sami.find('style').append(stylesheet)
+ sami.find("style").append(stylesheet)
- a = sami.prettify(formatter=None).split('\n')
- caption_content = '\n'.join(a[1:])
+ a = sami.prettify(formatter=None).split("\n")
+ caption_content = "\n".join(a[1:])
return caption_content
def _recreate_p_tag(self, caption, sami, lang, primary, captions):
@@ -440,8 +439,7 @@ def _recreate_p_tag(self, caption, sami, lang, primary, captions):
time = caption.start // 1000
if self.last_time and time != self.last_time:
- sami = self._recreate_blank_tag(
- sami, caption, lang, primary, captions)
+ sami = self._recreate_blank_tag(sami, caption, lang, primary, captions)
self.last_time = caption.end // 1000
@@ -449,13 +447,13 @@ def _recreate_p_tag(self, caption, sami, lang, primary, captions):
p = sami.new_tag("p")
- p_style = ''
+ p_style = ""
for attr, value in list(self._recreate_style(caption.style).items()):
- p_style += f'{attr}:{value};'
+ p_style += f"{attr}:{value};"
if p_style:
- p['p_style'] = p_style
+ p["p_style"] = p_style
- p['class'] = self._recreate_p_lang(caption, lang, captions)
+ p["class"] = self._recreate_p_lang(caption, lang, captions)
p.string = self._recreate_text(caption.nodes)
sync.append(p)
@@ -503,8 +501,8 @@ def _recreate_blank_tag(self, sami, caption, lang, primary, captions):
sami, sync = self._recreate_sync(sami, lang, primary, self.last_time)
p = sami.new_tag("p")
- p['class'] = self._recreate_p_lang(caption, lang, captions)
- p.string = ' '
+ p["class"] = self._recreate_p_lang(caption, lang, captions)
+ p.string = " "
sync.append(p)
@@ -512,27 +510,29 @@ def _recreate_blank_tag(self, sami, caption, lang, primary, captions):
def _recreate_p_lang(self, caption, lang, captions):
try:
- if 'lang' in captions.get_style(caption.style['class']):
- return caption.style['class']
+ if "lang" in captions.get_style(caption.style["class"]):
+ return caption.style["class"]
except KeyError:
pass
return lang
def _recreate_stylesheet(self, caption_set):
- stylesheet = ''
+ return stylesheet + " -->"
def _recreate_style_block(self, target, rules, layout_info):
"""
@@ -543,35 +543,37 @@ def _recreate_style_block(self, target, rules, layout_info):
:param layout_info: A Layout object providing positioning information
to be converted to CSS
"""
- if target not in ['p', 'sync', 'span']:
+ if target not in ["p", "sync", "span"]:
# If it's not a valid SAMI element, then it's a custom class name
- selector = f'.{target}'
+ selector = f".{target}"
else:
selector = target
- sami_style = f'\n {selector} {{\n '
+ sami_style = f"\n {selector} {{\n "
if layout_info and layout_info.padding:
- rules.update({
- 'margin-top': str(layout_info.padding.before),
- 'margin-right': str(layout_info.padding.end),
- 'margin-bottom': str(layout_info.padding.after),
- 'margin-left': str(layout_info.padding.start),
- })
+ rules.update(
+ {
+ "margin-top": str(layout_info.padding.before),
+ "margin-right": str(layout_info.padding.end),
+ "margin-bottom": str(layout_info.padding.after),
+ "margin-left": str(layout_info.padding.start),
+ }
+ )
for attr, value in sorted(self._recreate_style(rules).items()):
- sami_style += f' {attr}: {value};\n '
+ sami_style += f" {attr}: {value};\n "
- return sami_style + '}\n'
+ return sami_style + "}\n"
def _recreate_text(self, caption):
- line = ''
+ line = ""
for node in caption:
if node.type_ == CaptionNode.TEXT:
- line += self._encode(node.content) + ' '
+ line += self._encode(node.content) + " "
elif node.type_ == CaptionNode.BREAK:
- line = line.rstrip() + '
\n '
+ line = line.rstrip() + "
\n "
elif node.type_ == CaptionNode.STYLE:
line = self._recreate_line_style(line, node)
@@ -580,28 +582,28 @@ def _recreate_text(self, caption):
def _recreate_line_style(self, line, node):
if node.start:
if self.open_span:
- line = line.rstrip() + ' '
+ line = line.rstrip() + " "
line = self._recreate_span(line, node.content)
else:
if self.open_span:
- line = line.rstrip() + ' '
+ line = line.rstrip() + " "
self.open_span = False
return line
def _recreate_span(self, line, content):
- style = ''
- klass = ''
- if 'class' in content:
+ style = ""
+ klass = ""
+ if "class" in content:
klass += f' class="{content["class"]}"'
for attr, value in list(self._recreate_style(content).items()):
- style += f'{attr}:{value};'
+ style += f"{attr}:{value};"
if style or klass:
if style:
style = f' style="{style}"'
- line += f''
+ line += f""
self.open_span = True
return line
@@ -614,12 +616,12 @@ def _recreate_style(self, rules):
for key, value in list(rules.items()):
# Recreate original CSS rules from internal style
- if key == 'italics' and value is True:
- sami_style['font-style'] = 'italic'
- elif key == 'bold' and value is True:
- sami_style['font-weight'] = 'bold'
- elif key == 'underline' and value is True:
- sami_style['text-decoration'] = 'underline'
+ if key == "italics" and value is True:
+ sami_style["font-style"] = "italic"
+ elif key == "bold" and value is True:
+ sami_style["font-weight"] = "bold"
+ elif key == "underline" and value is True:
+ sami_style["text-decoration"] = "underline"
else:
sami_style[key] = value
@@ -637,14 +639,14 @@ def _encode(self, s):
class SAMIParser(HTMLParser):
def __init__(self, *args, **kw):
HTMLParser.__init__(self, *args, **kw)
- self.sami = ''
- self.line = ''
+ self.sami = ""
+ self.line = ""
self.styles = {}
self.queue = deque()
self.langs = set()
- self.last_element = ''
+ self.last_element = ""
self.name2codepoint = name2codepoint.copy()
- self.name2codepoint['apos'] = 0x0027
+ self.name2codepoint["apos"] = 0x0027
self.convert_charrefs = False
def handle_starttag(self, tag, attrs):
@@ -656,20 +658,20 @@ def handle_starttag(self, tag, attrs):
self.last_element = tag
# treat divs as spans
- if tag == 'div':
- tag = 'span'
+ if tag == "div":
+ tag = "span"
# figure out the caption language of P tags
- if tag == 'p':
+ if tag == "p":
lang = self._find_lang(attrs)
# if no language detected, set it as the default
lang = lang or DEFAULT_LANGUAGE_CODE
- attrs.append(('lang', lang))
+ attrs.append(("lang", lang))
self.langs.add(lang)
# clean-up line breaks
- if tag == 'br':
+ if tag == "br":
self.sami += "
"
# add tag to queue
else:
@@ -687,11 +689,11 @@ def handle_starttag(self, tag, attrs):
# override the parser's handling of endtags
def handle_endtag(self, tag):
# treat divs as spans
- if tag == 'div':
- tag = 'span'
+ if tag == "div":
+ tag = "span"
# handle incorrectly formatted sync/p tags
- if tag in ['p', 'sync'] and tag == self.last_element:
+ if tag in ["p", "sync"] and tag == self.last_element:
return
# close off tags in LIFO order, if matching starting tag in queue
@@ -700,18 +702,18 @@ def handle_endtag(self, tag):
self.sami += f""
def handle_entityref(self, name):
- if name in ['gt', 'lt']:
- self.sami += f'&{name};'
+ if name in ["gt", "lt"]:
+ self.sami += f"&{name};"
else:
try:
self.sami += chr(self.name2codepoint[name])
except (KeyError, ValueError):
- self.sami += f'&{name}'
+ self.sami += f"&{name}"
- self.last_element = ''
+ self.last_element = ""
def handle_charref(self, name):
- if name[0] == 'x':
+ if name[0] == "x":
self.sami += chr(int(name[1:], 16))
else:
self.sami += chr(int(name))
@@ -719,7 +721,7 @@ def handle_charref(self, name):
# override the parser's handling of data
def handle_data(self, data):
self.sami += data
- self.last_element = ''
+ self.last_element = ""
# override the parser's feed function
def feed(self, data):
@@ -727,28 +729,27 @@ def feed(self, data):
:param data: Raw SAMI unicode string
:returns: tuple (str, dict, set)
"""
- no_cc = 'no closed captioning available'
+ no_cc = "no closed captioning available"
- if '")
- style = BeautifulSoup(data[:index], "lxml").find('style')
+ style = BeautifulSoup(data[:index], "lxml").find("style")
if style and style.contents:
- self.styles = self._css_parse(' '.join(style.contents))
+ self.styles = self._css_parse(" ".join(style.contents))
else:
self.styles = {}
# fix erroneous italics tags
- data = data.replace('', '')
+ data = data.replace("", "")
# fix awkward tags found in some SAMIs
- data = data.replace(';>', '>')
+ data = data.replace(";>", ">")
HTMLParser.feed(self, data)
# close any tags that remain in the queue
@@ -770,22 +771,22 @@ def _css_parse(self, css):
for rule in sheet:
new_style = {}
selector = rule.selectorText.lower()
- if selector[0] in ['#', '.']:
+ if selector[0] in ["#", "."]:
selector = selector[1:]
# keep any style attributes that are needed
for prop in rule.style:
- if prop.name == 'color':
+ if prop.name == "color":
try:
cv = cssutils_css.ColorValue(prop.value)
except SyntaxErr:
raise CaptionReadSyntaxError(
f"Invalid color value: {prop.value}. Check for "
f"missing # before hex values or misspelled color "
- f"values.")
+ f"values."
+ )
# Code for RGB to hex conversion comes from
# http://bit.ly/1kwfBnQ
- new_style['color'] = (f'#{cv.red:02x}{cv.green:02x}'
- f'{cv.blue:02x}')
+ new_style["color"] = f"#{cv.red:02x}{cv.green:02x}" f"{cv.blue:02x}"
else:
new_style[prop.name] = prop.value
if new_style:
@@ -796,12 +797,12 @@ def _css_parse(self, css):
def _find_lang(self, attrs):
for attr, value in attrs:
# if lang is an attribute of the tag
- if attr.lower() == 'lang':
+ if attr.lower() == "lang":
return value[:2]
# if the P tag has a class, try and find the language
- if attr.lower() == 'class':
+ if attr.lower() == "class":
try:
- return self.styles[value.lower()]['lang']
+ return self.styles[value.lower()]["lang"]
except KeyError:
pass
diff --git a/pycaption/scc/__init__.py b/pycaption/scc/__init__.py
index 5846f551..4ec8bbcd 100644
--- a/pycaption/scc/__init__.py
+++ b/pycaption/scc/__init__.py
@@ -314,6 +314,8 @@ def _flush_implicit_buffers(self, old_key=None, *args):
if not self.buffer.is_empty():
self.caption_stash.create_and_store(self.buffer, self.time)
self.buffer = self.node_creator_factory.new_creator()
+ # Reset positioning state for new caption boundary
+ self.node_creator_factory.position_tracker.reset_for_new_caption()
def _translate_line(self, line):
# ignore blank lines
@@ -367,13 +369,13 @@ def _handle_double_command(self, word):
# doubled special characters and doubled extended characters
# with only one member of each pair being displayed.
- doubled_types = (word != "94a1" and word in COMMANDS) or _is_pac_command(word) or word in SPECIAL_CHARS
+ doubled_types = (
+ (word != "94a1" and word in COMMANDS)
+ or _is_pac_command(word)
+ or word in SPECIAL_CHARS
+ )
if self.double_starter:
- doubled_types = (
- doubled_types
- or word in EXTENDED_CHARS
- or word == "94a1"
- )
+ doubled_types = doubled_types or word in EXTENDED_CHARS or word == "94a1"
if word in CUE_STARTING_COMMAND and word != self.last_command:
self.double_starter = False
@@ -426,6 +428,8 @@ def _translate_command(self, word, next_command=None):
if not self.buffer.is_empty():
self.caption_stash.create_and_store(self.buffer, self.time)
self.buffer = self.node_creator_factory.new_creator()
+ # Reset positioning state for new caption boundary
+ self.node_creator_factory.position_tracker.reset_for_new_caption()
self.time = self.time_translator.get_time()
@@ -445,6 +449,8 @@ def _translate_command(self, word, next_command=None):
if not self.buffer.is_empty():
self.caption_stash.create_and_store(self.buffer, self.time)
self.buffer = self.node_creator_factory.new_creator()
+ # Reset positioning state for new caption boundary
+ self.node_creator_factory.position_tracker.reset_for_new_caption()
# set rows to empty, configure start time for caption
self.roll_rows = []
@@ -453,6 +459,8 @@ def _translate_command(self, word, next_command=None):
# clear pop_on buffer
elif word == "94ae":
self.buffer = self.node_creator_factory.new_creator()
+ # Reset positioning state for new caption boundary
+ self.node_creator_factory.position_tracker.reset_for_new_caption()
# display pop_on buffer [End Of Caption]
elif word == "942f":
@@ -465,6 +473,8 @@ def _translate_command(self, word, next_command=None):
cue = PopOnCue(buffer=deepcopy(self.buffer), start=self.time, end=0)
self.pop_ons_queue.appendleft(cue)
self.buffer = self.node_creator_factory.new_creator()
+ # Reset positioning state for new caption boundary
+ self.node_creator_factory.position_tracker.reset_for_new_caption()
# roll up captions [Carriage Return]
elif word == "94ad":
@@ -522,6 +532,8 @@ def _roll_up(self):
# convert buffer and empty
self.caption_stash.create_and_store(self.buffer, self.time)
self.buffer = self.node_creator_factory.new_creator()
+ # Reset positioning state for new caption boundary
+ self.node_creator_factory.position_tracker.reset_for_new_caption()
# configure time
self.time = self.time_translator.get_time()
diff --git a/pycaption/scc/specialized_collections.py b/pycaption/scc/specialized_collections.py
index 1bd5bf9f..addcab1f 100644
--- a/pycaption/scc/specialized_collections.py
+++ b/pycaption/scc/specialized_collections.py
@@ -340,11 +340,12 @@ def add_chars(self, *chars):
node = _InstructionNode(position=current_position)
self._collection.append(node)
- # handle a simple line break
+ # handle line break(s) - may be multiple for multi-row jumps
if self._position_tracer.is_linebreak_required():
- self._collection.append(
- _InstructionNode.create_break(position=current_position)
- )
+ for _ in range(self._position_tracer._breaks_required):
+ self._collection.append(
+ _InstructionNode.create_break(position=current_position)
+ )
self._position_tracer.acknowledge_linebreak_consumed()
node = _InstructionNode.create_text(current_position)
self._collection.append(node)
@@ -412,9 +413,10 @@ def interpret_command(self, command, next_command=None):
# it should open italic tag
# if break is required, break then add style tag
if self._position_tracer.is_linebreak_required():
- self._collection.append(
- _InstructionNode.create_break(position=current_position)
- )
+ for _ in range(self._position_tracer._breaks_required):
+ self._collection.append(
+ _InstructionNode.create_break(position=current_position)
+ )
self._position_tracer.acknowledge_linebreak_consumed()
self._collection.append(
_InstructionNode.create_italics_style(current_position)
@@ -433,9 +435,10 @@ def interpret_command(self, command, next_command=None):
)
self.last_style = "italics off"
if self._position_tracer.is_linebreak_required():
- self._collection.append(
- _InstructionNode.create_break(position=current_position)
- )
+ for _ in range(self._position_tracer._breaks_required):
+ self._collection.append(
+ _InstructionNode.create_break(position=current_position)
+ )
self._position_tracer.acknowledge_linebreak_consumed()
# handle mid-row codes that follows a text node
@@ -446,7 +449,7 @@ def interpret_command(self, command, next_command=None):
prev_text_node = self.get_previous_text_node()
prev_node_is_break = prev_text_node is not None and 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 (
command in MID_ROW_CODES
diff --git a/pycaption/scc/state_machines.py b/pycaption/scc/state_machines.py
index de5a4e87..74ebcbee 100644
--- a/pycaption/scc/state_machines.py
+++ b/pycaption/scc/state_machines.py
@@ -12,7 +12,7 @@ def __init__(self, positioning=None):
:type positioning: tuple[int]
"""
self._positions = [positioning]
- self._break_required = False
+ self._breaks_required = 0
self._repositioning_required = False
# Since the actual column is not applied when encountering a line break
# this attribute is used to store it and determine by comparison if the
@@ -24,6 +24,10 @@ def update_positioning(self, positioning):
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)
+
:type positioning: tuple[int]
:param positioning: a tuple (row, col)
"""
@@ -36,17 +40,35 @@ def update_positioning(self, positioning):
return
row, col = current
- if self._break_required:
+ if self._breaks_required:
col = self._last_column
new_row, new_col = positioning
is_tab_offset = new_row == row and col + 1 <= new_col <= col + 3
- # One line below will be treated as line break, not repositioning
- if new_row == row + 1:
- self._positions.append((new_row, col))
- self._break_required = True
- self._last_column = new_col
+
+ # 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:
+ 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._last_column = new_col
+ # Large jumps (4+ rows): Use repositioning (new cue)
+ else:
+ # Reset position - this triggers repositioning
+ self._positions = [positioning]
+ self._repositioning_required = True
# Tab offsets after line breaks will be ignored to avoid repositioning
- elif self._break_required and is_tab_offset:
+ elif self._breaks_required and is_tab_offset:
return
# force not to reposition on the same coordinates
elif positioning == current:
@@ -87,11 +109,24 @@ def is_linebreak_required(self):
"""If the current position is simply one line below the previous.
:rtype: bool
"""
- return self._break_required
+ return self._breaks_required > 0
def acknowledge_linebreak_consumed(self):
"""Call to acknowledge that the line required was consumed"""
- self._break_required = False
+ self._breaks_required = 0
+
+ def reset_for_new_caption(self):
+ """Reset positioning state for a new caption boundary (e.g., EOC).
+
+ This ensures that breaks and repositioning state from the previous
+ caption do not bleed into the new caption. The position list is reset
+ to allow the next caption to set its position independently.
+ """
+ self._breaks_required = 0
+ self._repositioning_required = False
+ self._last_column = None
+ # Reset positions to None so the next PAC sets position fresh
+ self._positions = [None]
class DefaultProvidingPositionTracker(_PositioningTracker):
diff --git a/pycaption/scc/translator.py b/pycaption/scc/translator.py
index aba7f8a2..b2951ed1 100644
--- a/pycaption/scc/translator.py
+++ b/pycaption/scc/translator.py
@@ -1,7 +1,7 @@
from pycaption.scc.constants import ALL_CHARACTERS, COMMAND_LABELS
-def translate_scc(scc_content, brackets='[]'):
+def translate_scc(scc_content, brackets="[]"):
"""
Replaces hexadecimal words with their meaning
@@ -16,7 +16,7 @@ def translate_scc(scc_content, brackets='[]'):
:return: Translated SCC captions
:rtype: str
"""
- opening_bracket, closing_bracket = brackets if brackets else ('', '')
+ opening_bracket, closing_bracket = brackets if brackets else ("", "")
scc_elements = set(scc_content.split())
for elem in scc_elements:
name = COMMAND_LABELS.get(elem, ALL_CHARACTERS.get(elem))
@@ -28,5 +28,6 @@ def translate_scc(scc_content, brackets='[]'):
name = f"{char1}{char2}"
if name:
scc_content = scc_content.replace(
- elem, f"{opening_bracket}{name}{closing_bracket}")
+ elem, f"{opening_bracket}{name}{closing_bracket}"
+ )
return scc_content
diff --git a/pycaption/srt.py b/pycaption/srt.py
index 3351bad0..7b9bd389 100644
--- a/pycaption/srt.py
+++ b/pycaption/srt.py
@@ -1,22 +1,20 @@
from copy import deepcopy
-from .base import (
- BaseReader, BaseWriter, CaptionSet, CaptionList, Caption, CaptionNode,
-)
+from .base import BaseReader, BaseWriter, Caption, CaptionList, CaptionNode, CaptionSet
from .exceptions import CaptionReadNoCaptions, InvalidInputError
class SRTReader(BaseReader):
def detect(self, content):
lines = content.splitlines()
- if lines[0].isdigit() and '-->' in lines[1]:
+ if lines[0].isdigit() and "-->" in lines[1]:
return True
else:
return False
- def read(self, content, lang='en-US'):
+ def read(self, content, lang="en-US"):
if not isinstance(content, str):
- raise InvalidInputError('The content is not a unicode string.')
+ raise InvalidInputError("The content is not a unicode string.")
lines = content.splitlines()
start_line = 0
@@ -28,15 +26,15 @@ def read(self, content, lang='en-US'):
end_line = self._find_text_line(start_line, lines)
- timing = lines[start_line + 1].split('-->')
- start = self._srttomicro(timing[0].strip(' \r\n'))
- end = self._srttomicro(timing[1].strip(' \r\n'))
+ timing = lines[start_line + 1].split("-->")
+ start = self._srttomicro(timing[0].strip(" \r\n"))
+ end = self._srttomicro(timing[1].strip(" \r\n"))
nodes = []
- for line in lines[start_line + 2:end_line - 1]:
+ for line in lines[start_line + 2 : end_line - 1]:
# skip extra blank lines
- if not nodes or line != '':
+ if not nodes or line != "":
nodes.append(CaptionNode.create_text(line))
nodes.append(CaptionNode.create_break())
@@ -56,14 +54,16 @@ def read(self, content, lang='en-US'):
return caption_set
def _srttomicro(self, stamp):
- 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)
+ 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
+ )
return microseconds
@@ -89,11 +89,9 @@ def write(self, caption_set):
srt_captions = []
for lang in caption_set.get_languages():
- srt_captions.append(
- self._recreate_lang(caption_set.get_captions(lang))
- )
+ srt_captions.append(self._recreate_lang(caption_set.get_captions(lang)))
- caption_content = 'MULTI-LANGUAGE SRT\n'.join(srt_captions)
+ caption_content = "MULTI-LANGUAGE SRT\n".join(srt_captions)
return caption_content
def _recreate_lang(self, captions):
@@ -106,30 +104,35 @@ def _recreate_lang(self, captions):
for caption in captions[1:]:
# Merge if the timestamp is the same as last caption
if (caption.start, caption.end) == (
- merged_captions[-1].start, merged_captions[-1].end):
+ merged_captions[-1].start,
+ merged_captions[-1].end,
+ ):
merged_captions[-1] = Caption(
start=caption.start,
end=caption.end,
- nodes=(merged_captions[-1].nodes
- + [CaptionNode.create_break()]
- + caption.nodes))
+ nodes=(
+ merged_captions[-1].nodes
+ + [CaptionNode.create_break()]
+ + caption.nodes
+ ),
+ )
else:
# Different timestamp, end of merging, append new caption
merged_captions.append(caption)
captions = merged_captions
- srt = ''
+ srt = ""
count = 1
for caption in captions:
- srt += f'{count}\n'
+ srt += f"{count}\n"
- start = caption.format_start(msec_separator=',')
- end = caption.format_end(msec_separator=',')
+ start = caption.format_start(msec_separator=",")
+ end = caption.format_end(msec_separator=",")
- srt += f'{start[:12]} --> {end[:12]}\n'
+ srt += f"{start[:12]} --> {end[:12]}\n"
- new_content = ''
+ new_content = ""
for node in caption.nodes:
new_content = self._recreate_line(new_content, node)
@@ -143,8 +146,8 @@ def _recreate_lang(self, captions):
def _recreate_line(self, srt, line):
if line.type_ == CaptionNode.TEXT:
- return srt + f'{line.content} '
+ return srt + f"{line.content} "
elif line.type_ == CaptionNode.BREAK:
- return srt + '\n'
+ return srt + "\n"
else:
return srt
diff --git a/pycaption/utils.py b/pycaption/utils.py
index e8ff6fbc..0be4346f 100644
--- a/pycaption/utils.py
+++ b/pycaption/utils.py
@@ -4,7 +4,7 @@ def is_leaf(element):
considered a leaf if it is either NavigableString or the "br" tag
:param element: A BeautifulSoup tag or NavigableString
"""
- name = getattr(element, 'name', None)
- if not name or name == 'br':
+ name = getattr(element, "name", None)
+ if not name or name == "br":
return True
return False
diff --git a/pycaption/webvtt.py b/pycaption/webvtt.py
index c3573b29..4953e465 100644
--- a/pycaption/webvtt.py
+++ b/pycaption/webvtt.py
@@ -77,7 +77,6 @@ def _parse(self, lines):
found_timing = False
for i, line in enumerate(lines):
-
if "-->" in line:
found_timing = True
timing_line = i
diff --git a/tests/conftest.py b/tests/conftest.py
index acb97edb..d1d7d5ef 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -1,104 +1,170 @@
from tests.fixtures.dfxp import ( # noqa: F401
- sample_dfxp, sample_dfxp_with_inline_style, sample_dfxp_with_defined_style,
- sample_dfxp_with_inherited_style, sample_dfxp_without_region_and_style,
- sample_dfxp_with_positioning, sample_dfxp_with_relativized_positioning,
- sample_dfxp_empty, sample_dfxp_syntax_error,
+ dfxp_style_region_align_conflict,
+ dfxp_with_concurrent_captions,
+ sample_dfxp,
+ sample_dfxp_default_styling_p_tags,
+ sample_dfxp_empty,
+ sample_dfxp_empty_cue,
+ sample_dfxp_empty_cue_output,
+ sample_dfxp_empty_paragraph,
+ sample_dfxp_for_legacy_writer_input,
+ sample_dfxp_for_legacy_writer_output,
+ sample_dfxp_from_sami_with_bad_span_align,
+ sample_dfxp_from_sami_with_lang_margins,
+ sample_dfxp_from_sami_with_margins,
sample_dfxp_from_sami_with_positioning,
- sample_dfxp_long_cue, sample_dfxp_long_cue_fit_to_screen,
- sample_dfxp_from_sami_with_margins, sample_dfxp_from_sami_with_lang_margins,
- sample_dfxp_from_sami_with_span, sample_dfxp_from_sami_with_bad_span_align,
+ sample_dfxp_from_sami_with_span,
+ sample_dfxp_from_scc_output,
+ sample_dfxp_incorrect_time_format,
sample_dfxp_invalid_but_supported_positioning_input,
sample_dfxp_invalid_but_supported_positioning_output,
- sample_dfxp_multiple_regions_input, sample_dfxp_multiple_regions_output,
- sample_dfxp_to_render_with_only_default_positioning_input,
- sample_dfxp_output, sample_dfxp_style_tag_with_no_xml_id_input,
- sample_dfxp_style_tag_with_no_xml_id_output, sample_dfxp_from_scc_output,
- sample_dfxp_with_properly_closing_spans_output,
- sample_dfxp_for_legacy_writer_input, sample_dfxp_for_legacy_writer_output,
- sample_dfxp_with_templated_style, sample_dfxp_with_escaped_apostrophe,
- sample_dfxp_with_alternative_timing_formats, sample_dfxp_empty_paragraph,
- sample_dfxp_only_spaces_paragraph, sample_dfxp_incorrect_time_format,
- sample_dfxp_missing_begin, sample_dfxp_missing_end_and_dur,
- sample_dfxp_with_frame_timing, sample_dfxp_empty_cue,
- sample_dfxp_empty_cue_output, sample_dfxp_default_styling_p_tags,
sample_dfxp_invalid_positioning_value_template,
+ sample_dfxp_long_cue,
+ sample_dfxp_long_cue_fit_to_screen,
+ sample_dfxp_missing_begin,
+ sample_dfxp_missing_end_and_dur,
sample_dfxp_multiple_captions_with_the_same_timing,
- sample_dfxp_with_ampersand_character, sample_dfxp_with_nested_spans,
- dfxp_style_region_align_conflict, dfxp_with_concurrent_captions,
+ sample_dfxp_multiple_regions_input,
+ sample_dfxp_multiple_regions_output,
+ sample_dfxp_only_spaces_paragraph,
+ sample_dfxp_output,
+ sample_dfxp_style_tag_with_no_xml_id_input,
+ sample_dfxp_style_tag_with_no_xml_id_output,
+ sample_dfxp_syntax_error,
+ sample_dfxp_to_render_with_only_default_positioning_input,
+ sample_dfxp_with_alternative_timing_formats,
+ sample_dfxp_with_ampersand_character,
+ sample_dfxp_with_defined_style,
+ sample_dfxp_with_escaped_apostrophe,
+ sample_dfxp_with_frame_timing,
+ sample_dfxp_with_inherited_style,
+ sample_dfxp_with_inline_style,
+ sample_dfxp_with_nested_spans,
+ sample_dfxp_with_positioning,
+ sample_dfxp_with_properly_closing_spans_output,
+ sample_dfxp_with_relativized_positioning,
+ sample_dfxp_with_templated_style,
+ sample_dfxp_without_region_and_style,
)
-from tests.fixtures.microdvd import ( # noqa: F401
- sample_microdvd, sample_microdvd_2,
- sample_microdvd_invalid_format, missing_fps_sample_microdvd,
- sample_microdvd_empty, sample_microdvd_empty_cue_output,
+from tests.fixtures.microdvd import missing_fps_sample_microdvd # noqa: F401
+from tests.fixtures.microdvd import (
+ sample_microdvd,
+ sample_microdvd_2,
+ sample_microdvd_empty,
+ sample_microdvd_empty_cue_output,
+ sample_microdvd_invalid_format,
)
-from tests.fixtures.sami import ( # noqa: F401
- sample_sami, sample_sami_with_style_tags,
- sample_sami_with_css_inline_style, sample_sami_with_css_id_style,
- sample_sami_empty, sample_sami_syntax_error,
- sample_sami_double_br, sample_sami_partial_margins,
- sample_sami_partial_margins_relativized, sample_sami_lang_margin,
- sample_sami_with_span, sample_sami_with_bad_span_align,
- sample_sami_with_bad_div_align, sample_sami_with_p_align,
- sample_sami_with_p_and_span_align, sample_sami_with_multiple_span_aligns,
- sample_sami_no_lang, sample_sami_with_lang, sample_sami_with_multi_lang,
- sample_sami_with_multiple_p, sample_sami_empty_cue_output,
- sample_sami_with_invalid_inline_style,
- sample_sami_including_hexadecimal_charref,
+from tests.fixtures.sami import sample_sami # noqa: F401
+from tests.fixtures.sami import (
+ sample_sami_double_br,
+ sample_sami_empty,
+ sample_sami_empty_cue_output,
+ sample_sami_from_dfxp_with_nested_spans,
sample_sami_including_decimal_charref,
- sample_sami_including_html5_entityref, sample_sami_with_unclosed_tag,
- sample_sami_with_inline_lang, sample_sami_from_dfxp_with_nested_spans,
- sample_sami_with_separate_multi_lang, sample_sami_missing_start
+ sample_sami_including_hexadecimal_charref,
+ sample_sami_including_html5_entityref,
+ sample_sami_lang_margin,
+ sample_sami_missing_start,
+ sample_sami_no_lang,
+ sample_sami_partial_margins,
+ sample_sami_partial_margins_relativized,
+ sample_sami_syntax_error,
+ sample_sami_with_bad_div_align,
+ sample_sami_with_bad_span_align,
+ sample_sami_with_css_id_style,
+ sample_sami_with_css_inline_style,
+ sample_sami_with_inline_lang,
+ sample_sami_with_invalid_inline_style,
+ sample_sami_with_lang,
+ sample_sami_with_multi_lang,
+ sample_sami_with_multiple_p,
+ sample_sami_with_multiple_span_aligns,
+ sample_sami_with_p_align,
+ sample_sami_with_p_and_span_align,
+ sample_sami_with_separate_multi_lang,
+ sample_sami_with_span,
+ sample_sami_with_style_tags,
+ sample_sami_with_unclosed_tag,
)
from tests.fixtures.scc import ( # noqa: F401
+ sample_no_positioning_at_all_scc,
sample_scc_created_dfxp_with_wrongly_closing_spans,
- scc_that_generates_webvtt_with_proper_newlines,
- sample_scc_produces_captions_with_start_and_end_time_the_same,
- sample_scc_pop_on, sample_scc_multiple_positioning, sample_scc_with_italics,
- sample_scc_empty, sample_scc_roll_up_ru2, sample_scc_roll_up_ru3,
- sample_no_positioning_at_all_scc, sample_scc_with_line_too_long,
- sample_scc_no_explicit_end_to_last_caption, sample_scc_flashing_cue,
- sample_scc_eoc_first_command, sample_scc_with_extended_characters,
- sample_scc_with_ampersand_character, sample_scc_multiple_formats,
- sample_scc_duplicate_tab_offset, sample_scc_duplicate_special_characters,
- sample_scc_tab_offset, sample_scc_with_unknown_commands,
- sample_scc_special_and_extended_characters, sample_scc_mid_row_before_text_pop,
- sample_scc_mid_row_before_text_roll, sample_scc_mid_row_before_text_paint,
+ sample_scc_duplicate_special_characters,
+ sample_scc_duplicate_tab_offset,
+ sample_scc_empty,
+ sample_scc_eoc_first_command,
+ sample_scc_flashing_cue,
+ sample_scc_mid_row_before_text_paint,
+ sample_scc_mid_row_before_text_pop,
+ sample_scc_mid_row_before_text_roll,
+ sample_scc_mid_row_following_text_no_text_before_italics_off_paint,
sample_scc_mid_row_following_text_no_text_before_italics_off_pop,
sample_scc_mid_row_following_text_no_text_before_italics_off_roll,
- sample_scc_mid_row_following_text_no_text_before_italics_off_paint,
+ sample_scc_mid_row_following_text_no_text_before_italics_on_paint,
sample_scc_mid_row_following_text_no_text_before_italics_on_pop,
sample_scc_mid_row_following_text_no_text_before_italics_on_roll,
- sample_scc_mid_row_following_text_no_text_before_italics_on_paint,
+ sample_scc_mid_row_with_space_before_paint,
sample_scc_mid_row_with_space_before_pop,
sample_scc_mid_row_with_space_before_roll,
- sample_scc_mid_row_with_space_before_paint,
+ sample_scc_multiple_formats,
+ sample_scc_multiple_positioning,
+ sample_scc_no_explicit_end_to_last_caption,
+ sample_scc_pop_on,
+ sample_scc_produces_captions_with_start_and_end_time_the_same,
+ sample_scc_roll_up_ru2,
+ sample_scc_roll_up_ru3,
+ sample_scc_special_and_extended_characters,
+ sample_scc_tab_offset,
+ sample_scc_with_ampersand_character,
+ sample_scc_with_extended_characters,
+ sample_scc_with_italics,
+ sample_scc_with_line_too_long,
+ sample_scc_with_spaces_at_eol_paint,
sample_scc_with_spaces_at_eol_pop,
sample_scc_with_spaces_at_eol_roll,
- sample_scc_with_spaces_at_eol_paint,
+ sample_scc_with_unknown_commands,
+ scc_that_generates_webvtt_with_proper_newlines,
)
-from tests.fixtures.srt import ( # noqa: F401
- sample_srt, sample_srt_ascii, sample_srt_numeric, sample_srt_empty,
- sample_srt_blank_lines, sample_srt_trailing_blanks,
- samples_srt_same_time, sample_srt_empty_cue_output,
+from tests.fixtures.srt import (
+ sample_srt,
+ sample_srt_ascii, # noqa: F401
+ sample_srt_blank_lines,
+ sample_srt_empty,
+ sample_srt_empty_cue_output,
+ sample_srt_numeric,
sample_srt_timestamps_without_microseconds,
+ sample_srt_trailing_blanks,
+ samples_srt_same_time,
)
from tests.fixtures.translated_scc import ( # noqa: F401
- sample_translated_scc_custom_brackets, sample_translated_scc_success,
- sample_translated_scc_commands_not_found, sample_translated_scc_no_brackets,
- sample_translated_scc_special_and_extended_characters
+ sample_translated_scc_commands_not_found,
+ sample_translated_scc_custom_brackets,
+ sample_translated_scc_no_brackets,
+ sample_translated_scc_special_and_extended_characters,
+ sample_translated_scc_success,
)
from tests.fixtures.webvtt import ( # noqa: F401
- sample_webvtt, sample_webvtt_from_dfxp, sample_webvtt_from_sami,
- sample_webvtt_from_sami_with_style, sample_webvtt_from_sami_with_id_style,
+ sample_webvtt,
+ sample_webvtt_2,
+ sample_webvtt_double_br,
+ sample_webvtt_empty,
+ sample_webvtt_empty_cue,
+ sample_webvtt_empty_cue_output,
+ sample_webvtt_from_dfxp,
+ sample_webvtt_from_dfxp_with_positioning_and_style,
sample_webvtt_from_dfxp_with_style,
+ sample_webvtt_from_sami,
+ sample_webvtt_from_sami_with_id_style,
+ sample_webvtt_from_sami_with_style,
+ sample_webvtt_from_scc_properly_writes_newlines_output,
+ sample_webvtt_from_srt,
+ sample_webvtt_from_webvtt,
sample_webvtt_keeps_positioning,
- sample_webvtt_from_dfxp_with_positioning_and_style,
- sample_webvtt_from_srt, sample_webvtt_from_webvtt,
- sample_webvtt_2, sample_webvtt_empty, sample_webvtt_double_br,
- sample_webvtt_output_long_cue, webvtt_from_dfxp_with_conflicting_align,
+ sample_webvtt_last_cue_zero_start,
+ sample_webvtt_multi_lang_de,
+ sample_webvtt_multi_lang_en,
+ sample_webvtt_output_long_cue,
+ sample_webvtt_timestamps,
sample_webvtt_with_cue_settings,
- sample_webvtt_from_scc_properly_writes_newlines_output,
- sample_webvtt_last_cue_zero_start, sample_webvtt_empty_cue,
- sample_webvtt_multi_lang_en, sample_webvtt_multi_lang_de,
- sample_webvtt_empty_cue_output, sample_webvtt_timestamps
+ webvtt_from_dfxp_with_conflicting_align,
)
diff --git a/tests/fixtures/dfxp.py b/tests/fixtures/dfxp.py
index 864f3e7a..277252e2 100644
--- a/tests/fixtures/dfxp.py
+++ b/tests/fixtures/dfxp.py
@@ -915,16 +915,15 @@ def sample_dfxp_from_scc_output():
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
@@ -933,40 +932,38 @@ def sample_dfxp_from_scc_output():
abab
- cdcd
-
-
+ cdcd
efef
-
+
ghgh
ijij
klkl
-
+
mnmn
-
+
opop
-
+
qrqr
-
+
stst
uvuv
wxwx
-
+
yzyz
-
+
0101
-
+
2323
-
+
4545
6767
8989
@@ -977,7 +974,7 @@ def sample_dfxp_from_scc_output():
"""
-@pytest.fixture(scope="session")
+@pytest.fixture()
def sample_dfxp_with_properly_closing_spans_output():
return """\
@@ -992,7 +989,7 @@ def sample_dfxp_with_properly_closing_spans_output():
-
+
@@ -1015,11 +1012,8 @@ def sample_dfxp_with_properly_closing_spans_output():
bb
cc
-
- abcd
-
- abcd
+ abcdabcd