# Copyright (c) 2010-2024 openpyxl
|
|
from copy import copy
|
|
from openpyxl.compat import safe_string
|
from openpyxl.utils import (
|
get_column_letter,
|
get_column_interval,
|
column_index_from_string,
|
range_boundaries,
|
)
|
from openpyxl.utils.units import DEFAULT_COLUMN_WIDTH
|
from openpyxl.descriptors import (
|
Integer,
|
Float,
|
Bool,
|
Strict,
|
String,
|
Alias,
|
)
|
from openpyxl.descriptors.serialisable import Serialisable
|
from openpyxl.styles.styleable import StyleableObject
|
from openpyxl.utils.bound_dictionary import BoundDictionary
|
from openpyxl.xml.functions import Element
|
|
|
class Dimension(Strict, StyleableObject):
|
"""Information about the display properties of a row or column."""
|
__fields__ = ('hidden',
|
'outlineLevel',
|
'collapsed',)
|
|
index = Integer()
|
hidden = Bool()
|
outlineLevel = Integer(allow_none=True)
|
outline_level = Alias('outlineLevel')
|
collapsed = Bool()
|
style = Alias('style_id')
|
|
|
def __init__(self, index, hidden, outlineLevel,
|
collapsed, worksheet, visible=True, style=None):
|
super().__init__(sheet=worksheet, style_array=style)
|
self.index = index
|
self.hidden = hidden
|
self.outlineLevel = outlineLevel
|
self.collapsed = collapsed
|
|
|
def __iter__(self):
|
for key in self.__fields__:
|
value = getattr(self, key, None)
|
if value:
|
yield key, safe_string(value)
|
|
|
def __copy__(self):
|
cp = self.__new__(self.__class__)
|
attrib = self.__dict__
|
attrib['worksheet'] = self.parent
|
cp.__init__(**attrib)
|
cp._style = copy(self._style)
|
return cp
|
|
|
def __repr__(self):
|
return f"<{self.__class__.__name__} Instance, Attributes={dict(self)}>"
|
|
|
class RowDimension(Dimension):
|
"""Information about the display properties of a row."""
|
|
__fields__ = Dimension.__fields__ + ('ht', 'customFormat', 'customHeight', 's',
|
'thickBot', 'thickTop')
|
r = Alias('index')
|
s = Alias('style_id')
|
ht = Float(allow_none=True)
|
height = Alias('ht')
|
thickBot = Bool()
|
thickTop = Bool()
|
|
def __init__(self,
|
worksheet,
|
index=0,
|
ht=None,
|
customHeight=None, # do not write
|
s=None,
|
customFormat=None, # do not write
|
hidden=False,
|
outlineLevel=0,
|
outline_level=None,
|
collapsed=False,
|
visible=None,
|
height=None,
|
r=None,
|
spans=None,
|
thickBot=None,
|
thickTop=None,
|
**kw
|
):
|
if r is not None:
|
index = r
|
if height is not None:
|
ht = height
|
self.ht = ht
|
if visible is not None:
|
hidden = not visible
|
if outline_level is not None:
|
outlineLevel = outline_level
|
self.thickBot = thickBot
|
self.thickTop = thickTop
|
super().__init__(index, hidden, outlineLevel,
|
collapsed, worksheet, style=s)
|
|
@property
|
def customFormat(self):
|
"""Always true if there is a style for the row"""
|
return self.has_style
|
|
@property
|
def customHeight(self):
|
"""Always true if there is a height for the row"""
|
return self.ht is not None
|
|
|
class ColumnDimension(Dimension):
|
"""Information about the display properties of a column."""
|
|
width = Float()
|
bestFit = Bool()
|
auto_size = Alias('bestFit')
|
index = String()
|
min = Integer(allow_none=True)
|
max = Integer(allow_none=True)
|
collapsed = Bool()
|
|
__fields__ = Dimension.__fields__ + ('width', 'bestFit', 'customWidth', 'style',
|
'min', 'max')
|
|
def __init__(self,
|
worksheet,
|
index='A',
|
width=DEFAULT_COLUMN_WIDTH,
|
bestFit=False,
|
hidden=False,
|
outlineLevel=0,
|
outline_level=None,
|
collapsed=False,
|
style=None,
|
min=None,
|
max=None,
|
customWidth=False, # do not write
|
visible=None,
|
auto_size=None,):
|
self.width = width
|
self.min = min
|
self.max = max
|
if visible is not None:
|
hidden = not visible
|
if auto_size is not None:
|
bestFit = auto_size
|
self.bestFit = bestFit
|
if outline_level is not None:
|
outlineLevel = outline_level
|
self.collapsed = collapsed
|
super().__init__(index, hidden, outlineLevel,
|
collapsed, worksheet, style=style)
|
|
|
@property
|
def customWidth(self):
|
"""Always true if there is a width for the column"""
|
return bool(self.width)
|
|
|
def reindex(self):
|
"""
|
Set boundaries for column definition
|
"""
|
if not all([self.min, self.max]):
|
self.min = self.max = column_index_from_string(self.index)
|
|
@property
|
def range(self):
|
"""Return the range of cells actually covered"""
|
return f"{get_column_letter(self.min)}:{get_column_letter(self.max)}"
|
|
|
def to_tree(self):
|
attrs = dict(self)
|
if attrs.keys() != {'min', 'max'}:
|
return Element("col", **attrs)
|
|
|
class DimensionHolder(BoundDictionary):
|
"""
|
Allow columns to be grouped
|
"""
|
|
def __init__(self, worksheet, reference="index", default_factory=None):
|
self.worksheet = worksheet
|
self.max_outline = None
|
self.default_factory = default_factory
|
super().__init__(reference, default_factory)
|
|
|
def group(self, start, end=None, outline_level=1, hidden=False):
|
"""allow grouping a range of consecutive rows or columns together
|
|
:param start: first row or column to be grouped (mandatory)
|
:param end: last row or column to be grouped (optional, default to start)
|
:param outline_level: outline level
|
:param hidden: should the group be hidden on workbook open or not
|
"""
|
if end is None:
|
end = start
|
|
if isinstance(self.default_factory(), ColumnDimension):
|
new_dim = self[start]
|
new_dim.outline_level = outline_level
|
new_dim.hidden = hidden
|
work_sequence = get_column_interval(start, end)[1:]
|
for column_letter in work_sequence:
|
if column_letter in self:
|
del self[column_letter]
|
new_dim.min, new_dim.max = map(column_index_from_string, (start, end))
|
elif isinstance(self.default_factory(), RowDimension):
|
for el in range(start, end + 1):
|
new_dim = self.worksheet.row_dimensions[el]
|
new_dim.outline_level = outline_level
|
new_dim.hidden = hidden
|
|
|
def to_tree(self):
|
|
def sorter(value):
|
value.reindex()
|
return value.min
|
|
el = Element('cols')
|
outlines = set()
|
|
for col in sorted(self.values(), key=sorter):
|
obj = col.to_tree()
|
if obj is not None:
|
outlines.add(col.outlineLevel)
|
el.append(obj)
|
|
if outlines:
|
self.max_outline = max(outlines)
|
|
if len(el):
|
return el # must have at least one child
|
|
|
class SheetFormatProperties(Serialisable):
|
|
tagname = "sheetFormatPr"
|
|
baseColWidth = Integer(allow_none=True)
|
defaultColWidth = Float(allow_none=True)
|
defaultRowHeight = Float()
|
customHeight = Bool(allow_none=True)
|
zeroHeight = Bool(allow_none=True)
|
thickTop = Bool(allow_none=True)
|
thickBottom = Bool(allow_none=True)
|
outlineLevelRow = Integer(allow_none=True)
|
outlineLevelCol = Integer(allow_none=True)
|
|
def __init__(self,
|
baseColWidth=8, #according to spec
|
defaultColWidth=None,
|
defaultRowHeight=15,
|
customHeight=None,
|
zeroHeight=None,
|
thickTop=None,
|
thickBottom=None,
|
outlineLevelRow=None,
|
outlineLevelCol=None,
|
):
|
self.baseColWidth = baseColWidth
|
self.defaultColWidth = defaultColWidth
|
self.defaultRowHeight = defaultRowHeight
|
self.customHeight = customHeight
|
self.zeroHeight = zeroHeight
|
self.thickTop = thickTop
|
self.thickBottom = thickBottom
|
self.outlineLevelRow = outlineLevelRow
|
self.outlineLevelCol = outlineLevelCol
|
|
|
class SheetDimension(Serialisable):
|
|
tagname = "dimension"
|
|
ref = String()
|
|
def __init__(self,
|
ref=None,
|
):
|
self.ref = ref
|
|
|
@property
|
def boundaries(self):
|
return range_boundaries(self.ref)
|
