, please create a character style in Word.")
return False
def parse_inline_styles(self, style_string):
@@ -271,9 +265,7 @@ def apply_inline_styles_to_run(self, styles_dict):
# Apply font-family
if "font-family" in styles_dict:
- font_family = (
- styles_dict["font-family"].split(",")[0].strip().strip('"').strip("'")
- )
+ font_family = styles_dict["font-family"].split(",")[0].strip().strip('"').strip("'")
self.run.font.name = font_family
def get_cell_html(self, soup):
@@ -282,14 +274,14 @@ def get_cell_html(self, soup):
Cannot use find_all as it only finds element tags and does not find text which
is not inside an element
"""
- return ' '.join([str(i) for i in soup.contents])
+ return " ".join([str(i) for i in soup.contents])
def set_cell_background(self, cell, color):
"""Set the background color of a table cell."""
tc = cell._tc
tcPr = tc.get_or_add_tcPr()
- shd = OxmlElement('w:shd')
- shd.set(qn('w:fill'), color.lstrip('#'))
+ shd = OxmlElement("w:shd")
+ shd.set(qn("w:fill"), color.lstrip("#"))
tcPr.append(shd)
def set_cell_borders(self, cell, styles):
@@ -314,11 +306,11 @@ def set_cell_borders(self, cell, styles):
border_styles = constants.BORDER_STYLES
keywords = constants.BORDER_KEYWORDS
border_sides = ("top", "right", "bottom", "left")
- border_width_pattern = re.compile(r'^[0-9]*\.?[0-9]+(px|pt|cm|in|rem|em|%)$')
+ border_width_pattern = re.compile(r"^[0-9]*\.?[0-9]+(px|pt|cm|in|rem|em|%)$")
def parse_border_style(value: str) -> str:
"""Parses border styles to match word standart"""
- return constants.BORDER_STYLES[value] if value in constants.BORDER_STYLES.keys() else 'none'
+ return constants.BORDER_STYLES[value] if value in constants.BORDER_STYLES.keys() else "none"
def check_unit_keywords(value: str) -> str:
"""Convert medium, thin, thick keywords to numeric values (px)"""
@@ -332,23 +324,23 @@ def border_unit_converter(unit_value: str):
unit_value = check_unit_keywords(unit_value)
# Return default if no value or empty
- if not unit_value or unit_value == '':
+ if not unit_value or unit_value == "":
return default_size
- unit = re.sub(r'[0-9\.]+', '', unit_value)
- value = float(re.sub(r'[a-zA-Z\!\%]+', '', unit_value)) # Allow float values
+ unit = re.sub(r"[0-9\.]+", "", unit_value)
+ value = float(re.sub(r"[a-zA-Z\!\%]+", "", unit_value)) # Allow float values
- if unit == 'px':
+ if unit == "px":
result = value * 0.75 # 1 px = 0.75 pt
- elif unit == 'cm':
+ elif unit == "cm":
result = value * 28.35 # 1 cm = 28.35 pt
- elif unit == 'in':
+ elif unit == "in":
result = value * 72 # 1 inch = 72 pt
- elif unit == 'pt':
- result = value # default is pt
- elif unit == 'rem' or unit == 'em':
+ elif unit == "pt":
+ result = value # default is pt
+ elif unit == "rem" or unit == "em":
result = value * 12 # Assuming 1rem/em = 16px, converted to pt
- elif unit == '%':
+ elif unit == "%":
result = constants.MAX_INDENT * (value / 100)
else:
return None # Unsupported units return None
@@ -363,7 +355,7 @@ def parse_border_value(value: str):
parts = value.split()
# Return all default if there is only 'none' or empty
- if (len(parts) == 1 and parts[0] == 'none') or (not value or value.strip() == ''):
+ if (len(parts) == 1 and parts[0] == "none") or (not value or value.strip() == ""):
return default_size, default_style, default_color
size = None
@@ -452,9 +444,9 @@ def parse_border_value(value: str):
borders[side].update({"size": size, "style": style, "color": color})
# Check if w:tcBorders exists, otherwise create it
- tcBorders = tcPr.first_child_found_in('w:tcBorders')
+ tcBorders = tcPr.first_child_found_in("w:tcBorders")
if tcBorders is None:
- tcBorders = OxmlElement('w:tcBorders')
+ tcBorders = OxmlElement("w:tcBorders")
tcPr.append(tcBorders)
# Apply borders to the cell
@@ -463,17 +455,17 @@ def parse_border_value(value: str):
border = OxmlElement(f"w:{side}")
border.set(qn("w:val"), border_info["style"]) # Set border style
border.set(qn("w:sz"), str(border_info["size"] * 8)) # Word uses eighths of a point
- border.set(qn("w:color"), border_info["color"].replace('#', '')) # Set border color
+ border.set(qn("w:color"), border_info["color"].replace("#", "")) # Set border color
tcBorders.append(border)
def add_bookmark(self, bookmark_name):
"""Adds a word bookmark to an existing paragraph"""
- bookmark_start = OxmlElement('w:bookmarkStart')
- bookmark_start.set(qn('w:id'), str(self.bookmark_id))
- bookmark_start.set(qn('w:name'), bookmark_name)
+ bookmark_start = OxmlElement("w:bookmarkStart")
+ bookmark_start.set(qn("w:id"), str(self.bookmark_id))
+ bookmark_start.set(qn("w:name"), bookmark_name)
- bookmark_end = OxmlElement('w:bookmarkEnd')
- bookmark_end.set(qn('w:id'), str(self.bookmark_id))
+ bookmark_end = OxmlElement("w:bookmarkEnd")
+ bookmark_end.set(qn("w:id"), str(self.bookmark_id))
if not self.paragraph:
self.paragraph = self.doc.add_paragraph()
@@ -492,18 +484,14 @@ def apply_styles_to_run(self, run, style, isCustom=False):
return
except ValueError as e:
if "need type CHARACTER" in str(e):
- print(
- f"Warning: '{style}' is a paragraph style, not a character style."
- )
- print(
- "For inline elements like , please create a character style in Word."
- )
-
- if not style or not hasattr(run, 'font'):
+ print(f"Warning: '{style}' is a paragraph style, not a character style.")
+ print("For inline elements like , please create a character style in Word.")
+
+ if not style or not hasattr(run, "font"):
return
# Find current paragraph and run position
- if not hasattr(self, 'paragraph') or self.paragraph is None:
+ if not hasattr(self, "paragraph") or self.paragraph is None:
return
paragraph_id = id(self.paragraph)
@@ -518,17 +506,17 @@ def apply_styles_to_run(self, run, style, isCustom=False):
for style_name, style_value in style.items():
if style_name in constants.RUN_STYLES:
- if style_name.startswith('background-color') and style_value in ('inherit', 'initial'):
+ if style_name.startswith("background-color") and style_value in ("inherit", "initial"):
continue
self.paragraph_span_styles[paragraph_id][run_index].add(style_name)
- if style_name == 'text-decoration':
+ if style_name == "text-decoration":
# If span sets text-decoration shorthand, it conflicts with all text-decoration-* properties
- self.paragraph_span_styles[paragraph_id][run_index].add('text-decoration-line')
- self.paragraph_span_styles[paragraph_id][run_index].add('text-decoration-style')
- self.paragraph_span_styles[paragraph_id][run_index].add('text-decoration-color')
- elif style_name.startswith('text-decoration-'):
+ self.paragraph_span_styles[paragraph_id][run_index].add("text-decoration-line")
+ self.paragraph_span_styles[paragraph_id][run_index].add("text-decoration-style")
+ self.paragraph_span_styles[paragraph_id][run_index].add("text-decoration-color")
+ elif style_name.startswith("text-decoration-"):
pass
for style_name, style_value in style.items():
@@ -536,7 +524,7 @@ def apply_styles_to_run(self, run, style, isCustom=False):
continue
elif style_name in constants.RUN_STYLES:
handler = getattr(self, constants.RUN_STYLES[style_name])
- param_name = style_name.replace('-', '_')
+ param_name = style_name.replace("-", "_")
handler(run=run, **{param_name: style_value})
else:
logging.warning(f"Warning: Unrecognized style '{style_name}', will be skipped.")
@@ -550,7 +538,7 @@ def apply_styles_to_paragraph(self, paragraph, style, isCustom=False):
print(f"Warning: Style '{style}' not found in document. Using default.")
return
- if not style or not hasattr(paragraph, 'paragraph_format'):
+ if not style or not hasattr(paragraph, "paragraph_format"):
return
for style_name, style_value in style.items():
@@ -562,40 +550,35 @@ def apply_styles_to_paragraph(self, paragraph, style, isCustom=False):
logging.warning(f"Warning: Unrecognized paragraph style '{style_name}', will be skipped.")
continue
- handler(
- paragraph=paragraph,
- style_name=style_name,
- value=style_value,
- all_styles=style
- )
+ handler(paragraph=paragraph, style_name=style_name, value=style_value, all_styles=style)
def _apply_alignment_paragraph(self, **kwargs):
- paragraph = kwargs['paragraph']
- value = kwargs['value']
+ paragraph = kwargs["paragraph"]
+ value = kwargs["value"]
align = utils.remove_important_from_style(value)
- if 'center' in align:
+ if "center" in align:
paragraph.alignment = WD_ALIGN_PARAGRAPH.CENTER
- elif 'left' in align:
+ elif "left" in align:
paragraph.alignment = WD_ALIGN_PARAGRAPH.LEFT
- elif 'right' in align:
+ elif "right" in align:
paragraph.alignment = WD_ALIGN_PARAGRAPH.RIGHT
- elif 'justify' in align:
+ elif "justify" in align:
paragraph.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
def _apply_line_height_paragraph(self, **kwargs):
- paragraph = kwargs['paragraph']
- value = kwargs['value']
+ paragraph = kwargs["paragraph"]
+ value = kwargs["value"]
line_height = utils.remove_important_from_style(value)
- if line_height in ('normal', 'inherit'):
+ if line_height in ("normal", "inherit"):
paragraph.paragraph_format.line_spacing = None
else:
try:
- if line_height.replace('.', '').replace('%', '').isdigit():
- multiplier = float(line_height[:-1]) / 100.0 if line_height.endswith('%') else float(line_height)
+ if line_height.replace(".", "").replace("%", "").isdigit():
+ multiplier = float(line_height[:-1]) / 100.0 if line_height.endswith("%") else float(line_height)
paragraph.paragraph_format.line_spacing = multiplier
else:
converted = utils.unit_converter(line_height, target_unit="pt")
@@ -605,35 +588,35 @@ def _apply_line_height_paragraph(self, **kwargs):
paragraph.paragraph_format.line_spacing = None
def _apply_margins_paragraph(self, **kwargs):
- paragraph = kwargs['paragraph']
- style_name = kwargs['style_name']
- all_styles = kwargs['all_styles']
+ paragraph = kwargs["paragraph"]
+ style_name = kwargs["style_name"]
+ all_styles = kwargs["all_styles"]
- margin_left = all_styles.get('margin-left')
- margin_right = all_styles.get('margin-right')
+ margin_left = all_styles.get("margin-left")
+ margin_right = all_styles.get("margin-right")
if margin_left and margin_right:
- if 'auto' in margin_left and 'auto' in margin_right:
+ if "auto" in margin_left and "auto" in margin_right:
paragraph.paragraph_format.alignment = WD_ALIGN_PARAGRAPH.CENTER
return
- if style_name == 'margin-left' and margin_left and 'auto' not in margin_left:
+ if style_name == "margin-left" and margin_left and "auto" not in margin_left:
paragraph.paragraph_format.left_indent = utils.unit_converter(margin_left)
- if style_name == 'margin-right' and margin_right and 'auto' not in margin_right:
+ if style_name == "margin-right" and margin_right and "auto" not in margin_right:
paragraph.paragraph_format.right_indent = utils.unit_converter(margin_right)
def _apply_text_indent_paragraph(self, **kwargs):
- paragraph = kwargs['paragraph']
- value = kwargs['value']
+ paragraph = kwargs["paragraph"]
+ value = kwargs["value"]
indent_value = utils.remove_important_from_style(value)
paragraph.paragraph_format.first_line_indent = utils.unit_converter(indent_value, target_unit="pt")
def _apply_font_weight_paragraph(self, **kwargs):
- paragraph = kwargs['paragraph']
- value = kwargs['value']
+ paragraph = kwargs["paragraph"]
+ value = kwargs["value"]
font_weight = utils.remove_important_from_style(value).lower()
@@ -641,7 +624,7 @@ def _apply_font_weight_paragraph(self, **kwargs):
paragraph_spans = self.paragraph_span_styles.get(paragraph_id, {})
for i, run in enumerate(paragraph.runs):
- if i in paragraph_spans and 'font-weight' in paragraph_spans[i]:
+ if i in paragraph_spans and "font-weight" in paragraph_spans[i]:
continue
self._apply_font_weight_to_run(
@@ -650,11 +633,11 @@ def _apply_font_weight_paragraph(self, **kwargs):
)
def _apply_font_weight_to_run(self, **kwargs):
- font_weight = kwargs['font_weight']
- run = kwargs['run']
- if font_weight in ('bold', 'bolder', '700', '800', '900'):
+ font_weight = kwargs["font_weight"]
+ run = kwargs["run"]
+ if font_weight in ("bold", "bolder", "700", "800", "900"):
run.font.bold = True
- elif font_weight in ('normal', 'lighter', '400', '300', '100'):
+ elif font_weight in ("normal", "lighter", "400", "300", "100"):
run.font.bold = False
# Note: Decide what to do for values between 400-700
elif font_weight.isdigit():
@@ -662,8 +645,8 @@ def _apply_font_weight_to_run(self, **kwargs):
run.font.bold = weight >= 700
def _apply_font_style_paragraph(self, **kwargs):
- paragraph = kwargs['paragraph']
- value = kwargs['value']
+ paragraph = kwargs["paragraph"]
+ value = kwargs["value"]
font_style = utils.remove_important_from_style(value).lower()
@@ -671,7 +654,7 @@ def _apply_font_style_paragraph(self, **kwargs):
paragraph_spans = self.paragraph_span_styles.get(paragraph_id, {})
for i, run in enumerate(paragraph.runs):
- if i in paragraph_spans and 'font-style' in paragraph_spans[i]:
+ if i in paragraph_spans and "font-style" in paragraph_spans[i]:
continue
self._apply_font_style_to_run(
@@ -680,17 +663,17 @@ def _apply_font_style_paragraph(self, **kwargs):
)
def _apply_font_style_to_run(self, **kwargs):
- font_style = kwargs['font_style']
- run = kwargs['run']
+ font_style = kwargs["font_style"]
+ run = kwargs["run"]
- if font_style in ('italic', 'oblique'):
+ if font_style in ("italic", "oblique"):
run.font.italic = True
- elif font_style == 'normal':
+ elif font_style == "normal":
run.font.italic = False
def _apply_font_size_paragraph(self, **kwargs):
- paragraph = kwargs['paragraph']
- value = kwargs['value']
+ paragraph = kwargs["paragraph"]
+ value = kwargs["value"]
font_size = utils.remove_important_from_style(value).lower()
@@ -701,7 +684,7 @@ def _apply_font_size_paragraph(self, **kwargs):
paragraph_spans = self.paragraph_span_styles.get(paragraph_id, {})
for i, run in enumerate(paragraph.runs):
- if i in paragraph_spans and 'font-size' in paragraph_spans[i]:
+ if i in paragraph_spans and "font-size" in paragraph_spans[i]:
continue
self._apply_font_size_to_run(
@@ -710,14 +693,14 @@ def _apply_font_size_paragraph(self, **kwargs):
)
def _apply_font_size_to_run(self, **kwargs):
- run = kwargs['run']
- font_size = kwargs['font_size']
+ run = kwargs["run"]
+ font_size = kwargs["font_size"]
font_size = utils.remove_important_from_style(font_size).lower()
font_size = utils.adapt_font_size(font_size)
try:
- if font_size in ('normal', 'initial', 'inherit'):
+ if font_size in ("normal", "initial", "inherit"):
run.font.size = None
else:
converted_size = utils.unit_converter(font_size, target_unit="pt")
@@ -728,8 +711,8 @@ def _apply_font_size_to_run(self, **kwargs):
logging.warning(f"Warning: Could not parse font-size '{font_size}': {e}")
def _apply_font_family_paragraph(self, **kwargs):
- paragraph = kwargs['paragraph']
- value = kwargs['value']
+ paragraph = kwargs["paragraph"]
+ value = kwargs["value"]
font_family = utils.remove_important_from_style(value).strip()
@@ -737,7 +720,7 @@ def _apply_font_family_paragraph(self, **kwargs):
paragraph_spans = self.paragraph_span_styles.get(paragraph_id, {})
for i, run in enumerate(paragraph.runs):
- if i in paragraph_spans and 'font-family' in paragraph_spans[i]:
+ if i in paragraph_spans and "font-family" in paragraph_spans[i]:
continue
self._apply_font_family_to_run(
@@ -746,21 +729,30 @@ def _apply_font_family_paragraph(self, **kwargs):
)
def _apply_font_family_to_run(self, **kwargs):
- run = kwargs['run']
- font_family = kwargs['font_family']
+ run = kwargs["run"]
+ font_family = kwargs["font_family"]
- if not font_family or font_family in ('inherit', 'initial', 'unset'):
+ if not font_family or font_family in ("inherit", "initial", "unset"):
return
try:
- font_families = [f.strip().strip('"\'') for f in font_family.split(',')]
+ font_families = [f.strip().strip("\"'") for f in font_family.split(",")]
for font_name in font_families:
- if font_name and font_name not in ('inherit', 'initial', 'unset', 'serif', 'sans-serif', 'monospace',
- 'cursive', 'fantasy', 'system-ui'):
+ if font_name and font_name not in (
+ "inherit",
+ "initial",
+ "unset",
+ "serif",
+ "sans-serif",
+ "monospace",
+ "cursive",
+ "fantasy",
+ "system-ui",
+ ):
run.font.name = font_name
break
- elif font_name in ('serif', 'sans-serif', 'monospace'):
+ elif font_name in ("serif", "sans-serif", "monospace"):
run.font.name = constants.GENERIC_FONT_STYLES[font_name]
break
@@ -768,17 +760,17 @@ def _apply_font_family_to_run(self, **kwargs):
logging.warning(f"Warning: Could not apply font-family '{font_family}': {e}")
def _apply_color_paragraph(self, **kwargs):
- paragraph = kwargs['paragraph']
- all_styles = kwargs['all_styles']
- color_value = utils.remove_important_from_style(all_styles.get('color', '')).lower().strip()
- if color_value in ('inherit', 'initial', 'transparent', 'currentcolor'):
+ paragraph = kwargs["paragraph"]
+ all_styles = kwargs["all_styles"]
+ color_value = utils.remove_important_from_style(all_styles.get("color", "")).lower().strip()
+ if color_value in ("inherit", "initial", "transparent", "currentcolor"):
return
paragraph_id = id(paragraph)
paragraph_spans = self.paragraph_span_styles.get(paragraph_id, {})
for i, run in enumerate(paragraph.runs):
- if i in paragraph_spans and 'color' in paragraph_spans[i]:
+ if i in paragraph_spans and "color" in paragraph_spans[i]:
continue
self._apply_color_to_run(
run=run,
@@ -786,8 +778,8 @@ def _apply_color_paragraph(self, **kwargs):
)
def _apply_color_to_run(self, **kwargs):
- run = kwargs['run']
- color_value = kwargs['color']
+ run = kwargs["run"]
+ color_value = kwargs["color"]
try:
colors = utils.parse_color(color_value)
run.font.color.rgb = RGBColor(*colors)
@@ -795,8 +787,8 @@ def _apply_color_to_run(self, **kwargs):
logging.warning(f"Could not apply color '{color_value}': {e}")
def _apply_text_transform_paragraph(self, **kwargs):
- paragraph = kwargs['paragraph']
- value = kwargs['value']
+ paragraph = kwargs["paragraph"]
+ value = kwargs["value"]
text_transform = utils.remove_important_from_style(value).lower()
@@ -804,7 +796,7 @@ def _apply_text_transform_paragraph(self, **kwargs):
paragraph_spans = self.paragraph_span_styles.get(paragraph_id, {})
for i, run in enumerate(paragraph.runs):
- if i in paragraph_spans and 'text-transform' in paragraph_spans[i]:
+ if i in paragraph_spans and "text-transform" in paragraph_spans[i]:
continue
self._apply_text_transform_to_run(
@@ -813,54 +805,50 @@ def _apply_text_transform_paragraph(self, **kwargs):
)
def _apply_text_transform_to_run(self, **kwargs):
- run = kwargs['run']
- text_transform = kwargs['text_transform']
+ run = kwargs["run"]
+ text_transform = kwargs["text_transform"]
if not run.text:
return
try:
- if text_transform == 'uppercase':
+ if text_transform == "uppercase":
run.text = run.text.upper()
- elif text_transform == 'lowercase':
+ elif text_transform == "lowercase":
run.text = run.text.lower()
- elif text_transform == 'capitalize':
+ elif text_transform == "capitalize":
run.text = run.text.title()
- elif text_transform in ('none', 'initial', 'inherit'):
+ elif text_transform in ("none", "initial", "inherit"):
# No transformation needed
pass
- elif text_transform in ('full-width', 'math-auto', 'full-size-kana'):
+ elif text_transform in ("full-width", "math-auto", "full-size-kana"):
logging.warning(f"Warning: Unsupported text transform '{text_transform}'")
except (AttributeError, Exception) as e:
logging.warning(f"Warning: Could not apply text-transform '{text_transform}': {e}")
def _apply_text_decoration_paragraph(self, **kwargs):
- paragraph = kwargs['paragraph']
- all_styles = kwargs['all_styles']
+ paragraph = kwargs["paragraph"]
+ all_styles = kwargs["all_styles"]
# Initialize decorations
- decorations = {
- 'line_type': None,
- 'line_style': None,
- 'color': None
- }
+ decorations = {"line_type": None, "line_style": None, "color": None}
- if 'text-decoration' in all_styles:
- text_decoration_value = utils.remove_important_from_style(all_styles['text-decoration']).lower()
+ if "text-decoration" in all_styles:
+ text_decoration_value = utils.remove_important_from_style(all_styles["text-decoration"]).lower()
decorations = utils.parse_text_decoration(text_decoration_value)
- if 'text-decoration-line' in all_styles:
- line_value = utils.remove_important_from_style(all_styles['text-decoration-line']).lower()
- decorations['line_type'] = line_value
+ if "text-decoration-line" in all_styles:
+ line_value = utils.remove_important_from_style(all_styles["text-decoration-line"]).lower()
+ decorations["line_type"] = line_value
- if 'text-decoration-style' in all_styles:
- style_value = utils.remove_important_from_style(all_styles['text-decoration-style']).lower()
- decorations['line_style'] = style_value
+ if "text-decoration-style" in all_styles:
+ style_value = utils.remove_important_from_style(all_styles["text-decoration-style"]).lower()
+ decorations["line_style"] = style_value
- if 'text-decoration-color' in all_styles:
- color_value = utils.remove_important_from_style(all_styles['text-decoration-color']).lower()
- decorations['color'] = color_value
+ if "text-decoration-color" in all_styles:
+ color_value = utils.remove_important_from_style(all_styles["text-decoration-color"]).lower()
+ decorations["color"] = color_value
paragraph_id = id(paragraph)
paragraph_spans = self.paragraph_span_styles.get(paragraph_id, {})
@@ -869,82 +857,82 @@ def _apply_text_decoration_paragraph(self, **kwargs):
span_styles = paragraph_spans.get(i, set())
# If span has text-decoration shorthand, skip entirely
- if 'text-decoration' in span_styles:
+ if "text-decoration" in span_styles:
continue
- if decorations['line_type'] and 'text-decoration-line' not in span_styles:
+ if decorations["line_type"] and "text-decoration-line" not in span_styles:
self._apply_text_decoration_line_to_run(
run=run,
- text_decoration_line=decorations['line_type'],
+ text_decoration_line=decorations["line_type"],
)
- if decorations['line_style'] and 'text-decoration-style' not in span_styles:
+ if decorations["line_style"] and "text-decoration-style" not in span_styles:
self._apply_text_decoration_style_to_run(
run=run,
- text_decoration_style=decorations['line_style'],
+ text_decoration_style=decorations["line_style"],
)
- if decorations['color'] and 'text-decoration-color' not in span_styles:
+ if decorations["color"] and "text-decoration-color" not in span_styles:
self._apply_text_decoration_color_to_run(
run=run,
- text_decoration_color=decorations['color'],
+ text_decoration_color=decorations["color"],
)
def _apply_text_decoration_to_run(self, **kwargs):
- run = kwargs['run']
- text_decoration = kwargs['text_decoration']
+ run = kwargs["run"]
+ text_decoration = kwargs["text_decoration"]
if not text_decoration:
return
decorations = utils.parse_text_decoration(text_decoration)
- if decorations['line_type']:
+ if decorations["line_type"]:
self._apply_text_decoration_line_to_run(
run=run,
- text_decoration_line=decorations['line_type'],
+ text_decoration_line=decorations["line_type"],
)
- if decorations['line_style']:
+ if decorations["line_style"]:
self._apply_text_decoration_style_to_run(
run=run,
- text_decoration_style=decorations['line_style'],
+ text_decoration_style=decorations["line_style"],
)
- if decorations['color']:
+ if decorations["color"]:
self._apply_text_decoration_color_to_run(
run=run,
- text_decoration_color=decorations['color'],
+ text_decoration_color=decorations["color"],
)
def _apply_text_decoration_line_to_run(self, **kwargs):
- run = kwargs['run']
- text_decoration_line = kwargs['text_decoration_line']
+ run = kwargs["run"]
+ text_decoration_line = kwargs["text_decoration_line"]
if text_decoration_line in constants.FONT_UNDERLINE:
- if text_decoration_line == 'underline':
+ if text_decoration_line == "underline":
run.font.underline = True
run.font.strike = False
- elif text_decoration_line == 'line-through':
+ elif text_decoration_line == "line-through":
run.font.strike = True
run.font.underline = False
- elif text_decoration_line == 'none':
+ elif text_decoration_line == "none":
run.font.underline = False
run.font.strike = False
else:
logging.warning(f"Warning: Unsupported text decoration '{text_decoration_line}'")
def _apply_text_decoration_style_to_run(self, **kwargs):
- run = kwargs['run']
- text_decoration_style = kwargs['text_decoration_style']
+ run = kwargs["run"]
+ text_decoration_style = kwargs["text_decoration_style"]
if not text_decoration_style or run.font.underline is False:
return False
should_apply = False
if run.font.underline:
should_apply = True
- elif hasattr(self.paragraph, '_pending_styles'):
+ elif hasattr(self.paragraph, "_pending_styles"):
for pending_style in self.paragraph._pending_styles:
- if 'text-decoration' in pending_style or 'text-decoration-line' in pending_style:
+ if "text-decoration" in pending_style or "text-decoration-line" in pending_style:
should_apply = True
break
@@ -959,31 +947,31 @@ def _apply_text_decoration_style_to_run(self, **kwargs):
paragraph_id = id(self.paragraph)
run_index = len(self.paragraph.runs) - 1
if paragraph_id in self.paragraph_span_styles and run_index in self.paragraph_span_styles[paragraph_id]:
- self.paragraph_span_styles[paragraph_id][run_index].add('text-decoration-line')
+ self.paragraph_span_styles[paragraph_id][run_index].add("text-decoration-line")
return True
def _apply_text_decoration_color_to_run(self, **kwargs):
- run = kwargs['run']
- text_decoration_color = kwargs['text_decoration_color']
+ run = kwargs["run"]
+ text_decoration_color = kwargs["text_decoration_color"]
if not text_decoration_color or not utils.is_color(text_decoration_color):
return
color_hex = utils.parse_color(text_decoration_color, return_hex=True)
rPr = run._r.get_or_add_rPr()
- u = rPr.find(qn('w:u'))
+ u = rPr.find(qn("w:u"))
if u is not None:
- u.set(qn('w:color'), color_hex.upper().lstrip('#'))
+ u.set(qn("w:color"), color_hex.upper().lstrip("#"))
def _apply_background_color_paragraph(self, **kwargs):
- paragraph = kwargs['paragraph']
- value = kwargs['value']
+ paragraph = kwargs["paragraph"]
+ value = kwargs["value"]
background_color = utils.remove_important_from_style(value).lower().strip()
- if background_color in ('inherit', 'initial'):
+ if background_color in ("inherit", "initial"):
return
- elif background_color in ('transparent', 'none'):
+ elif background_color in ("transparent", "none"):
logging.warning(f"Warning: Unsupported background color '{background_color}'")
return
@@ -996,7 +984,7 @@ def _apply_background_color_paragraph(self, **kwargs):
paragraph_spans = self.paragraph_span_styles.get(paragraph_id, {})
for i, run in enumerate(paragraph.runs):
- if i in paragraph_spans and 'background-color' in paragraph_spans[i]:
+ if i in paragraph_spans and "background-color" in paragraph_spans[i]:
continue
self._apply_background_color_to_run(
run=run,
@@ -1007,12 +995,12 @@ def _apply_background_color_paragraph(self, **kwargs):
logging.warning(f"Could not apply background-color to paragraph: {e}")
def _apply_background_color_to_run(self, **kwargs):
- run = kwargs['run']
- background_color = kwargs['background_color']
+ run = kwargs["run"]
+ background_color = kwargs["background_color"]
try:
- if background_color in ('inherit', 'initial'):
+ if background_color in ("inherit", "initial"):
return
- elif background_color in ('transparent', 'none'):
+ elif background_color in ("transparent", "none"):
logging.warning(f"Warning: Unsupported background color '{background_color}'")
return
@@ -1020,15 +1008,15 @@ def _apply_background_color_to_run(self, **kwargs):
if not color_hex:
return
- shd = OxmlElement('w:shd')
- shd.set(qn('w:val'), 'clear')
- shd.set(qn('w:color'), 'auto')
- shd.set(qn('w:fill'), color_hex.lstrip('#'))
+ shd = OxmlElement("w:shd")
+ shd.set(qn("w:val"), "clear")
+ shd.set(qn("w:color"), "auto")
+ shd.set(qn("w:fill"), color_hex.lstrip("#"))
r_pr = run._element.get_or_add_rPr()
# Remove existing shading
- existing_shd = r_pr.find(qn('w:shd'))
+ existing_shd = r_pr.find(qn("w:shd"))
if existing_shd is not None:
r_pr.remove(existing_shd)
@@ -1039,66 +1027,66 @@ def _apply_background_color_to_run(self, **kwargs):
def add_text_align_or_margin_to(self, obj, style):
"""Styles that can be applied on multiple objects"""
- if 'text-align' in style:
- align = utils.remove_important_from_style(style['text-align'])
+ if "text-align" in style:
+ align = utils.remove_important_from_style(style["text-align"])
- if 'center' in align:
+ if "center" in align:
obj.alignment = WD_ALIGN_PARAGRAPH.CENTER
- elif 'left' in align:
+ elif "left" in align:
obj.alignment = WD_ALIGN_PARAGRAPH.LEFT
- elif 'right' in align:
+ elif "right" in align:
obj.alignment = WD_ALIGN_PARAGRAPH.RIGHT
- elif 'justify' in align:
+ elif "justify" in align:
obj.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
- if 'margin-left' in style and 'margin-right' in style:
- if 'auto' in style['margin-left'] and 'auto' in style['margin-right']:
+ if "margin-left" in style and "margin-right" in style:
+ if "auto" in style["margin-left"] and "auto" in style["margin-right"]:
obj.alignment = WD_ALIGN_PARAGRAPH.CENTER
- elif 'margin-left' in style:
- obj.left_indent = utils.unit_converter(style['margin-left'])
+ elif "margin-left" in style:
+ obj.left_indent = utils.unit_converter(style["margin-left"])
def add_styles_to_table_cell(self, styles, doc_cell, cell_row):
"""Styles that must be applied specifically in a _Cell object"""
# Set background color
- if 'background-color' in styles:
- self.set_cell_background(doc_cell, styles['background-color'])
+ if "background-color" in styles:
+ self.set_cell_background(doc_cell, styles["background-color"])
# Set width (approximate, since DOCX uses different units)
- if 'width' in styles:
- doc_cell.width = utils.unit_converter(styles['width'])
+ if "width" in styles:
+ doc_cell.width = utils.unit_converter(styles["width"])
# Set height (due word limitations, cannot set individually cell height, only whole row)
- if 'height' in styles:
- cell_row.height = utils.unit_converter(styles['height'])
+ if "height" in styles:
+ cell_row.height = utils.unit_converter(styles["height"])
# Set text color
- if 'color' in styles:
- color = utils.parse_color(styles['color'])
+ if "color" in styles:
+ color = utils.parse_color(styles["color"])
if color:
for paragraph in doc_cell.paragraphs:
for run in paragraph.runs:
run.font.color.rgb = color
# Set vertical align (for individual cells)
- if 'vertical-align' in styles:
- align = utils.remove_important_from_style(styles['vertical-align'])
+ if "vertical-align" in styles:
+ align = utils.remove_important_from_style(styles["vertical-align"])
- if 'top' in align:
+ if "top" in align:
doc_cell.vertical_alignment = WD_ALIGN_VERTICAL.TOP
- elif 'middle' in align:
+ elif "middle" in align:
doc_cell.vertical_alignment = WD_ALIGN_VERTICAL.CENTER
- elif 'bottom' in align:
+ elif "bottom" in align:
doc_cell.vertical_alignment = WD_ALIGN_VERTICAL.BOTTOM
# Set borders
- if any('border' in style for style in styles.keys()):
+ if any("border" in style for style in styles.keys()):
self.set_cell_borders(doc_cell, styles)
self.add_text_align_or_margin_to(doc_cell.paragraphs[0], styles)
def add_styles_to_run(self, style):
- if 'font-size' in style:
- font_size = utils.remove_important_from_style(style['font-size'])
+ if "font-size" in style:
+ font_size = utils.remove_important_from_style(style["font-size"])
# Adapt font_size when text, ex.: small, medium, etc.
font_size = utils.adapt_font_size(font_size)
@@ -1106,21 +1094,21 @@ def add_styles_to_run(self, style):
for run in self.paragraph.runs:
run.font.size = utils.unit_converter(font_size)
- if 'color' in style:
- colors = utils.parse_color(style['color'])
+ if "color" in style:
+ colors = utils.parse_color(style["color"])
self.run.font.color.rgb = RGBColor(*colors)
- if 'background-color' in style:
+ if "background-color" in style:
# This should stay here for div.
# Little trick to apply background-color to paragraph
# because `self.run.font.highlight_color`
# has a very limited amount of colors
- color = utils.parse_color(style['background-color'], return_hex=True)
+ color = utils.parse_color(style["background-color"], return_hex=True)
- shd = OxmlElement('w:shd')
- shd.set(qn('w:val'), 'clear')
- shd.set(qn('w:color'), 'auto')
- shd.set(qn('w:fill'), color.lstrip('#'))
+ shd = OxmlElement("w:shd")
+ shd.set(qn("w:val"), "clear")
+ shd.set(qn("w:color"), "auto")
+ shd.set(qn("w:fill"), color.lstrip("#"))
# Make sure the paragraph styling element exists
self.paragraph.paragraph_format.element.get_or_add_pPr()
@@ -1129,15 +1117,15 @@ def add_styles_to_run(self, style):
self.paragraph.paragraph_format.element.pPr.append(shd)
def handle_li(self):
- '''
- Handle li tags
- source: https://stackoverflow.com/a/78685353/17274446
- '''
- list_depth = len(self.tags['list']) or 1
- list_type = self.tags['list'][-1] if self.tags['list'] else 'ul'
+ """
+ Handle li tags
+ source: https://stackoverflow.com/a/78685353/17274446
+ """
+ list_depth = len(self.tags["list"]) or 1
+ list_type = self.tags["list"][-1] if self.tags["list"] else "ul"
level = min(list_depth, 3)
style_key = list_type if level <= 1 else f"{list_type}{level}"
- list_style = constants.STYLES.get(style_key, 'List Number' if list_type == 'ol' else 'List Bullet')
+ list_style = constants.STYLES.get(style_key, "List Number" if list_type == "ol" else "List Bullet")
self.paragraph = self.doc.add_paragraph(style=list_style)
self.in_li = True
@@ -1152,7 +1140,7 @@ def handle_li(self):
style_obj = self.paragraph.style
num_id_style = None
- if hasattr(style_obj._element.pPr, 'numPr'):
+ if hasattr(style_obj._element.pPr, "numPr"):
num_id_style = style_obj._element.pPr.numPr.numId.val
if num_id_style is not None:
@@ -1176,13 +1164,13 @@ def handle_li(self):
# Assign this numId to the paragraph
pPr = self.paragraph._p.get_or_add_pPr()
- numPr = OxmlElement('w:numPr')
+ numPr = OxmlElement("w:numPr")
- numId_elem = OxmlElement('w:numId')
- numId_elem.set(qn('w:val'), str(new_num_id))
+ numId_elem = OxmlElement("w:numId")
+ numId_elem.set(qn("w:val"), str(new_num_id))
- ilvl = OxmlElement('w:ilvl')
- ilvl.set(qn('w:val'), str(level - 1))
+ ilvl = OxmlElement("w:ilvl")
+ ilvl.set(qn("w:val"), str(level - 1))
numPr.append(ilvl)
numPr.append(numId_elem)
@@ -1197,18 +1185,18 @@ def add_image_to_cell(self, cell, image, width=None, height=None):
def handle_img(self, current_attrs):
if not self.include_images:
self.skip = True
- self.skip_tag = 'img'
+ self.skip_tag = "img"
return
- if 'src' not in current_attrs:
+ if "src" not in current_attrs:
self.doc.add_paragraph("")
return
- src = current_attrs['src']
+ src = current_attrs["src"]
# added image dimension, interpreting values as pixel only
- height = utils.unit_converter(current_attrs['height']) if 'height' in current_attrs else None
- width = utils.unit_converter(current_attrs['width']) if 'width' in current_attrs else None
+ height = utils.unit_converter(utils.add_px(current_attrs["height"])) if "height" in current_attrs else None
+ width = utils.unit_converter(utils.add_px(current_attrs["width"])) if "width" in current_attrs else None
# fetch image
image = utils.fetch_image_data(src)
@@ -1235,14 +1223,14 @@ def handle_img(self, current_attrs):
# avoid exposing filepaths in document
self.doc.add_paragraph("" % utils.get_filename_from_url(src))
- '''
+ """
#adding style
For right-alignment: `'float: right;'`
For center-alignment: `'display: block; margin-left: auto; margin-right: auto;'`
Everything else would be Left aligned
- '''
- if 'style' in current_attrs:
- style = current_attrs['style']
+ """
+ if "style" in current_attrs:
+ style = current_attrs["style"]
image_alignment = utils.get_image_alignment(style)
last_paragraph = self.doc.paragraphs[-1]
if image_alignment == utils.ImageAlignment.RIGHT:
@@ -1268,7 +1256,7 @@ def handle_table(self, current_attrs):
try:
# Fixed 'style lookup by style_id is deprecated.'
# https://stackoverflow.com/a/29567907/17274446
- self.table_style = ' '.join(re.findall(r'[A-Z][a-z]*|[0-9]', self.table_style))
+ self.table_style = " ".join(re.findall(r"[A-Z][a-z]*|[0-9]", self.table_style))
# Available Table Styles
# https://python-docx.readthedocs.io/en/latest/user/styles-understanding.html#table-styles-in-default-template
self.table.style = self.table_style
@@ -1288,7 +1276,7 @@ def handle_table(self, current_attrs):
current_col = col_offset
cell_html = self.get_cell_html(col)
- if col.name == 'th':
+ if col.name == "th":
cell_html = "%s" % cell_html
# Get _Cell object from table based on cell_row and cell_col
@@ -1296,16 +1284,11 @@ def handle_table(self, current_attrs):
# Reference:
# https://python-docx.readthedocs.io/en/latest/dev/analysis/features/table/cell-merge.html
- rowspan = utils.safe_int(col.get('rowspan', 1))
- colspan = utils.safe_int(col.get('colspan', 1))
+ rowspan = utils.safe_int(col.get("rowspan", 1))
+ colspan = utils.safe_int(col.get("colspan", 1))
if rowspan > 1 or colspan > 1:
- docx_cell = docx_cell.merge(
- self.table.cell(
- current_row + (rowspan - 1),
- current_col + (colspan - 1)
- )
- )
+ docx_cell = docx_cell.merge(self.table.cell(current_row + (rowspan - 1), current_col + (colspan - 1)))
# Mark all merged cells as used
for r in range(current_row, current_row + rowspan):
@@ -1315,9 +1298,9 @@ def handle_table(self, current_attrs):
used_cells[current_row][current_col] = True
# Parse cell styles
- cell_styles = utils.parse_dict_string(col.get('style', ''))
+ cell_styles = utils.parse_dict_string(col.get("style", ""))
- if 'width' in cell_styles or 'height' in cell_styles:
+ if "width" in cell_styles or "height" in cell_styles:
self.table.autofit = False
self.table.allow_autofit = False
@@ -1328,13 +1311,13 @@ def handle_table(self, current_attrs):
col_offset += colspan # Move to the next real column
- if 'style' in current_attrs and self.table:
- style = utils.parse_dict_string(current_attrs['style'])
+ if "style" in current_attrs and self.table:
+ style = utils.parse_dict_string(current_attrs["style"])
self.add_text_align_or_margin_to(self.table, style)
# skip all tags until corresponding closing tag
- self.instances_to_skip = len(table_soup.find_all('table'))
- self.skip_tag = 'table'
+ self.instances_to_skip = len(table_soup.find_all("table"))
+ self.skip_tag = "table"
self.skip = True
self.table = None
@@ -1342,8 +1325,8 @@ def handle_div(self, current_attrs):
self.paragraph = self.doc.add_paragraph()
# handle page break
- if 'style' in current_attrs:
- style = current_attrs['style']
+ if "style" in current_attrs:
+ style = current_attrs["style"]
# Match CSS2 page-break-after: always or CSS3 break-after: page
# Using regex to ensure we match the exact property-value pairs
# Also handles optional !important flag
@@ -1355,21 +1338,42 @@ def handle_hr(self):
# https://github.com/python-openxml/python-docx/issues/105#issuecomment-62806373
self.paragraph = self.doc.add_paragraph()
pPr = self.paragraph._p.get_or_add_pPr()
- pBdr = OxmlElement('w:pBdr')
+ pBdr = OxmlElement("w:pBdr")
pPr.insert_element_before(
pBdr,
- 'w:shd', 'w:tabs', 'w:suppressAutoHyphens', 'w:kinsoku', 'w:wordWrap',
- 'w:overflowPunct', 'w:topLinePunct', 'w:autoSpaceDE', 'w:autoSpaceDN',
- 'w:bidi', 'w:adjustRightInd', 'w:snapToGrid', 'w:spacing', 'w:ind',
- 'w:contextualSpacing', 'w:mirrorIndents', 'w:suppressOverlap', 'w:jc',
- 'w:textDirection', 'w:textAlignment', 'w:textboxTightWrap',
- 'w:outlineLvl', 'w:divId', 'w:cnfStyle', 'w:rPr', 'w:sectPr', 'w:pPrChange'
+ "w:shd",
+ "w:tabs",
+ "w:suppressAutoHyphens",
+ "w:kinsoku",
+ "w:wordWrap",
+ "w:overflowPunct",
+ "w:topLinePunct",
+ "w:autoSpaceDE",
+ "w:autoSpaceDN",
+ "w:bidi",
+ "w:adjustRightInd",
+ "w:snapToGrid",
+ "w:spacing",
+ "w:ind",
+ "w:contextualSpacing",
+ "w:mirrorIndents",
+ "w:suppressOverlap",
+ "w:jc",
+ "w:textDirection",
+ "w:textAlignment",
+ "w:textboxTightWrap",
+ "w:outlineLvl",
+ "w:divId",
+ "w:cnfStyle",
+ "w:rPr",
+ "w:sectPr",
+ "w:pPrChange",
)
- bottom = OxmlElement('w:bottom')
- bottom.set(qn('w:val'), 'single')
- bottom.set(qn('w:sz'), '6')
- bottom.set(qn('w:space'), '1')
- bottom.set(qn('w:color'), 'auto')
+ bottom = OxmlElement("w:bottom")
+ bottom.set(qn("w:val"), "single")
+ bottom.set(qn("w:sz"), "6")
+ bottom.set(qn("w:space"), "1")
+ bottom.set(qn("w:color"), "auto")
pBdr.append(bottom)
def handle_custom_tag_styles(self, tag):
@@ -1386,13 +1390,13 @@ def handle_mark(self):
"""
Apply default styling using Word shading (yellow highlight).
"""
- shd = OxmlElement('w:shd')
- shd.set(qn('w:val'), 'clear')
- shd.set(qn('w:color'), 'auto')
- shd.set(qn('w:fill'), 'FFFF00') # Yellow - default color
+ shd = OxmlElement("w:shd")
+ shd.set(qn("w:val"), "clear")
+ shd.set(qn("w:color"), "auto")
+ shd.set(qn("w:fill"), "FFFF00") # Yellow - default color
r_pr = self.run._element.get_or_add_rPr()
# Remove existing shading if present
- existing_shd = r_pr.find(qn('w:shd'))
+ existing_shd = r_pr.find(qn("w:shd"))
if existing_shd is not None:
r_pr.remove(existing_shd)
r_pr.append(shd)
@@ -1406,39 +1410,35 @@ def handle_link(self, href, text, tooltip=None):
text: The text displayed for the url.
tooltip: The text displayed when holder link.
"""
- is_external = href.startswith('http') if href else False
- hyperlink = OxmlElement('w:hyperlink')
+ is_external = href.startswith("http") if href else False
+ hyperlink = OxmlElement("w:hyperlink")
if is_external:
# Create external hyperlink
- rel_id = self.paragraph.part.relate_to(
- href,
- docx.opc.constants.RELATIONSHIP_TYPE.HYPERLINK,
- is_external=True
- )
+ rel_id = self.paragraph.part.relate_to(href, docx.opc.constants.RELATIONSHIP_TYPE.HYPERLINK, is_external=True)
# Create the w:hyperlink tag and add needed values
- hyperlink.set(qn('r:id'), rel_id)
+ hyperlink.set(qn("r:id"), rel_id)
else:
# Create internal hyperlink (anchor)
- hyperlink.set(qn('w:anchor'), href.replace('#', ''))
+ hyperlink.set(qn("w:anchor"), href.replace("#", ""))
if tooltip is not None:
# set tooltip to hyperlink
- hyperlink.set(qn('w:tooltip'), tooltip)
+ hyperlink.set(qn("w:tooltip"), tooltip)
# Create sub-run
subrun = self.paragraph.add_run()
- rPr = OxmlElement('w:rPr')
+ rPr = OxmlElement("w:rPr")
# add default color
- c = OxmlElement('w:color')
- c.set(qn('w:val'), "0000EE")
+ c = OxmlElement("w:color")
+ c.set(qn("w:val"), "0000EE")
rPr.append(c)
# add underline
- u = OxmlElement('w:u')
- u.set(qn('w:val'), 'single')
+ u = OxmlElement("w:u")
+ u.set(qn("w:val"), "single")
rPr.append(u)
subrun._r.append(rPr)
@@ -1453,41 +1453,39 @@ def handle_link(self, href, text, tooltip=None):
def handle_starttag(self, tag, attrs):
if self.skip:
return
- if tag == 'head':
+ if tag == "head":
self.skip = True
self.skip_tag = tag
self.instances_to_skip = 0
return
- elif tag == 'body':
+ elif tag == "body":
return
current_attrs = dict(attrs)
- if tag == 'span':
+ if tag == "span":
# Parse inline styles if present to check for !important
if "style" in current_attrs:
- normal_styles, important_styles = utils.parse_inline_styles(
- current_attrs["style"]
- )
+ normal_styles, important_styles = utils.parse_inline_styles(current_attrs["style"])
# Store normal styles to apply to runs
if normal_styles:
self.pending_inline_styles = normal_styles
# Store important styles to apply after parent's processing
if important_styles:
self.pending_important_styles = important_styles
- self.tags['span'].append(current_attrs)
+ self.tags["span"].append(current_attrs)
return
- elif tag in ['ol', 'ul']:
- if tag == 'ol':
+ elif tag in ["ol", "ul"]:
+ if tag == "ol":
# Assign new ID if it's a fresh top-level list
self.list_restart_counter += 1
self.current_ol_num_id = self.list_restart_counter
else:
self.current_ol_num_id = None # unordered list
- self.tags['list'].append(tag)
- return # don't apply styles for now
- elif tag == 'br':
+ self.tags["list"].append(tag)
+ return # don't apply styles for now
+ elif tag == "br":
try:
self.run.add_break()
except AttributeError:
@@ -1500,9 +1498,7 @@ def handle_starttag(self, tag, attrs):
# Control custom_style based on the Options. Default is True on both.
custom_style = (
- self.get_word_style_for_element(tag, current_attrs)
- if (self.use_styles or self.use_tag_overrides)
- else None
+ self.get_word_style_for_element(tag, current_attrs) if (self.use_styles or self.use_tag_overrides) else None
)
if custom_style:
@@ -1522,9 +1518,7 @@ def handle_starttag(self, tag, attrs):
# Parse inline styles on the paragraph itself to apply to runs within
if "style" in current_attrs:
- normal_styles, important_styles = utils.parse_inline_styles(
- current_attrs["style"]
- )
+ normal_styles, important_styles = utils.parse_inline_styles(current_attrs["style"])
if normal_styles:
self.pending_inline_styles = normal_styles
if important_styles:
@@ -1534,15 +1528,15 @@ def handle_starttag(self, tag, attrs):
self.pending_div_style = custom_style
else:
self.handle_div(current_attrs)
- elif tag == 'li':
+ elif tag == "li":
self.handle_li()
if custom_style and self.paragraph:
self.apply_styles_to_paragraph(self.paragraph, custom_style, True)
- elif tag == 'hr':
+ elif tag == "hr":
self.handle_hr()
- elif re.match('h[1-9]', tag):
+ elif re.match("h[1-9]", tag):
if isinstance(self.doc, docx.document.Document):
if custom_style:
self.paragraph = self.doc.add_paragraph()
@@ -1555,44 +1549,42 @@ def handle_starttag(self, tag, attrs):
if custom_style:
self.apply_styles_to_paragraph(self.paragraph, custom_style, True)
- elif tag == 'img':
+ elif tag == "img":
self.handle_img(current_attrs)
self.paragraph = self.doc.paragraphs[-1]
- elif tag == 'table':
+ elif tag == "table":
if self.include_tables:
self.handle_table(current_attrs)
return
- elif tag == 'code':
+ elif tag == "code":
# Character style for inline code (pre uses paragraph style in the ["p", "pre"] branch)
if custom_style:
self.pending_character_style = custom_style
if "style" in current_attrs:
- normal_styles, important_styles = utils.parse_inline_styles(
- current_attrs["style"]
- )
+ normal_styles, important_styles = utils.parse_inline_styles(current_attrs["style"])
if normal_styles:
self.pending_inline_styles = normal_styles
if important_styles:
self.pending_important_styles = important_styles
return
- if 'id' in current_attrs:
- self.add_bookmark(current_attrs['id'])
+ if "id" in current_attrs:
+ self.add_bookmark(current_attrs["id"])
# add style
if not self.include_styles:
return
- if 'style' in current_attrs and self.paragraph and (tag in ['p'] or re.match(r'h[1-9]', tag)):
- if not hasattr(self.paragraph, '_pending_styles'):
+ if "style" in current_attrs and self.paragraph and (tag in ["p"] or re.match(r"h[1-9]", tag)):
+ if not hasattr(self.paragraph, "_pending_styles"):
self.paragraph._pending_styles = []
- style = utils.parse_dict_string(current_attrs['style'])
+ style = utils.parse_dict_string(current_attrs["style"])
self.paragraph._pending_styles.append(style)
- elif 'style' in current_attrs and self.paragraph:
- style = utils.parse_dict_string(current_attrs['style'])
+ elif "style" in current_attrs and self.paragraph:
+ style = utils.parse_dict_string(current_attrs["style"])
self.add_text_align_or_margin_to(self.paragraph.paragraph_format, style)
def handle_endtag(self, tag):
@@ -1615,7 +1607,7 @@ def handle_endtag(self, tag):
self.pending_inline_styles = None
self.pending_important_styles = None
- if re.match('h[1-9]', tag):
+ if re.match("h[1-9]", tag):
self.pending_inline_styles = None
self.pending_important_styles = None
@@ -1631,26 +1623,26 @@ def handle_endtag(self, tag):
self.skip_tag = None
self.paragraph = None
- if tag == 'span':
- if self.tags['span']:
- self.tags['span'].pop()
+ if tag == "span":
+ if self.tags["span"]:
+ self.tags["span"].pop()
return
- elif tag in ['ol', 'ul']:
- utils.remove_last_occurence(self.tags['list'], tag)
- if tag == 'ol':
+ elif tag in ["ol", "ul"]:
+ utils.remove_last_occurence(self.tags["list"], tag)
+ if tag == "ol":
self._list_num_ids.pop(self.current_ol_num_id, None)
self.current_ol_num_id = None
return
- elif tag == 'table':
+ elif tag == "table":
if self.include_tables:
self.table_no += 1
self.table = None
self.paragraph = None
- elif tag == 'li':
+ elif tag == "li":
self.in_li = False
- if tag in ['p', 'pre'] or re.match(r'h[1-9]', tag):
- if hasattr(self.paragraph, '_pending_styles'):
+ if tag in ["p", "pre"] or re.match(r"h[1-9]", tag):
+ if hasattr(self.paragraph, "_pending_styles"):
for style in self.paragraph._pending_styles:
self.apply_styles_to_paragraph(self.paragraph, style)
# Clear the pending styles
@@ -1666,7 +1658,7 @@ def handle_data(self, data):
return
# Only remove white space if we're not in a pre block.
- if 'pre' not in self.tags:
+ if "pre" not in self.tags:
# remove leading and trailing whitespace in all instances
data = utils.remove_whitespace(data, True, True)
@@ -1676,9 +1668,9 @@ def handle_data(self, data):
# There can only be one nested link in a valid html document
# You cannot have interactive content in an A tag, this includes links
# https://html.spec.whatwg.org/#interactive-content
- link = self.tags.get('a', {})
- href = link.get('href', None)
- title = link.get('title', None)
+ link = self.tags.get("a", {})
+ href = link.get("href", None)
+ title = link.get("title", None)
if link and href:
self.handle_link(href, data, title)
@@ -1691,20 +1683,20 @@ def handle_data(self, data):
if self.pending_character_style:
self.apply_styles_to_run(self.run, self.pending_character_style, isCustom=True)
- for span in self.tags['span']:
- if 'style' in span:
- span_style = utils.parse_dict_string(span['style'])
+ for span in self.tags["span"]:
+ if "style" in span:
+ span_style = utils.parse_dict_string(span["style"])
self.apply_styles_to_run(self.run, span_style)
for tag, attrs in self.tags.items():
- if tag == 'div' and 'style' in attrs:
- div_style = utils.parse_dict_string(attrs['style'])
+ if tag == "div" and "style" in attrs:
+ div_style = utils.parse_dict_string(attrs["style"])
for span_style_name in span_style.keys():
if span_style_name in div_style:
del div_style[span_style_name]
- self.tags[tag]['style'] = utils.dict_to_style_string(div_style)
+ self.tags[tag]["style"] = utils.dict_to_style_string(div_style)
for tag, attrs in self.tags.items():
if self.use_tag_overrides and tag in self.tag_style_overrides:
@@ -1712,7 +1704,7 @@ def handle_data(self, data):
if tag in constants.FONT_STYLES:
font_style = constants.FONT_STYLES[tag]
- if font_style == 'custom':
+ if font_style == "custom":
self.handle_custom_tag_styles(tag)
else:
setattr(self.run.font, font_style, True)
@@ -1721,8 +1713,8 @@ def handle_data(self, data):
font_name = constants.FONT_NAMES[tag]
self.run.font.name = font_name
- if 'style' in attrs and (tag in ['div', 'li', 'pre']):
- style = utils.parse_dict_string(attrs['style'])
+ if "style" in attrs and (tag in ["div", "li", "pre"]):
+ style = utils.parse_dict_string(attrs["style"])
self.add_styles_to_run(style)
def handle_comment(self, data):
@@ -1759,16 +1751,16 @@ def ignore_nested_tables(self, tables_soup):
nest -= 1
continue
new_tables.append(table)
- nest = len(table.find_all('table'))
+ nest = len(table.find_all("table"))
return new_tables
def get_table_rows(self, table_soup):
# If there's a header, body, footer or direct child tr tags, add row dimensions from there
- return table_soup.select(', '.join(self.table_row_selectors), recursive=False)
+ return table_soup.select(", ".join(self.table_row_selectors), recursive=False)
def get_table_columns(self, row):
# Get all columns for the specified row tag.
- return row.find_all(['th', 'td'], recursive=False) if row else []
+ return row.find_all(["th", "td"], recursive=False) if row else []
def get_table_dimensions(self, table_soup):
# Get rows for the table
@@ -1787,28 +1779,28 @@ def get_table_dimensions(self, table_soup):
for row_idx, row in enumerate(rows):
cols = self.get_table_columns(row)
# Handle colspan
- row_col_count = sum(utils.safe_int(col.get('colspan', default_span)) for col in cols)
+ row_col_count = sum(utils.safe_int(col.get("colspan", default_span)) for col in cols)
max_cols = max(max_cols, row_col_count)
# Handle rowspan
for col in cols:
- rowspan = utils.safe_int(col.get('rowspan', default_span))
+ rowspan = utils.safe_int(col.get("rowspan", default_span))
if rowspan > default_span:
max_rows = max(max_rows, row_idx + rowspan)
return max_rows, max_cols
def get_tables(self) -> None:
- if not hasattr(self, 'soup'):
- self.options['tables'] = False
+ if not hasattr(self, "soup"):
+ self.options["tables"] = False
return
- self.tables = self.ignore_nested_tables(self.soup.find_all('table'))
+ self.tables = self.ignore_nested_tables(self.soup.find_all("table"))
self.table_no = 0
def run_process(self, html: str) -> None:
if self.bs and BeautifulSoup:
- self.soup = BeautifulSoup(html, 'html.parser')
+ self.soup = BeautifulSoup(html, "html.parser")
html = str(self.soup)
if self.include_tables:
@@ -1817,16 +1809,16 @@ def run_process(self, html: str) -> None:
def add_html_to_document(self, html: str, document) -> None:
if not isinstance(html, str):
- raise ValueError(f'First argument needs to be a {str}')
+ raise ValueError(f"First argument needs to be a {str}")
elif not isinstance(document, docx.document.Document) and not isinstance(document, docx.table._Cell):
- raise ValueError(f'Second argument needs to be a {docx.document.Document}')
+ raise ValueError(f"Second argument needs to be a {docx.document.Document}")
self.set_initial_attrs(document)
self.run_process(html)
def add_html_to_cell(self, html: str, cell: docx.table._Cell) -> None:
if not isinstance(cell, docx.table._Cell):
- raise ValueError(f'Second argument needs to be a {docx.table._Cell}')
+ raise ValueError(f"Second argument needs to be a {docx.table._Cell}")
unwanted_paragraph = cell.paragraphs[0]
utils.delete_paragraph(unwanted_paragraph)
@@ -1835,10 +1827,10 @@ def add_html_to_cell(self, html: str, cell: docx.table._Cell) -> None:
# cells must end with a paragraph or will get message about corrupt file
# https://stackoverflow.com/a/29287121
if not self.doc.paragraphs:
- self.doc.add_paragraph('')
+ self.doc.add_paragraph("")
- def parse_html_file(self, filename_html: str, filename_docx, encoding: str = 'utf-8') -> None:
- with open(filename_html, 'r', encoding=encoding) as infile:
+ def parse_html_file(self, filename_html: str, filename_docx, encoding: str = "utf-8") -> None:
+ with open(filename_html, "r", encoding=encoding) as infile:
html = infile.read()
self.set_initial_attrs()
@@ -1846,7 +1838,7 @@ def parse_html_file(self, filename_html: str, filename_docx, encoding: str = 'ut
if not filename_docx:
path, filename = os.path.split(filename_html)
- filename_docx = f'{path}/new_docx_file_{filename}'
+ filename_docx = f"{path}/new_docx_file_{filename}"
self.save(filename_docx)
@@ -1855,19 +1847,19 @@ def parse_html_string(self, html: str) -> docx.document.Document:
self.run_process(html)
return self.doc
-if __name__ == '__main__':
- arg_parser = argparse.ArgumentParser(description='Convert .html file into .docx file with formatting')
- arg_parser.add_argument('filename_html', help='The .html file to be parsed')
+
+if __name__ == "__main__":
+ arg_parser = argparse.ArgumentParser(description="Convert .html file into .docx file with formatting")
+ arg_parser.add_argument("filename_html", help="The .html file to be parsed")
arg_parser.add_argument(
- 'filename_docx',
- nargs='?',
- help='The name of the .docx file to be saved. Default new_docx_file_[filename_html]',
- default=None
+ "filename_docx",
+ nargs="?",
+ help="The name of the .docx file to be saved. Default new_docx_file_[filename_html]",
+ default=None,
)
- arg_parser.add_argument('--bs', action='store_true',
- help='Attempt to fix html before parsing. Requires bs4. Default True')
+ arg_parser.add_argument("--bs", action="store_true", help="Attempt to fix html before parsing. Requires bs4. Default True")
args = vars(arg_parser.parse_args())
- file_html = args.pop('filename_html')
+ file_html = args.pop("filename_html")
html_parser = HtmlToDocx()
html_parser.parse_html_file(file_html, **args)
diff --git a/html4docx/utils.py b/html4docx/utils.py
index 1f0cac4..1ffcf14 100644
--- a/html4docx/utils.py
+++ b/html4docx/utils.py
@@ -23,9 +23,11 @@ class ImageAlignment(Enum):
def get_filename_from_url(url: str):
return os.path.basename(urlparse(url).path)
+
def dict_to_style_string(style_dict):
"""Convert style dictionary back to CSS string"""
- return '; '.join([f'{k}: {v}' for k, v in style_dict.items()])
+ return "; ".join([f"{k}: {v}" for k, v in style_dict.items()])
+
def is_url(url: str):
"""
@@ -87,18 +89,33 @@ def parse_dict_string(string: str, separator: str = ";"):
return dict()
new_string = re.sub(r"\s+", " ", string.replace("\n", "")).split(separator)
- string_dict = dict(
- (k.strip(), v.strip())
- for x in new_string
- if ":" in x
- for k, v in [x.split(":", 1)]
- )
+ string_dict = dict((k.strip(), v.strip()) for x in new_string if ":" in x for k, v in [x.split(":", 1)])
return string_dict
+def add_px(value):
+ """
+ Append 'px' only if the value is purely numeric (int, float, or numeric string).
+ If there is any non-numeric character, return the original value unchanged.
+ """
+ if isinstance(value, (int, float)):
+ return f"{value}px"
+
+ if isinstance(value, str):
+ stripped = value.strip()
+
+ # Check if it's a valid number (integer or float)
+ if stripped.replace(".", "", 1).isdigit():
+ return f"{stripped}px"
+
+ return value
+
+ return value
+
+
def unit_converter(unit_value: str, target_unit: str = "pt"):
"""
- Converts a CSS unit value to a target unit (default is 'pt').
+ Converts a CSS unit value (default px) to a target unit (default is 'pt').
Supported input units: px, pt, in, pc, cm, mm, em, rem, %.
Supported target units: pt, px, in, cm, mm.
@@ -141,9 +158,7 @@ def unit_converter(unit_value: str, target_unit: str = "pt"):
return None
# Clamp the value to MAX_INDENT (in points)
- value_in_pt = min(
- value_in_pt, constants.MAX_INDENT * 72.0
- ) # MAX_INDENT is in inches
+ value_in_pt = min(value_in_pt, constants.MAX_INDENT * 72.0)
# Convert from points (pt) to the target unit
conversion_from_pt = {
@@ -181,9 +196,9 @@ def is_color(color: str) -> bool:
>>> is_color("000000")
False
"""
- is_rgb = 'rgb' in color
- is_hex = color.startswith('#')
- is_keyword = color == 'currentcolor'
+ is_rgb = "rgb" in color
+ is_hex = color.startswith("#")
+ is_keyword = color == "currentcolor"
is_color_name = color in Color.__members__
return is_rgb or is_hex or is_keyword or is_color_name
@@ -200,7 +215,7 @@ def parse_color(original_color: str, return_hex: bool = False):
if "rgba" in color:
color = re.sub(r"[^0-9,]", "", color)
colors = [int(x) for x in color.split(",")]
- colors = colors[:3] # remove opacity because it's not supported by python-docx
+ colors = colors[:3] # remove opacity because it's not supported by python-docx
logging.warning("RGBA color is not supported by python-docx. Opacity will be ignored.")
elif "rgb" in color:
color = re.sub(r"[^0-9,]", "", color)
@@ -209,7 +224,7 @@ def parse_color(original_color: str, return_hex: bool = False):
raise ValueError(f"Invalid RGB color: {original_color}")
elif color.startswith("#"):
color = color.lstrip("#")
- color = ("".join([x + x for x in color]) if len(color) == 3 else color) # convert short hex to full hex
+ color = "".join([x + x for x in color]) if len(color) == 3 else color # convert short hex to full hex
colors = RGBColor.from_string(color)
elif color in Color.__members__:
colors = Color[color].value
@@ -217,7 +232,7 @@ def parse_color(original_color: str, return_hex: bool = False):
colors = [0, 0, 0] # Default to black for unexpected colors
logging.warning(f"Could not parse color '{original_color}': Invalid color value. Fallback to black.")
except Exception:
- colors = [0, 0, 0] # Default to black for errors
+ colors = [0, 0, 0] # Default to black for errors
logging.warning(f"Could not parse color '{original_color}': Invalid color value. Fallback to black.")
return rgb_to_hex(colors) if return_hex else colors
diff --git a/tests/test_h4d.py b/tests/test_h4d.py
index 685df09..8aa4a30 100644
--- a/tests/test_h4d.py
+++ b/tests/test_h4d.py
@@ -3,14 +3,16 @@
import unittest
from io import BytesIO
from pathlib import Path
+
from docx import Document
-from docx.shared import Pt, RGBColor
-from docx.oxml.ns import qn
-from docx.enum.text import WD_ALIGN_PARAGRAPH, WD_UNDERLINE
from docx.enum.style import WD_STYLE_TYPE
+from docx.enum.text import WD_ALIGN_PARAGRAPH, WD_UNDERLINE
+from docx.oxml.ns import qn
+from docx.shared import Pt, RGBColor
+
from html4docx import HtmlToDocx
-from html4docx.utils import unit_converter, parse_color
from html4docx.colors import Color
+from html4docx.utils import parse_color, unit_converter
test_dir = os.path.abspath(os.path.dirname(__file__))
@@ -24,8 +26,8 @@ def clean_up_docx():
@staticmethod
def get_html_from_file(filename: str):
- file_path = Path(f'{test_dir}/assets/htmls') / Path(filename)
- with open(file_path, 'r') as f:
+ file_path = Path(f"{test_dir}/assets/htmls") / Path(filename)
+ with open(file_path, "r") as f:
html = f.read()
return html
@@ -43,12 +45,12 @@ def get_underline_color(run):
Extract underline color from the run XML.
Returns hex string like 'FF0000' or None.
"""
- u_elems = run._r.xpath('.//w:u')
+ u_elems = run._r.xpath(".//w:u")
if not u_elems:
return None
u_elem = u_elems[0]
- return u_elem.get(qn('w:color'))
+ return u_elem.get(qn("w:color"))
@staticmethod
def get_run_shading_fill(run):
@@ -56,13 +58,13 @@ def get_run_shading_fill(run):
Extract shading fill color from the run XML (e.g. for ).
Returns hex string like 'FFFF00' or None if no shading.
"""
- r_pr = run._element.find(qn('w:rPr'))
+ r_pr = run._element.find(qn("w:rPr"))
if r_pr is None:
return None
- shd = r_pr.find(qn('w:shd'))
+ shd = r_pr.find(qn("w:shd"))
if shd is None:
return None
- return (shd.get(qn('w:fill')) or "").upper()
+ return (shd.get(qn("w:fill")) or "").upper()
@staticmethod
def save_document_on_buffer(document: Document) -> BytesIO:
@@ -76,19 +78,19 @@ def save_document_on_buffer(document: Document) -> BytesIO:
def setUpClass(cls):
cls.clean_up_docx()
cls.document = Document()
- cls.text1 = cls.get_html_from_file('text1.html')
- cls.paragraph_line_height = cls.get_html_from_file('paragraph_line_height.html')
- cls.paragraph_first_line_indent = cls.get_html_from_file('paragraph_first_line_indent.html')
- cls.text_decoration = cls.get_html_from_file('text_decoration.html')
- cls.css_properties = cls.get_html_from_file('css_properties.html')
- cls.css_properties_header = cls.get_html_from_file('header.html')
- cls.table_html = cls.get_html_from_file('tables1.html')
- cls.table2_html = cls.get_html_from_file('tables2.html')
- cls.table3_html = cls.get_html_from_file('tables3.html')
+ cls.text1 = cls.get_html_from_file("text1.html")
+ cls.paragraph_line_height = cls.get_html_from_file("paragraph_line_height.html")
+ cls.paragraph_first_line_indent = cls.get_html_from_file("paragraph_first_line_indent.html")
+ cls.text_decoration = cls.get_html_from_file("text_decoration.html")
+ cls.css_properties = cls.get_html_from_file("css_properties.html")
+ cls.css_properties_header = cls.get_html_from_file("header.html")
+ cls.table_html = cls.get_html_from_file("tables1.html")
+ cls.table2_html = cls.get_html_from_file("tables2.html")
+ cls.table3_html = cls.get_html_from_file("tables3.html")
@classmethod
def tearDownClass(cls):
- outputpath = os.path.join(test_dir, 'test.docx')
+ outputpath = os.path.join(test_dir, "test.docx")
cls.document.save(outputpath)
def setUp(self):
@@ -96,7 +98,7 @@ def setUp(self):
# ============================== Tests ============================== #
def test_save_docx_by_filename(self):
- filename = os.path.join(test_dir, 'new_test.docx')
+ filename = os.path.join(test_dir, "new_test.docx")
self.parser.set_initial_attrs(self.document)
self.parser.save(filename)
self.assertTrue(os.path.exists(filename))
@@ -110,59 +112,41 @@ def test_save_docx_by_buffer(self):
self.assertTrue(buffer.getvalue())
def test_html_with_images_links_style(self):
- self.document.add_heading(
- 'Test: add regular html with images, links and some formatting to document',
- level=1
- )
+ self.document.add_heading("Test: add regular html with images, links and some formatting to document", level=1)
self.parser.add_html_to_document(self.text1, self.document)
def test_html_with_default_paragraph_style(self):
- self.document.add_heading(
- 'Test: add regular html with a default paragraph style defined',
- level=1
- )
- self.parser.paragraph_style = 'Quote'
+ self.document.add_heading("Test: add regular html with a default paragraph style defined", level=1)
+ self.parser.paragraph_style = "Quote"
self.parser.add_html_to_document(self.text1, self.document)
def test_add_html_to_table_cell_with_default_paragraph_style(self):
- self.document.add_heading(
- 'Test: regular html to table cell with a default paragraph style defined',
- level=1
- )
- self.parser.paragraph_style = 'Quote'
- table = self.document.add_table(1, 2, style='Table Grid')
+ self.document.add_heading("Test: regular html to table cell with a default paragraph style defined", level=1)
+ self.parser.paragraph_style = "Quote"
+ table = self.document.add_table(1, 2, style="Table Grid")
cell = table.cell(0, 1)
self.parser.add_html_to_document(self.text1, cell)
def test_add_html_to_table_cell(self):
- self.document.add_heading(
- 'Test: regular html with images, links, some formatting to table cell',
- level=1
- )
- table = self.document.add_table(1, 2, style='Table Grid')
+ self.document.add_heading("Test: regular html with images, links, some formatting to table cell", level=1)
+ table = self.document.add_table(1, 2, style="Table Grid")
cell = table.cell(0, 1)
self.parser.add_html_to_document(self.text1, cell)
def test_add_html_skip_images(self):
- self.document.add_heading(
- 'Test: regular html with images, but skip adding images',
- level=1
- )
- self.parser.options['images'] = False
+ self.document.add_heading("Test: regular html with images, but skip adding images", level=1)
+ self.parser.options["images"] = False
self.parser.add_html_to_document(self.text1, self.document)
document = self.parser.parse_html_string(self.text1)
- assert any(['Graphic' in paragraph._p.xml for paragraph in document.paragraphs]) is False
+ assert any(["Graphic" in paragraph._p.xml for paragraph in document.paragraphs]) is False
def test_add_html_with_tables(self):
- self.document.add_heading(
- 'Test: add html with tables (by default no borders)',
- level=1
- )
+ self.document.add_heading("Test: add html with tables (by default no borders)", level=1)
self.parser.add_html_to_document(self.table_html, self.document)
# When no table style is set, use Normal Table as default
- table_style = 'Normal Table'
+ table_style = "Normal Table"
# Find the last table added to the document
last_table = self.document.tables[-1] # Assumes the table was added at the end
@@ -171,9 +155,9 @@ def test_add_html_with_tables(self):
self.assertEqual(last_table.style.name, table_style, f"Table style does not match expected '{table_style}'")
def test_add_html_with_tables_accent_style(self):
- table_style = 'Light Grid Accent 6'
+ table_style = "Light Grid Accent 6"
self.document.add_heading(
- 'Test: add html with tables with accent',
+ "Test: add html with tables with accent",
)
self.parser.table_style = table_style
self.parser.add_html_to_document(self.table_html, self.document)
@@ -185,9 +169,9 @@ def test_add_html_with_tables_accent_style(self):
self.assertEqual(last_table.style.name, table_style, f"Table style does not match expected '{table_style}'")
def test_add_html_with_tables_basic_style(self):
- table_style = 'Table Grid'
+ table_style = "Table Grid"
self.document.add_heading(
- 'Test: add html with tables with basic style',
+ "Test: add html with tables with basic style",
)
self.parser.table_style = table_style
self.parser.add_html_to_document(self.table_html, self.document)
@@ -200,31 +184,28 @@ def test_add_html_with_tables_basic_style(self):
def test_add_nested_tables(self):
self.document.add_heading(
- 'Test: add nested tables',
+ "Test: add nested tables",
)
self.parser.add_html_to_document(self.table2_html, self.document)
def test_add_nested_tables_basic_style(self):
self.document.add_heading(
- 'Test: add nested tables with basic style',
+ "Test: add nested tables with basic style",
)
- self.parser.table_style = 'Table Grid'
+ self.parser.table_style = "Table Grid"
self.parser.add_html_to_document(self.table2_html, self.document)
def test_add_nested_tables_accent_style(self):
self.document.add_heading(
- 'Test: add nested tables with accent style',
+ "Test: add nested tables with accent style",
)
- self.parser.table_style = 'Light Grid Accent 6'
+ self.parser.table_style = "Light Grid Accent 6"
self.parser.add_html_to_document(self.table2_html, self.document)
def test_add_html_skip_tables(self):
# broken until feature readded
- self.document.add_heading(
- 'Test: add html with tables, but skip adding tables',
- level=1
- )
- self.parser.options['tables'] = False
+ self.document.add_heading("Test: add html with tables, but skip adding tables", level=1)
+ self.parser.options["tables"] = False
self.parser.add_html_to_document(self.table_html, self.document)
def test_wrong_argument_type_raises_error(self):
@@ -246,39 +227,29 @@ def test_wrong_argument_type_raises_error(self):
assert False, "Error not raised as expected"
def test_add_html_to_cells_method(self):
- self.document.add_heading(
- 'Test: add_html_to_cells method',
- level=1
- )
- table = self.document.add_table(2, 3, style='Table Grid')
+ self.document.add_heading("Test: add_html_to_cells method", level=1)
+ table = self.document.add_table(2, 3, style="Table Grid")
cell = table.cell(0, 0)
- html = '''Line 0 without p tagsLine 1 with P tags
'''
+ html = """Line 0 without p tagsLine 1 with P tags
"""
self.parser.add_html_to_cell(html, cell)
cell = table.cell(0, 1)
- html = '''Line 0 with p tags
Line 1 without p tags'''
+ html = """Line 0 with p tags
Line 1 without p tags"""
self.parser.add_html_to_cell(html, cell)
cell = table.cell(0, 2)
cell.text = "Pre-defined text that shouldn't be removed."
- html = '''Add HTML to non-empty cell.
'''
+ html = """Add HTML to non-empty cell.
"""
self.parser.add_html_to_cell(html, cell)
def test_inline_code(self):
- self.document.add_heading(
- 'Test: inline code block',
- level=1
- )
+ self.document.add_heading("Test: inline code block", level=1)
- html = "This is a sentence that contains some code elements that " \
- "should appear as code.
"
+ html = "This is a sentence that contains some code elements that should appear as code.
"
self.parser.add_html_to_document(html, self.document)
def test_code_block(self):
- self.document.add_heading(
- 'Test: code block',
- level=1
- )
+ self.document.add_heading("Test: code block", level=1)
html = """
This is a code block.
@@ -290,10 +261,7 @@ def test_code_block(self):
self.parser.add_html_to_document(html, self.document)
def test_pre_block(self):
- self.document.add_heading(
- 'Test: pre block',
- level=1
- )
+ self.document.add_heading("Test: pre block", level=1)
html = """
This is a pre-formatted block.
@@ -306,25 +274,19 @@ def test_pre_block(self):
self.parser.add_html_to_document(html, self.document)
def test_handling_hr(self):
- hr_html_example = 'paragraph
paragraph
'
+ hr_html_example = "paragraph
paragraph
"
- self.document.add_heading(
- 'Test: Handling of hr',
- level=1
- )
+ self.document.add_heading("Test: Handling of hr", level=1)
# Add on document for human validation
self.parser.add_html_to_document(hr_html_example, self.document)
document = self.parser.parse_html_string(hr_html_example)
- assert '' in document._body._body.xml
+ assert "" in document._body._body.xml
def test_external_hyperlink(self):
- hyperlink_html_example = "Google External Link"
+ hyperlink_html_example = 'Google External Link'
- self.document.add_heading(
- 'Test: Handling external hyperlink',
- level=1
- )
+ self.document.add_heading("Test: Handling external hyperlink", level=1)
self.parser.add_html_to_document(hyperlink_html_example, self.document)
document = self.parser.parse_html_string(hyperlink_html_example)
@@ -335,19 +297,16 @@ def test_external_hyperlink(self):
if "hyperlink" in rel.reltype:
external_hyperlinks.append(rel.target_ref)
- assert 'https://www.google.com' in external_hyperlinks
- assert 'Introduction Header
"
- "Click here: Link to intro
"
+ 'Introduction Header
'
+ 'Click here: Link to intro
'
)
- self.document.add_heading(
- 'Test: Handling internal hyperlink',
- level=1
- )
+ self.document.add_heading("Test: Handling internal hyperlink", level=1)
self.parser.add_html_to_document(hyperlink_html_example, self.document)
document = self.parser.parse_html_string(hyperlink_html_example)
@@ -358,8 +317,8 @@ def test_internal_hyperlink(self):
def test_internal_hyperlink_without_paragraph(self):
hyperlink_html_example = (
- "Introduction Header
"
- "Click here: Link to intro
"
+ 'Introduction Header
'
+ 'Click here: Link to intro
'
)
document = self.parser.parse_html_string(hyperlink_html_example)
@@ -370,9 +329,7 @@ def test_internal_hyperlink_without_paragraph(self):
assert '' in document_body
def test_internal_hyperlink_without_anchor(self):
- hyperlink_html_example = (
- "Click here: Link to intro
"
- )
+ hyperlink_html_example = 'Click here: Link to intro
'
document = self.parser.parse_html_string(hyperlink_html_example)
document_body = document._body._body.xml
@@ -382,18 +339,15 @@ def test_internal_hyperlink_without_anchor(self):
assert '' in document_body
def test_image_no_src(self):
- self.document.add_heading(
- 'Test: Handling img without src',
- level=1
- )
- self.parser.add_html_to_document('![]()
', self.document)
+ self.document.add_heading("Test: Handling img without src", level=1)
+ self.parser.add_html_to_document("![]()
", self.document)
- document = self.parser.parse_html_string('![]()
')
- assert '' in document.paragraphs[0].text
+ document = self.parser.parse_html_string("![]()
")
+ assert "" in document.paragraphs[0].text
def test_local_img(self):
# A table with more td elements in latter rows than in the first
- self.document.add_heading('Test: Local Image', level=1)
+ self.document.add_heading("Test: Local Image", level=1)
html_local_img = '
'
self.parser.add_html_to_document(html_local_img, self.document)
document = self.parser.parse_html_string(html_local_img)
@@ -411,33 +365,50 @@ def test_local_img(self):
assert image_found, "No image was found in the document"
- def test_inline_images(self):
- self.document.add_heading(
- 'Test: Handling inline images',
- level=1
+ def test_img_with_dimensions(self):
+ self.document.add_heading("Test: Image With Dimensions", level=1)
+
+ html = ''
+ self.parser.add_html_to_document(html, self.document)
+ document = self.parser.parse_html_string(html)
+
+ # Ensure at least one image exists
+ assert len(document.inline_shapes) > 0, "No image was found in the document"
+
+ shape = document.inline_shapes[-1]
+
+ # Convert expected px → inches (assuming 96 DPI)
+ expected_width_in = 520 / 96
+ expected_height_in = 306 / 96
+
+ actual_width_in = shape.width.inches
+ actual_height_in = shape.height.inches
+
+ # Allow tolerance (floating point + conversion differences)
+ tolerance = 0.05 # ~1.27 mm
+
+ assert abs(actual_width_in - expected_width_in) < tolerance, (
+ f"Width mismatch: expected ~{expected_width_in:.2f}in, got {actual_width_in:.2f}in"
)
- test_img_src = 'https://github.com/dfop02/html4docx/blob/main/tests/assets/images/test_img.png?raw=true'
- html_example = (
- f"
"
- f""
- f"
"
+
+ assert abs(actual_height_in - expected_height_in) < tolerance, (
+ f"Height mismatch: expected ~{expected_height_in:.2f}in, got {actual_height_in:.2f}in"
)
+
+ def test_inline_images(self):
+ self.document.add_heading("Test: Handling inline images", level=1)
+ test_img_src = "https://github.com/dfop02/html4docx/blob/main/tests/assets/images/test_img.png?raw=true"
+ html_example = f"
"
self.parser.add_html_to_document(html_example, self.document)
document = self.parser.parse_html_string(html_example)
# Find paragraphs containing inline pictures
- img_paragraphs = [
- p for p in document.paragraphs
- if any(r._element.xpath(".//pic:pic") for r in p.runs)
- ]
+ img_paragraphs = [p for p in document.paragraphs if any(r._element.xpath(".//pic:pic") for r in p.runs)]
assert img_paragraphs, "Expected at least one paragraph with inline images"
first_img_para = img_paragraphs[0]
- inline_img_runs = [
- r for r in first_img_para.runs
- if r._element.xpath(".//pic:pic")
- ]
+ inline_img_runs = [r for r in first_img_para.runs if r._element.xpath(".//pic:pic")]
assert len(inline_img_runs) == 3, "Expected 3 inline image runs in a single paragraph"
def test_single_image_without_paragraph(self):
@@ -445,24 +416,15 @@ def test_single_image_without_paragraph(self):
document = self.parser.parse_html_string(html_example)
# Find paragraphs containing inline pictures
- img_paragraphs = [
- p for p in document.paragraphs
- if any(r._element.xpath(".//pic:pic") for r in p.runs)
- ]
+ img_paragraphs = [p for p in document.paragraphs if any(r._element.xpath(".//pic:pic") for r in p.runs)]
assert img_paragraphs, "Expected at least one paragraph with inline images"
first_img_para = img_paragraphs[0]
- inline_img_runs = [
- r for r in first_img_para.runs
- if r._element.xpath(".//pic:pic")
- ]
+ inline_img_runs = [r for r in first_img_para.runs if r._element.xpath(".//pic:pic")]
assert len(inline_img_runs) == 1, "Expected 1 inline image runs in a single paragraph"
def test_bold_italic_underline_and_strike(self):
- self.document.add_heading(
- 'Test: Bold, Italic, Underline, Inserted, Strike, Deleted and Marked tags',
- level=1
- )
+ self.document.add_heading("Test: Bold, Italic, Underline, Inserted, Strike, Deleted and Marked tags", level=1)
html_example = (
"This text has Bold Words.
"
@@ -500,8 +462,7 @@ def test_bold_italic_underline_and_strike(self):
self.assertIn("Marked Words", paragraphs[6].text)
self.assertEqual(
- self.get_run_shading_fill(paragraphs[6].runs[1]), 'FFFF00',
- " should apply yellow shading (FFFF00)"
+ self.get_run_shading_fill(paragraphs[6].runs[1]), "FFFF00", " should apply yellow shading (FFFF00)"
)
self.assertIn("Bold, Italic, Underline and Strike Words", paragraphs[7].text)
@@ -513,64 +474,58 @@ def test_bold_italic_underline_and_strike(self):
def test_font_size(self):
font_size_html_example = (
- "paragraph 8px
"
- "paragraph 1cm
"
- "paragraph 6em
"
- "paragraph 12cm
"
- "paragraph 12vh not supported
"
- "paragraph 5pc
"
- "paragraph 14pt
"
- "paragraph 16pt
"
- "paragraph 2mm
"
- "paragraph small
"
- )
-
- self.document.add_heading(
- 'Test: Font-Size',
- level=1
- )
+ 'paragraph 8px
'
+ 'paragraph 1cm
'
+ 'paragraph 6em
'
+ 'paragraph 12cm
'
+ 'paragraph 12vh not supported
'
+ 'paragraph 5pc
'
+ 'paragraph 14pt
'
+ 'paragraph 16pt
'
+ 'paragraph 2mm
'
+ 'paragraph small
'
+ )
+
+ self.document.add_heading("Test: Font-Size", level=1)
# Add on document for human validation
self.parser.add_html_to_document(font_size_html_example, self.document)
document = self.parser.parse_html_string(font_size_html_example)
font_sizes = [str(p.runs[0].font.size) for p in document.paragraphs]
- assert ['76200', '355600', '914400', '431800', 'None', '762000', '177800', '203200', '69850', '120650'] == font_sizes
+ assert ["76200", "355600", "914400", "431800", "None", "762000", "177800", "203200", "69850", "120650"] == font_sizes
def test_font_size_paragraph(self):
font_size_html_example = (
- "paragraph 8px
"
- "paragraph 1cm
"
- "paragraph 6em
"
- "paragraph 12cm
"
- "paragraph 12vh not supported
"
- "paragraph 5pc
"
- "paragraph 14pt
"
- "paragraph 16pt
"
- "paragraph 2mm
"
- "paragraph small
"
- )
-
- self.document.add_heading(
- 'Test: Font-Size on ',
- level=1
- )
+ '
paragraph 8px
'
+ 'paragraph 1cm
'
+ 'paragraph 6em
'
+ 'paragraph 12cm
'
+ 'paragraph 12vh not supported
'
+ 'paragraph 5pc
'
+ 'paragraph 14pt
'
+ 'paragraph 16pt
'
+ 'paragraph 2mm
'
+ 'paragraph small
'
+ )
+
+ self.document.add_heading("Test: Font-Size on ", level=1)
self.parser.add_html_to_document(font_size_html_example, self.document)
document = self.parser.parse_html_string(font_size_html_example)
font_sizes = [str(p.runs[0].font.size) for p in document.paragraphs]
- assert ['76200', '355600', '914400', '431800', 'None', '762000', '177800', '203200', '69850', '120650'] == font_sizes
+ assert ["76200", "355600", "914400", "431800", "None", "762000", "177800", "203200", "69850", "120650"] == font_sizes
def test_font_weight_paragraph(self):
- self.document.add_heading('Test: font weight on
', level=1)
+ self.document.add_heading("Test: font weight on
", level=1)
font_weight_html_example = (
- "
bold text
"
- "bolder text
"
- "700 weight
"
- "900 weight
"
- "normal text
"
- "lighter text
"
- "400 weight
"
- "100 weight
"
+ 'bold text
'
+ 'bolder text
'
+ '700 weight
'
+ '900 weight
'
+ 'normal text
'
+ 'lighter text
'
+ '400 weight
'
+ '100 weight
'
)
self.parser.add_html_to_document(font_weight_html_example, self.document)
@@ -580,10 +535,10 @@ def test_font_weight_paragraph(self):
font_weights = [p.runs[0].font.bold for p in document.paragraphs]
expected_weights = [
- True, # bold
- True, # bolder
- True, # 700
- True, # 900
+ True, # bold
+ True, # bolder
+ True, # 700
+ True, # 900
False, # normal
False, # lighter
False, # 400
@@ -593,11 +548,11 @@ def test_font_weight_paragraph(self):
self.assertEqual(font_weights, expected_weights)
def test_font_style_paragraph(self):
- self.document.add_heading('Test: font style on ', level=1)
+ self.document.add_heading("Test: font style on
", level=1)
font_style_html_example = (
- "
italic text
"
- "oblique text
"
- "normal text
"
+ 'italic text
'
+ 'oblique text
'
+ 'normal text
'
)
self.parser.add_html_to_document(font_style_html_example, self.document)
@@ -607,76 +562,70 @@ def test_font_style_paragraph(self):
font_styles = [p.runs[0].font.italic for p in document.paragraphs]
expected_styles = [
- True, # italic
- True, # oblique (should be treated as italic)
+ True, # italic
+ True, # oblique (should be treated as italic)
False, # normal
]
self.assertEqual(font_styles, expected_styles)
def test_font_family_paragraph(self):
- self.document.add_heading('Test: font family on ', level=1)
+ self.document.add_heading("Test: font family on
", level=1)
font_family_html_example = (
- "
Arial font text
"
+ 'Arial font text
'
"Helvetica font text
"
"Noto Sans font text
"
"Times New Roman font text
"
- "Generic serif font text
"
- "Generic sans-serif font text
"
- "Generic monospace font text
"
+ 'Generic serif font text
'
+ 'Generic sans-serif font text
'
+ 'Generic monospace font text
'
"Courier New font text
"
- "Inherit font text
"
+ 'Inherit font text
'
)
self.parser.add_html_to_document(font_family_html_example, self.document)
def test_text_transform_paragraph(self):
- self.document.add_heading('Test: text-transform on ', level=1)
+ self.document.add_heading("Test: text-transform on
", level=1)
text_transform_html_example = (
- "
uppercase text
"
- "LOWERCASE TEXT
"
- "capitalize each word
"
- "normal text
"
+ 'uppercase text
'
+ 'LOWERCASE TEXT
'
+ 'capitalize each word
'
+ 'normal text
'
"default text
"
)
self.parser.add_html_to_document(text_transform_html_example, self.document)
def test_text_decoration_span(self):
- self.document.add_heading('Test: text-decoration on ', level=1)
+ self.document.add_heading("Test: text-decoration on ", level=1)
text_decoration_html_example = (
# Standalone spans
- "underlined span (red)"
- "no decoration span (rgb(0, 0, 0))"
- "strikethrough span (gray) (not supported)"
- "underline+line-through span (orange)\
- (should be strike)"
-
+ 'underlined span (red)'
+ 'no decoration span (rgb(0, 0, 0))'
+ 'strikethrough span (gray) (not supported)'
+ 'underline+line-through span (orange)\
+ (should be strike)'
# Spans inside paragraphs
- "Normal text wavy underlined span (blue) continues
"
- "Normal text dotted underlined span (purple) continues
"
- "Normal text strikethrough span (red) continues
"
-
+ 'Normal text wavy underlined span (blue) continues
'
+ 'Normal text dotted underlined span (purple) continues
'
+ 'Normal text strikethrough span (red) continues
'
# Multiple spans with different decorations in same paragraph
- "Start underlined "
- "strikethrough "
- "dashed underline end
"
-
+ 'Start underlined '
+ 'strikethrough '
+ 'dashed underline end
'
# Span with no decoration inside decorated paragraph
- "Underlined paragraph with "
- "normal span inside
"
-
+ 'Underlined paragraph with '
+ 'normal span inside
'
# Span with decoration inside decorated paragraph (should override)
- "Strikethrough paragraph with "
- "underlined red span inside
"
-
+ 'Strikethrough paragraph with '
+ 'underlined red span inside
'
# Override behavior with individual properties
- "Blue underlined paragraph with "
- "strikethrough span inside
"
-
+ 'Blue underlined paragraph with '
+ 'strikethrough span inside
'
# Check if equal - shorthand vs individual properties
- "Blue underlined paragraph
"
- "Blue underlined paragraph
"
+ 'Blue underlined paragraph
'
+ 'Blue underlined paragraph
'
)
self.parser.add_html_to_document(text_decoration_html_example, self.document)
@@ -802,24 +751,24 @@ def test_text_decoration_span(self):
assert self.get_underline_color(p9.runs[0]) == self.hexcolor("blue")
def test_text_decoration_paragraph(self):
- self.document.add_heading('Test: text-decoration on ', level=1)
+ self.document.add_heading("Test: text-decoration on
", level=1)
text_decoration_html_example = (
- "
underlined text (red)
"
- "no decoration text (rgb(0, 0, 0))
"
- "strikethrough text (gray) (color not supported)
"
- "underline+line-through (orange)\
- (should be strike)
"
- "wavy underline (blue)
"
- "dotted underline (rgb(0, 128, 0))
"
- "dotted underline (rgb(0, 255, 0))
"
- "dashed underline (purple)
"
- "double underline (rgb(255, 69, 0))
"
- "overline text (hotpink) (not supported)
"
- "blink text (hotpink) (not supported)
"
+ 'underlined text (red)
'
+ 'no decoration text (rgb(0, 0, 0))
'
+ 'strikethrough text (gray) (color not supported)
'
+ 'underline+line-through (orange)\
+ (should be strike)
'
+ 'wavy underline (blue)
'
+ 'dotted underline (rgb(0, 128, 0))
'
+ 'dotted underline (rgb(0, 255, 0))
'
+ 'dashed underline (purple)
'
+ 'double underline (rgb(255, 69, 0))
'
+ 'overline text (hotpink) (not supported)
'
+ 'blink text (hotpink) (not supported)
'
)
self.parser.add_html_to_document(text_decoration_html_example, self.document)
- with self.assertLogs(level='WARNING') as log:
+ with self.assertLogs(level="WARNING") as log:
document = self.parser.parse_html_string(text_decoration_html_example)
underline_states = []
@@ -856,45 +805,45 @@ def test_text_decoration_paragraph(self):
strike_states.append(strike)
expected_underline_states = [
- True, # underline (default single) - explicitly True
+ True, # underline (default single) - explicitly True
False, # none - explicitly False for both underline and strike
False, # line-through - explicitly False for underline when strike is True
False, # underline + line-through - line-through wins, underline explicitly False
- WD_UNDERLINE.WAVY, # wavy underline - explicitly set to wavy
- WD_UNDERLINE.DOTTED, # dotted underline - explicitly set to dotted
- WD_UNDERLINE.DOTTED, # dotted underline - explicitly set to dotted
- WD_UNDERLINE.DASH, # dashed underline - explicitly set to dash
- WD_UNDERLINE.DOUBLE, # double underline - explicitly set to double
+ WD_UNDERLINE.WAVY, # wavy underline - explicitly set to wavy
+ WD_UNDERLINE.DOTTED, # dotted underline - explicitly set to dotted
+ WD_UNDERLINE.DOTTED, # dotted underline - explicitly set to dotted
+ WD_UNDERLINE.DASH, # dashed underline - explicitly set to dash
+ WD_UNDERLINE.DOUBLE, # double underline - explicitly set to double
None, # overline (not supported) - remains None/unchanged
None, # blink (not supported) - remains None/unchanged
]
expected_underline_colors = [
- self.hexcolor("red"), # underline red
- None, # none rgb(0,0,0)
- None, # line-through gray (strike only, but color captured)
- None, # underline + line-through (color should be orange)
- self.hexcolor("blue"), # wavy underline blue
- self.hexcolor("rgb(0,128,0)"), # dotted underline rgb(0,128,0)
- self.hexcolor("rgb(0,255,0)"), # dotted underline rgb(0,255,0)
- self.hexcolor("purple"), # dashed underline purple
- self.hexcolor("rgb(255,69,0)"), # double underline rgb(255,69,0)
- None, # overline hotpink (unsupported → underline None, but color still parsed)
- None, # blink hotpink (unsupported)
+ self.hexcolor("red"), # underline red
+ None, # none rgb(0,0,0)
+ None, # line-through gray (strike only, but color captured)
+ None, # underline + line-through (color should be orange)
+ self.hexcolor("blue"), # wavy underline blue
+ self.hexcolor("rgb(0,128,0)"), # dotted underline rgb(0,128,0)
+ self.hexcolor("rgb(0,255,0)"), # dotted underline rgb(0,255,0)
+ self.hexcolor("purple"), # dashed underline purple
+ self.hexcolor("rgb(255,69,0)"), # double underline rgb(255,69,0)
+ None, # overline hotpink (unsupported → underline None, but color still parsed)
+ None, # blink hotpink (unsupported)
]
expected_strike_states = [
False, # underline only - explicitly False for strike when underline is True
False, # none - explicitly False for both underline and strike
- True, # line-through - explicitly True
- True, # underline + line-through - line-through wins, strike explicitly True
+ True, # line-through - explicitly True
+ True, # underline + line-through - line-through wins, strike explicitly True
False, # wavy underline only - explicitly False for strike when underline is set
False, # dotted underline only - explicitly False for strike when underline is set
False, # dotted underline only - explicitly False for strike when underline is set
False, # dashed underline only - explicitly False for strike when underline is set
False, # double underline only - explicitly False for strike when underline is set
- None, # overline (not supported) - remains None/unchanged
- None, # blink (not supported) - remains None/unchanged
+ None, # overline (not supported) - remains None/unchanged
+ None, # blink (not supported) - remains None/unchanged
]
# Test that the underline states, colors, and strike states are correct
@@ -904,13 +853,17 @@ def test_text_decoration_paragraph(self):
# Test that the correct warnings are logged
self.assertEqual(len(log.records), 4)
- self.assertIn('Word does not support colored strike-through. Color \'gray\' will be ignored for line-through.', log.output[0])
- self.assertIn('Word does not support colored strike-through. Color \'orange\' will be ignored for line-through.', log.output[1])
- self.assertIn('Blink or overline not supported.', log.output[2])
- self.assertIn('Blink or overline not supported.', log.output[3])
+ self.assertIn(
+ "Word does not support colored strike-through. Color 'gray' will be ignored for line-through.", log.output[0]
+ )
+ self.assertIn(
+ "Word does not support colored strike-through. Color 'orange' will be ignored for line-through.", log.output[1]
+ )
+ self.assertIn("Blink or overline not supported.", log.output[2])
+ self.assertIn("Blink or overline not supported.", log.output[3])
def test_first_line_paragraph(self):
- self.document.add_heading('Test text-indent on tags', level=1)
+ self.document.add_heading("Test text-indent on
tags", level=1)
self.parser.add_html_to_document(self.paragraph_first_line_indent, self.document)
document = self.parser.parse_html_string(self.paragraph_first_line_indent)
@@ -922,26 +875,26 @@ def test_first_line_paragraph(self):
indent_values.append(indent_pt)
expected_values = [
- 1080000, # 3cm
- 254000, # 20pt
- 381000, # 40px
- 1260000, # 35mm
- None, # Word does not support negative values here
+ 1080000, # 3cm
+ 254000, # 20pt
+ 381000, # 40px
+ 1260000, # 35mm
+ None, # Word does not support negative values here
]
for actual, expected in zip(indent_values, expected_values):
self.assertAlmostEqual(actual, expected, delta=634)
def test_color_paragraph(self):
- self.document.add_heading('Test: color on p tags', level=1)
+ self.document.add_heading("Test: color on p tags", level=1)
color_html_example = (
- "
red text
"
- "green hex text
"
- "blue rgb text
"
- "inherit color text
"
- "transparent color text
"
- "current color text
"
- "red with other styles
"
+ 'red text
'
+ 'green hex text
'
+ 'blue rgb text
'
+ 'inherit color text
'
+ 'transparent color text
'
+ 'current color text
'
+ 'red with other styles
'
"default text
"
)
@@ -974,7 +927,7 @@ def test_color_paragraph(self):
self.assertEqual(color_states, expected_colors)
def test_line_height_paragraph(self):
- self.document.add_heading('Test: line-height on ', level=1)
+ self.document.add_heading("Test: line-height on
", level=1)
self.parser.add_html_to_document(self.paragraph_line_height, self.document)
document = self.parser.parse_html_string(self.paragraph_line_height)
@@ -984,64 +937,67 @@ def test_line_height_paragraph(self):
for p in document.paragraphs:
line_spacing = p.paragraph_format.line_spacing
line_rule = p.paragraph_format.line_spacing_rule
- line_heights.append(str(line_spacing) if line_spacing is not None else 'None')
- line_rules.append(str(line_rule) if line_rule is not None else 'None')
+ line_heights.append(str(line_spacing) if line_spacing is not None else "None")
+ line_rules.append(str(line_rule) if line_rule is not None else "None")
expected_line_heights = [
- '1.0',
- '1.15',
- '1.5',
- '2.0',
- '190500', # line-height: 20px
- '182880', # line-height: 1.2em
- '228600', # line-height: 1.5em
- '304800', # line-height: 2em
- '182880', # line-height: 1.2rem
- '228600', # line-height: 1.5rem
- '304800', # line-height: 2rem
- '1.5', # line-height: 150%
- '2.0', # line-height: 200%
+ "1.0",
+ "1.15",
+ "1.5",
+ "2.0",
+ "190500", # line-height: 20px
+ "182880", # line-height: 1.2em
+ "228600", # line-height: 1.5em
+ "304800", # line-height: 2em
+ "182880", # line-height: 1.2rem
+ "228600", # line-height: 1.5rem
+ "304800", # line-height: 2rem
+ "1.5", # line-height: 150%
+ "2.0", # line-height: 200%
]
- self.assertEqual(line_heights, expected_line_heights,
- f"Line heights don't match expected values. Got {line_heights}, expected {expected_line_heights}")
+ self.assertEqual(
+ line_heights,
+ expected_line_heights,
+ f"Line heights don't match expected values. Got {line_heights}, expected {expected_line_heights}",
+ )
def test_margins_paragraph(self):
margins_html_example = (
- "
centered paragraph
"
- "left margin 20px
"
- "right margin 1.5cm
"
- "left margin 1cm
"
- "both margins set
"
- "only left auto
"
- "only right auto
"
- "zero margins
"
- "left margin 2in
"
- )
-
- self.document.add_heading('Test margins on ', level=1)
+ '
centered paragraph
'
+ 'left margin 20px
'
+ 'right margin 1.5cm
'
+ 'left margin 1cm
'
+ 'both margins set
'
+ 'only left auto
'
+ 'only right auto
'
+ 'zero margins
'
+ 'left margin 2in
'
+ )
+
+ self.document.add_heading("Test margins on ", level=1)
self.parser.add_html_to_document(margins_html_example, self.document)
document = self.parser.parse_html_string(margins_html_example)
expected_margins = [
# Paragraph 1: "centered paragraph" - auto margins (None values)
- {'left': None, 'right': None},
+ {"left": None, "right": None},
# Paragraph 2: "left margin 20px" - 20px = 20 * 9525 = 190500 EMU
- {'left': 190500, 'right': None},
+ {"left": 190500, "right": None},
# Paragraph 3: "right margin 1.5cm" - 1.5cm = 1.5 * 360000 = 540000 EMU
- {'left': None, 'right': 540000},
+ {"left": None, "right": 540000},
# Paragraph 4: "left margin 1cm" - 1cm = 360000 EMU
- {'left': 360000, 'right': None},
+ {"left": 360000, "right": None},
# Paragraph 5: "both margins set" - 10px=95250 EMU, 15px=142875 EMU
- {'left': 95250, 'right': 142875},
+ {"left": 95250, "right": 142875},
# Paragraph 6: "only left auto" - auto margin
- {'left': None, 'right': None},
+ {"left": None, "right": None},
# Paragraph 7: "only right auto" - auto margin
- {'left': None, 'right': None},
+ {"left": None, "right": None},
# Paragraph 8: "zero margins" - 0px = 0 EMU
- {'left': 0, 'right': 0},
+ {"left": 0, "right": 0},
# Paragraph 9: "left margin 2in" - 2in = 2 * 914400 = 1828800 EMU
- {'left': 1828800, 'right': None},
+ {"left": 1828800, "right": None},
]
self.assertEqual(len(document.paragraphs), len(expected_margins))
@@ -1052,23 +1008,27 @@ def test_margins_paragraph(self):
actual_right = paragraph.paragraph_format.right_indent
# Check left margin
- if expected['left'] is None:
+ if expected["left"] is None:
self.assertIsNone(actual_left, f"Paragraph {i} left margin should be None")
else:
self.assertIsNotNone(actual_left, f"Paragraph {i} left margin should not be None")
- self.assertTrue(abs(actual_left - expected['left']) <= 634,
- f"Paragraph {i} left margin: expected {expected['left']} EMU, got {actual_left} EMU")
+ self.assertTrue(
+ abs(actual_left - expected["left"]) <= 634,
+ f"Paragraph {i} left margin: expected {expected['left']} EMU, got {actual_left} EMU",
+ )
# Check right margin
- if expected['right'] is None:
+ if expected["right"] is None:
self.assertIsNone(actual_right, f"Paragraph {i} right margin should be None")
else:
self.assertIsNotNone(actual_right, f"Paragraph {i} right margin should not be None")
- self.assertTrue(abs(actual_right - expected['right']) <= 634,
- f"Paragraph {i} right margin: expected {expected['right']} EMU, got {actual_right} EMU")
+ self.assertTrue(
+ abs(actual_right - expected["right"]) <= 634,
+ f"Paragraph {i} right margin: expected {expected['right']} EMU, got {actual_right} EMU",
+ )
def test_background_color_styles(self):
- self.document.add_heading('Test background color on
, multiple cases', level=1)
+ self.document.add_heading("Test background color on
, multiple cases", level=1)
html_example2 = """
Start of paragraph
@@ -1185,61 +1145,61 @@ def test_background_color_styles(self):
self.parser.add_html_to_document(html_example9, self.document)
def test_headers_with_css(self):
- self.document.add_heading('Test: headers with css', level=1)
+ self.document.add_heading("Test: headers with css", level=1)
self.parser.add_html_to_document(self.css_properties_header, self.document)
document = self.parser.parse_html_string(self.css_properties_header)
# Test H1 - Large and Centered
h1 = document.paragraphs[0]
- assert h1.style.name.startswith('Heading 1')
- assert str(h1.runs[0].font.color.rgb) == '2C3E50'
+ assert h1.style.name.startswith("Heading 1")
+ assert str(h1.runs[0].font.color.rgb) == "2C3E50"
assert h1.runs[0].font.bold is True
assert h1.runs[0].font.size == 342900
assert h1.alignment == WD_ALIGN_PARAGRAPH.CENTER
- assert h1.runs[0].text == 'MAIN HEADING H1 - LARGE AND CENTERED' # uppercase due to text-transform
+ assert h1.runs[0].text == "MAIN HEADING H1 - LARGE AND CENTERED" # uppercase due to text-transform
# Test H2 - Underlined with Background (no span in this one)
h2 = document.paragraphs[1]
- assert h2.style.name.startswith('Heading 2')
- assert str(h2.runs[0].font.color.rgb) == '34495E'
+ assert h2.style.name.startswith("Heading 2")
+ assert str(h2.runs[0].font.color.rgb) == "34495E"
assert h2.runs[0].font.underline is True
- assert h2.runs[0].font.name == 'Arial'
+ assert h2.runs[0].font.name == "Arial"
assert h2.runs[0].font.size == 266700
# Test H3 - Italic and Right Aligned
h3 = document.paragraphs[2]
- assert h3.style.name.startswith('Heading 3')
- assert str(h3.runs[0].font.color.rgb) == '7F8C8D'
+ assert h3.style.name.startswith("Heading 3")
+ assert str(h3.runs[0].font.color.rgb) == "7F8C8D"
assert h3.runs[0].font.italic is True
assert h3.runs[0].font.size == 209550
assert h3.alignment == WD_ALIGN_PARAGRAPH.RIGHT
# Test H4 - Normal Weight and Capitalized
h4 = document.paragraphs[3]
- assert h4.style.name.startswith('Heading 4')
- assert str(h4.runs[0].font.color.rgb) == '95A5A6'
+ assert h4.style.name.startswith("Heading 4")
+ assert str(h4.runs[0].font.color.rgb) == "95A5A6"
assert h4.runs[0].font.bold is False # font-weight: normal
- assert h4.runs[0].font.name == 'Georgia'
+ assert h4.runs[0].font.name == "Georgia"
assert h4.runs[0].font.size == 171450
- assert h4.runs[0].text == 'Quaternary Heading H4 - Normal Weight And Capitalized' # capitalized
+ assert h4.runs[0].text == "Quaternary Heading H4 - Normal Weight And Capitalized" # capitalized
# Test H1 with Complex Text Decoration and Span
h1_complex = document.paragraphs[4]
assert h1_complex.runs[0].font.strike is True # line-through
- assert str(h1_complex.runs[0].font.color.rgb) == '8E44AD'
+ assert str(h1_complex.runs[0].font.color.rgb) == "8E44AD"
assert h1_complex.runs[0].font.size == 381000
# Test span in complex H1
assert len(h1_complex.runs) >= 2
span_in_h1 = h1_complex.runs[1]
assert span_in_h1.font.underline is True # underline in span
- assert str(span_in_h1.font.color.rgb) == '2980B9'
+ assert str(span_in_h1.font.color.rgb) == "2980B9"
# Test H3 with Light Weight and Span
h3_light = document.paragraphs[5]
assert h3_light.runs[0].font.bold is False # font-weight: 100
- assert str(h3_light.runs[0].font.color.rgb) == 'D35400'
+ assert str(h3_light.runs[0].font.color.rgb) == "D35400"
assert h3_light.runs[0].font.size == 190500
# Test bold span in light H3
@@ -1249,21 +1209,21 @@ def test_headers_with_css(self):
# Test H3 with Text Transform
h3_transform = document.paragraphs[6]
- assert h3_transform.runs[0].text == 'h3 forced to lowercase with text-transform '
+ assert h3_transform.runs[0].text == "h3 forced to lowercase with text-transform "
assert len(h3_transform.runs) >= 2
uppercase_span = h3_transform.runs[1]
- assert uppercase_span.text == 'SPAN FORCED TO UPPERCASE'
+ assert uppercase_span.text == "SPAN FORCED TO UPPERCASE"
# Test H4 with Serif Font
h4_serif = document.paragraphs[7]
- assert h4_serif.runs[0].font.name == 'Times New Roman'
- assert str(h4_serif.runs[0].font.color.rgb) == '7D3C98'
+ assert h4_serif.runs[0].font.name == "Times New Roman"
+ assert str(h4_serif.runs[0].font.color.rgb) == "7D3C98"
assert h4_serif.alignment == WD_ALIGN_PARAGRAPH.CENTER
# Test H1 with Auto Margins and Background
h1_centered = document.paragraphs[8]
assert h1_centered.alignment == WD_ALIGN_PARAGRAPH.CENTER
- assert str(h1_centered.runs[0].font.color.rgb) == 'FFFFFF'
+ assert str(h1_centered.runs[0].font.color.rgb) == "FFFFFF"
# Test H2 with Lighter Weight and Span
h2_lighter = document.paragraphs[9]
@@ -1278,13 +1238,13 @@ def test_headers_with_css(self):
# Test H3 with RGB Colors and Span
h3_rgb = document.paragraphs[10]
- assert str(h3_rgb.runs[0].font.color.rgb) == '3498DB' # rgb(52, 152, 219)
+ assert str(h3_rgb.runs[0].font.color.rgb) == "3498DB" # rgb(52, 152, 219)
assert h3_rgb.runs[0].font.size == 177800
# Test RGB span
assert len(h3_rgb.runs) >= 2
rgb_span = h3_rgb.runs[1]
- assert str(rgb_span.font.color.rgb) == 'E74C3C' # rgb(231, 76, 60)
+ assert str(rgb_span.font.color.rgb) == "E74C3C" # rgb(231, 76, 60)
# Test H4 with Strike-through and Span
h4_strike = document.paragraphs[11]
@@ -1295,17 +1255,17 @@ def test_headers_with_css(self):
assert len(h4_strike.runs) >= 2
no_strike_span = h4_strike.runs[1]
assert no_strike_span.font.strike is False
- assert str(no_strike_span.font.color.rgb) == 'E74C3C'
+ assert str(no_strike_span.font.color.rgb) == "E74C3C"
# Test H3 with Unsupported Transform and Span
h3_unsupported = document.paragraphs[12]
- assert str(h3_unsupported.runs[0].font.color.rgb) == 'F39C12'
+ assert str(h3_unsupported.runs[0].font.color.rgb) == "F39C12"
assert h3_unsupported.runs[0].font.size == 196850
# Test supported transform in span
assert len(h3_unsupported.runs) >= 2
supported_span = h3_unsupported.runs[1]
- assert supported_span.text == 'Supported Transform In Span' # capitalize
+ assert supported_span.text == "Supported Transform In Span" # capitalize
# Test H4 with Reset Styles and Span
h4_reset = document.paragraphs[13]
@@ -1324,7 +1284,7 @@ def test_headers_with_css(self):
h1_transparent = document.paragraphs[14]
assert h1_transparent.runs[0].font.size == 361950
visible_span = h1_transparent.runs[1]
- assert str(visible_span.font.color.rgb) == 'ECF0F1'
+ assert str(visible_span.font.color.rgb) == "ECF0F1"
# Test H3 with All Three Decorations and Span
h3_all_decorations = document.paragraphs[15]
@@ -1352,40 +1312,34 @@ def test_headers_with_css(self):
def test_color_by_name(self):
color_html_example = (
- "
paragraph red
"
- "paragraph yellow
"
- "paragraph blue
"
- "paragraph green
"
- "paragraph darkgray
"
- "paragraph magenta
"
- "paragraph has default black because of invalid color name
"
+ 'paragraph red
'
+ 'paragraph yellow
'
+ 'paragraph blue
'
+ 'paragraph green
'
+ 'paragraph darkgray
'
+ 'paragraph magenta
'
+ 'paragraph has default black because of invalid color name
'
)
- self.document.add_heading(
- 'Test: Color by name',
- level=1
- )
+ self.document.add_heading("Test: Color by name", level=1)
# Add on document for human validation
self.parser.add_html_to_document(color_html_example, self.document)
document = self.parser.parse_html_string(color_html_example)
colors = [str(p.runs[0].font.color.rgb) for p in document.paragraphs]
- assert 'FF0000' in colors # Red
- assert 'FFFF00' in colors # Yellow
- assert '0000FF' in colors # Blue
- assert '008000' in colors # Green
- assert 'A9A9A9' in colors # Darkgray
- assert '000000' in colors # Black
- assert 'FF00FF' in colors # Magenta
+ assert "FF0000" in colors # Red
+ assert "FFFF00" in colors # Yellow
+ assert "0000FF" in colors # Blue
+ assert "008000" in colors # Green
+ assert "A9A9A9" in colors # Darkgray
+ assert "000000" in colors # Black
+ assert "FF00FF" in colors # Magenta
def test_table_cell_border_properties(self):
"""Validates that all table cells have the expected border size, style, and color."""
- self.document.add_heading(
- 'Test: Table Cell Border Properties',
- level=1
- )
+ self.document.add_heading("Test: Table Cell Border Properties", level=1)
# Add on document for human validation
self.parser.add_html_to_document(self.table3_html, self.document)
document = self.parser.parse_html_string(self.table3_html)
@@ -1396,38 +1350,38 @@ def test_table_cell_border_properties(self):
"top": {"color": "D95B48", "style": "single", "size": "1.0"},
"bottom": {"color": "D95B48", "style": "single", "size": "1.0"},
"left": {"color": "FF0000", "style": "single", "size": "1.0"},
- "right": {"color": "8B0000", "style": "single", "size": "1.0"}
+ "right": {"color": "8B0000", "style": "single", "size": "1.0"},
},
{
"top": {"color": "FAC32A", "style": "single", "size": "1.0"},
"bottom": {"color": "FAC32A", "style": "single", "size": "1.125"},
"left": {"color": "none", "style": "none", "size": "none"},
- "right": {"color": "FAC32A", "style": "single", "size": "12.0"}
+ "right": {"color": "FAC32A", "style": "single", "size": "12.0"},
},
{
"top": {"color": "30E667", "style": "none", "size": "5.67"},
"bottom": {"color": "30E667", "style": "single", "size": "5.67"},
"left": {"color": "30E667", "style": "single", "size": "5.67"},
- "right": {"color": "30E667", "style": "single", "size": "5.67"}
+ "right": {"color": "30E667", "style": "single", "size": "5.67"},
},
{
"top": {"color": "none", "style": "none", "size": "none"},
"bottom": {"color": "D948CF", "style": "single", "size": "1.5"},
"left": {"color": "none", "style": "none", "size": "none"},
- "right": {"color": "D948CF", "style": "single", "size": "5.67"}
+ "right": {"color": "D948CF", "style": "single", "size": "5.67"},
},
{
"top": {"color": "EAAAA7", "style": "single", "size": "1.1"},
"bottom": {"color": "EAAAA7", "style": "single", "size": "1.1"},
"left": {"color": "EAAAA7", "style": "single", "size": "1.1"},
- "right": {"color": "EAAAA7", "style": "single", "size": "1.1"}
+ "right": {"color": "EAAAA7", "style": "single", "size": "1.1"},
},
{
"top": {"color": "none", "style": "none", "size": "none"},
"bottom": {"color": "ACC4AA", "style": "dashed", "size": "7.2"},
"left": {"color": "none", "style": "none", "size": "none"},
- "right": {"color": "ACC4AA", "style": "dotted", "size": "4.8"}
- }
+ "right": {"color": "ACC4AA", "style": "dotted", "size": "4.8"},
+ },
]
# Validate border properties for each cell
@@ -1437,21 +1391,21 @@ def test_table_cell_border_properties(self):
# Get the table cell element and properties
tc = cell._tc
tcPr = tc.get_or_add_tcPr()
- tcBorders = tcPr.find(qn('w:tcBorders'))
+ tcBorders = tcPr.find(qn("w:tcBorders"))
# Extract border properties
border_sides = {
- 'top': tcBorders.find(qn('w:top')) if tcBorders is not None else None,
- 'bottom': tcBorders.find(qn('w:bottom')) if tcBorders is not None else None,
- 'left': tcBorders.find(qn('w:left')) if tcBorders is not None else None,
- 'right': tcBorders.find(qn('w:right')) if tcBorders is not None else None,
+ "top": tcBorders.find(qn("w:top")) if tcBorders is not None else None,
+ "bottom": tcBorders.find(qn("w:bottom")) if tcBorders is not None else None,
+ "left": tcBorders.find(qn("w:left")) if tcBorders is not None else None,
+ "right": tcBorders.find(qn("w:right")) if tcBorders is not None else None,
}
for side, border in border_sides.items():
if border is not None:
- color = border.get(qn('w:color'), "").upper() # Ensure uppercase and no #
- size = border.get(qn('w:sz'))
- style = border.get(qn('w:val'))
+ color = border.get(qn("w:color"), "").upper() # Ensure uppercase and no #
+ size = border.get(qn("w:sz"))
+ style = border.get(qn("w:val"))
else:
color, size, style = "none", "none", "none"
@@ -1480,22 +1434,19 @@ def test_table_cell_border_properties(self):
def test_table_cell_background_color(self):
"""Validates that all table cells have the expected background color."""
- self.document.add_heading(
- 'Test: Table Cell Background Color',
- level=1
- )
+ self.document.add_heading("Test: Table Cell Background Color", level=1)
# Add on document for human validation
self.parser.add_html_to_document(self.table3_html, self.document)
document = self.parser.parse_html_string(self.table3_html)
# Define expected background colors for each cell
expected_background_colors = [
- "3749EF", # Row 1 Column 1
- "33b32e", # Row 1 Column 2
- "BFBFBF", # Row 2 Column 1
- "2eaab3", # Row 2 Column 2
- "99fffa", # Row 3 Column 1
- "2eaab3" # Row 3 Column 2
+ "3749EF", # Row 1 Column 1
+ "33b32e", # Row 1 Column 2
+ "BFBFBF", # Row 2 Column 1
+ "2eaab3", # Row 2 Column 2
+ "99fffa", # Row 3 Column 1
+ "2eaab3", # Row 3 Column 2
]
# Validate background colors for each cell
@@ -1507,9 +1458,9 @@ def test_table_cell_background_color(self):
tcPr = tc.get_or_add_tcPr()
# Get the background color (shading) if it exists
- shading = tcPr.find(qn('w:shd'))
+ shading = tcPr.find(qn("w:shd"))
if shading is not None:
- background_color = shading.get(qn('w:fill'), "").upper() # Ensure uppercase and no #
+ background_color = shading.get(qn("w:fill"), "").upper() # Ensure uppercase and no #
else:
background_color = "None"
@@ -1525,10 +1476,7 @@ def test_table_cell_background_color(self):
def test_table_cell_dimensions(self):
"""Validates that all table cells have the expected width and height."""
- self.document.add_heading(
- 'Test: Table Cell Dimensions',
- level=1
- )
+ self.document.add_heading("Test: Table Cell Dimensions", level=1)
# Add on document for human validation
self.parser.add_html_to_document(self.table3_html, self.document)
document = self.parser.parse_html_string(self.table3_html)
@@ -1539,35 +1487,35 @@ def test_table_cell_dimensions(self):
[
{
"width": "258.35px", # Width for the first cell
- "height": "23.75pt" # Height for the first cell
+ "height": "23.75pt", # Height for the first cell
},
{
- "width": "222.2pt", # Width for the second cell
- "height": "23.75pt" # Height for the second cell
- }
+ "width": "222.2pt", # Width for the second cell
+ "height": "23.75pt", # Height for the second cell
+ },
],
# Second row
[
{
"width": "258.35in", # Width for the first cell
- "height": "15.5pt" # Height for the first cell
+ "height": "15.5pt", # Height for the first cell
},
{
- "width": "6cm", # Width for the second cell
- "height": "15.5pt" # Height for the second cell
- }
+ "width": "6cm", # Width for the second cell
+ "height": "15.5pt", # Height for the second cell
+ },
],
# Third row
[
{
"width": "258.35pt", # Width for the first cell
- "height": "2rem" # Height for the first cell
+ "height": "2rem", # Height for the first cell
},
{
- "width": "6cm", # Width for the second cell
- "height": "2em" # Height for the second cell
- }
- ]
+ "width": "6cm", # Width for the second cell
+ "height": "2em", # Height for the second cell
+ },
+ ],
]
# Validate dimensions for each cell
@@ -1589,8 +1537,7 @@ def test_table_cell_dimensions(self):
expected_height_px = unit_converter(expected_height, "px")
assert round(abs(cell_width_px - expected_width_px), 2) <= 0.03, (
- f"Width mismatch for cell ({row_idx}, {cell_idx}): "
- f"expected {expected_width_px}px, got {cell_width_px}px"
+ f"Width mismatch for cell ({row_idx}, {cell_idx}): expected {expected_width_px}px, got {cell_width_px}px"
)
assert round(abs(cell_height_px - expected_height_px), 2) <= 0.03, (
f"Height mismatch for cell ({row_idx}, {cell_idx}): "
@@ -1624,18 +1571,18 @@ def test_border_with_keywords(self):
# Get the table cell element and properties
tc = cell._tc
tcPr = tc.get_or_add_tcPr()
- tcBorders = tcPr.find(qn('w:tcBorders'))
+ tcBorders = tcPr.find(qn("w:tcBorders"))
# Extract border properties
border_sides = {
- 'top': tcBorders.find(qn('w:top')) if tcBorders is not None else None,
- 'bottom': tcBorders.find(qn('w:bottom')) if tcBorders is not None else None,
- 'left': tcBorders.find(qn('w:left')) if tcBorders is not None else None,
- 'right': tcBorders.find(qn('w:right')) if tcBorders is not None else None,
+ "top": tcBorders.find(qn("w:top")) if tcBorders is not None else None,
+ "bottom": tcBorders.find(qn("w:bottom")) if tcBorders is not None else None,
+ "left": tcBorders.find(qn("w:left")) if tcBorders is not None else None,
+ "right": tcBorders.find(qn("w:right")) if tcBorders is not None else None,
}
for side, border in border_sides.items():
- size = border.get(qn('w:sz')) if border is not None else "none"
+ size = border.get(qn("w:sz")) if border is not None else "none"
# Convert size from eighths of a point to points
size_in_pt = str(float(size) / 8) if size and size != "none" else "none"
@@ -1667,20 +1614,20 @@ def test_border_style_with_diff_formats(self):
"top": {"color": "ADD8E6", "style": "single", "size": "1.0"},
"bottom": {"color": "none", "style": "none", "size": "none"},
"left": {"color": "000000", "style": "none", "size": "2.25"},
- "right": {"color": "000000", "style": "single", "size": "1.0"}
+ "right": {"color": "000000", "style": "single", "size": "1.0"},
},
{
"top": {"color": "000000", "style": "single", "size": "3.75"},
"bottom": {"color": "none", "style": "none", "size": "none"},
"left": {"color": "000000", "style": "single", "size": "0.75"},
- "right": {"color": "773366", "style": "single", "size": "0.75"}
+ "right": {"color": "773366", "style": "single", "size": "0.75"},
},
{
"top": {"color": "FFA500", "style": "single", "size": "1.0"},
"bottom": {"color": "FF00FF", "style": "single", "size": "3.75"},
"left": {"color": "000000", "style": "dashed", "size": "2.25"},
- "right": {"color": "none", "style": "none", "size": "none"}
- }
+ "right": {"color": "none", "style": "none", "size": "none"},
+ },
]
cell_idx = 0
@@ -1689,21 +1636,21 @@ def test_border_style_with_diff_formats(self):
# Get the table cell element and properties
tc = cell._tc
tcPr = tc.get_or_add_tcPr()
- tcBorders = tcPr.find(qn('w:tcBorders'))
+ tcBorders = tcPr.find(qn("w:tcBorders"))
# Extract border properties
border_sides = {
- 'top': tcBorders.find(qn('w:top')) if tcBorders is not None else None,
- 'bottom': tcBorders.find(qn('w:bottom')) if tcBorders is not None else None,
- 'left': tcBorders.find(qn('w:left')) if tcBorders is not None else None,
- 'right': tcBorders.find(qn('w:right')) if tcBorders is not None else None,
+ "top": tcBorders.find(qn("w:top")) if tcBorders is not None else None,
+ "bottom": tcBorders.find(qn("w:bottom")) if tcBorders is not None else None,
+ "left": tcBorders.find(qn("w:left")) if tcBorders is not None else None,
+ "right": tcBorders.find(qn("w:right")) if tcBorders is not None else None,
}
for side, border in border_sides.items():
if border is not None:
- color = border.get(qn('w:color'), "").upper() # Ensure uppercase and no #
- size = border.get(qn('w:sz'))
- style = border.get(qn('w:val'))
+ color = border.get(qn("w:color"), "").upper() # Ensure uppercase and no #
+ size = border.get(qn("w:sz"))
+ style = border.get(qn("w:val"))
else:
color, size, style = "none", "none", "none"
@@ -1731,7 +1678,7 @@ def test_border_style_with_diff_formats(self):
def test_unbalanced_table(self):
# A table with more td elements in latter rows than in the first
- self.document.add_heading('Test: Handling unbalanced tables', level=1)
+ self.document.add_heading("Test: Handling unbalanced tables", level=1)
html_unbalanced_table = """
@@ -1766,7 +1713,7 @@ def test_html_comment_rendering(self):
"""
# Process document using parser
- self.parser.options['html-comments'] = True
+ self.parser.options["html-comments"] = True
self.parser.add_html_to_document(html_with_comment, self.document)
document = self.parser.parse_html_string(html_with_comment)
@@ -1777,15 +1724,12 @@ def test_html_comment_rendering(self):
expected_comment = "# This is a comment"
# Assert the comment paragraph exists
- assert any(
- expected_comment == text for text in paragraph_texts
- ), f"Expected comment '{expected_comment}' to appear in the document, but it was not found."
+ assert any(expected_comment == text for text in paragraph_texts), (
+ f"Expected comment '{expected_comment}' to appear in the document, but it was not found."
+ )
# (Optional) Check styling if needed: green color or italic
- comment_paragraph = next(
- (p for p in document.paragraphs if p.text.strip() == expected_comment),
- None
- )
+ comment_paragraph = next((p for p in document.paragraphs if p.text.strip() == expected_comment), None)
assert comment_paragraph is not None, "Comment paragraph not found for style checks."
comment_run = comment_paragraph.runs[0]
@@ -1795,10 +1739,9 @@ def test_html_comment_rendering(self):
# color assertion (dark-ish green #008000)
expected_rgb = parse_color("#008000")
- assert (
- comment_run.font.color.rgb is not None
- and comment_run.font.color.rgb == RGBColor(*expected_rgb)
- ), f"Comment run color should be green ({expected_rgb})."
+ assert comment_run.font.color.rgb is not None and comment_run.font.color.rgb == RGBColor(*expected_rgb), (
+ f"Comment run color should be green ({expected_rgb})."
+ )
def test_emojis_and_special_characters(self):
emojis_and_special_chars_html_example = """
@@ -1811,10 +1754,7 @@ def test_emojis_and_special_characters(self):