# Copyright (c) 2010-2023 openpyxl
"""
RichText definition
"""
from copy import copy
from openpyxl.cell.text import InlineFont, Text
from openpyxl.descriptors import (
Strict,
String,
Typed
)
[docs]class TextBlock(Strict):
""" Represents text string in a specific format
This class is used as part of constructing a rich text strings.
"""
font = Typed(expected_type=InlineFont)
text = String()
def __init__(self, font, text):
self.font = font
self.text = text
def __eq__(self, other):
return self.text == other.text and self.font == other.font
def __str__(self):
"""Just retun the text"""
return self.text
def __repr__(self):
font = self.font != InlineFont() and self.font or "default"
return f"{self.__class__.__name__} text={self.text}, font={font}"
#
# Rich Text class.
# This class behaves just like a list whose members are either simple strings, or TextBlock() instances.
# In addition, it can be initialized in several ways:
# t = CellRFichText([...]) # initialize with a list.
# t = CellRFichText((...)) # initialize with a tuple.
# t = CellRichText(node) # where node is an Element() from either lxml or xml.etree (has a 'tag' element)
[docs]class CellRichText(list):
"""Represents a rich text string.
Initialize with a list made of pure strings or :class:`TextBlock` elements
Can index object to access or modify individual rich text elements
it also supports the + and += operators between rich text strings
There are no user methods for this class
operations which modify the string will generally call an optimization pass afterwards,
that merges text blocks with identical formats, consecutive pure text strings,
and remove empty strings and empty text blocks
"""
def __init__(self, *args):
if len(args) == 1:
args = args[0]
if isinstance(args, (list, tuple)):
CellRichText._check_rich_text(args)
else:
CellRichText._check_element(args)
args = [args]
else:
CellRichText._check_rich_text(args)
super().__init__(args)
@classmethod
def _check_element(cls, value):
if hasattr(value, "__str__"):
return
raise TypeError(f"Illegal CellRichText element {value}")
@classmethod
def _check_rich_text(cls, rich_text):
for t in rich_text:
CellRichText._check_element(t)
[docs] @classmethod
def from_tree(cls, node):
text = Text.from_tree(node)
if text.t:
return (text.t.replace('x005F_', ''),)
s = []
for r in text.r:
t = ""
if r.t:
t = r.t.replace('x005F_', '')
if r.rPr:
s.append(TextBlock(r.rPr, t))
else:
s.append(t)
return cls(s)
# Merge TextBlocks with identical formatting
# remove empty elements
def _opt(self):
last_t = None
l = CellRichText(tuple())
for t in self:
if isinstance(t, str):
if not t:
continue
elif not t.text:
continue
if type(last_t) == type(t):
if isinstance(t, str):
last_t += t
continue
elif last_t.font == t.font:
last_t.text += t.text
continue
if last_t:
l.append(last_t)
last_t = t
if last_t:
# Add remaining TextBlock at end of rich text
l.append(last_t)
super().__setitem__(slice(None), l)
return self
def __iadd__(self, arg):
# copy used here to create new TextBlock() so we don't modify the right hand side in _opt()
CellRichText._check_rich_text(arg)
super().__iadd__([copy(e) for e in list(arg)])
return self._opt()
def __add__(self, arg):
return CellRichText([copy(e) for e in list(self) + list(arg)])._opt()
def __setitem__(self, indx, val):
CellRichText._check_element(val)
super().__setitem__(indx, val)
self._opt()
[docs] def append(self, arg):
CellRichText._check_element(arg)
super().append(arg)
[docs] def extend(self, arg):
CellRichText._check_rich_text(arg)
super().extend(arg)
def __repr__(self):
return "CellRichText([{}])".format(', '.join((repr(s) for s in self)))
def __str__(self):
return ''.join([str(s) for s in self])
[docs] def as_list(self):
"""
Returns a list of the strings contained.
The main reason for this is to make editing easier.
"""
return [str(s) for s in self]