class Break(Serialisable):
tagname = "brk"
id = Integer(allow_none=True)
min = Integer(allow_none=True)
max = Integer(allow_none=True)
man = Bool(allow_none=True)
pt = Bool(allow_none=True)
def __init__(
self,
id=0,
min=0,
max=16383,
man=True,
pt=None,
):
self.id = id
self.min = min
self.max = max
self.man = man
self.pt = pt
class ColorChangeEffect(Serialisable):
useA = Bool(allow_none=True)
clrFrom = Typed(expected_type=Color, )
clrTo = Typed(expected_type=Color, )
def __init__(self,
useA=None,
clrFrom=None,
clrTo=None,
):
self.useA = useA
self.clrFrom = clrFrom
self.clrTo = clrTo
class PrintOptions(Serialisable):
""" Worksheet print options """
tagname = "printOptions"
horizontalCentered = Bool(allow_none=True)
verticalCentered = Bool(allow_none=True)
headings = Bool(allow_none=True)
gridLines = Bool(allow_none=True)
gridLinesSet = Bool(allow_none=True)
def __init__(
self,
horizontalCentered=None,
verticalCentered=None,
headings=None,
gridLines=None,
gridLinesSet=None,
):
self.horizontalCentered = horizontalCentered
self.verticalCentered = verticalCentered
self.headings = headings
self.gridLines = gridLines
self.gridLinesSet = gridLinesSet
class ColorFilter(Serialisable):
tagname = "colorFilter"
dxfId = Integer(allow_none=True)
cellColor = Bool(allow_none=True)
def __init__(
self,
dxfId=None,
cellColor=None,
):
self.dxfId = dxfId
self.cellColor = cellColor
class SmartTagProperties(Serialisable):
tagname = "smartTagPr"
embed = Bool(allow_none=True)
show = NoneSet(values=(['all', 'noIndicator']))
def __init__(
self,
embed=None,
show=None,
):
self.embed = embed
self.show = show
class ChartsheetView(Serialisable):
tagname = "sheetView"
tabSelected = Bool(allow_none=True)
zoomScale = Integer(allow_none=True)
workbookViewId = Integer()
zoomToFit = Bool(allow_none=True)
extLst = Typed(expected_type=ExtensionList, allow_none=True)
__elements__ = ()
def __init__(
self,
tabSelected=None,
zoomScale=None,
workbookViewId=0,
zoomToFit=None,
extLst=None,
):
self.tabSelected = tabSelected
self.zoomScale = zoomScale
self.workbookViewId = workbookViewId
self.zoomToFit = zoomToFit
class GroupMember(Serialisable):
tagname = "groupMember"
uniqueName = String()
group = Bool()
def __init__(
self,
uniqueName=None,
group=None,
):
self.uniqueName = uniqueName
self.group = group
class TableStyleInfo(Serialisable):
tagname = "tableStyleInfo"
name = String(allow_none=True)
showFirstColumn = Bool(allow_none=True)
showLastColumn = Bool(allow_none=True)
showRowStripes = Bool(allow_none=True)
showColumnStripes = Bool(allow_none=True)
def __init__(
self,
name=None,
showFirstColumn=None,
showLastColumn=None,
showRowStripes=None,
showColumnStripes=None,
):
self.name = name
self.showFirstColumn = showFirstColumn
self.showLastColumn = showLastColumn
self.showRowStripes = showRowStripes
self.showColumnStripes = showColumnStripes
class WorksheetProperties(Serialisable):
tagname = "sheetPr"
codeName = String(allow_none=True)
enableFormatConditionsCalculation = Bool(allow_none=True)
filterMode = Bool(allow_none=True)
published = Bool(allow_none=True)
syncHorizontal = Bool(allow_none=True)
syncRef = String(allow_none=True)
syncVertical = Bool(allow_none=True)
transitionEvaluation = Bool(allow_none=True)
transitionEntry = Bool(allow_none=True)
tabColor = ColorDescriptor(allow_none=True)
outlinePr = Typed(expected_type=Outline, allow_none=True)
pageSetUpPr = Typed(expected_type=PageSetupProperties, allow_none=True)
__elements__ = ('tabColor', 'outlinePr', 'pageSetUpPr')
def __init__(self,
codeName=None,
enableFormatConditionsCalculation=None,
filterMode=None,
published=None,
syncHorizontal=None,
syncRef=None,
syncVertical=None,
transitionEvaluation=None,
transitionEntry=None,
tabColor=None,
outlinePr=None,
pageSetUpPr=None):
""" Attributes """
self.codeName = codeName
self.enableFormatConditionsCalculation = enableFormatConditionsCalculation
self.filterMode = filterMode
self.published = published
self.syncHorizontal = syncHorizontal
self.syncRef = syncRef
self.syncVertical = syncVertical
self.transitionEvaluation = transitionEvaluation
self.transitionEntry = transitionEntry
""" Elements """
self.tabColor = tabColor
if outlinePr is None:
self.outlinePr = Outline(summaryBelow=True, summaryRight=True)
else:
self.outlinePr = outlinePr
if pageSetUpPr is None:
pageSetUpPr = PageSetupProperties()
self.pageSetUpPr = pageSetUpPr
class LinearShadeProperties(Serialisable):
tagname = "lin"
namespace = DRAWING_NS
ang = Integer()
scaled = Bool(allow_none=True)
def __init__(
self,
ang=None,
scaled=None,
):
self.ang = ang
self.scaled = scaled
class _NamedCellStyle(Serialisable):
"""
Pointer-based representation of named styles in XML
xfId refers to the corresponding CellStyleXfs
Not used in client code.
"""
tagname = "cellStyle"
name = String()
xfId = Integer()
builtinId = Integer(allow_none=True)
iLevel = Integer(allow_none=True)
hidden = Bool(allow_none=True)
customBuiltin = Bool(allow_none=True)
extLst = Typed(expected_type=ExtensionList, allow_none=True)
__elements__ = ()
def __init__(
self,
name=None,
xfId=None,
builtinId=None,
iLevel=None,
hidden=None,
customBuiltin=None,
extLst=None,
):
self.name = name
self.xfId = xfId
self.builtinId = builtinId
self.iLevel = iLevel
self.hidden = hidden
self.customBuiltin = customBuiltin
class ExternalSheetData(Serialisable):
sheetId = Integer()
refreshError = Bool(allow_none=True)
row = Sequence(expected_type=ExternalRow)
__elements__ = ('row',)
def __init__(self,
sheetId=None,
refreshError=None,
row=(),
):
self.sheetId = sheetId
self.refreshError = refreshError
self.row = row
class CustomFilters(Serialisable):
tagname = "customFilters"
_and = Bool(allow_none=True)
customFilter = Sequence(expected_type=CustomFilter) # min 1, max 2
__elements__ = ('customFilter', )
def __init__(
self,
_and=None,
customFilter=(),
):
self._and = _and
self.customFilter = customFilter
class ReflectionEffect(Serialisable):
blurRad = Float()
stA = Integer()
stPos = Integer()
endA = Integer()
endPos = Integer()
dist = Float()
dir = Integer()
fadeDir = Integer()
sx = Integer()
sy = Integer()
kx = Integer()
ky = Integer()
algn = Set(values=(['tl', 't', 'tr', 'l', 'ctr', 'r', 'bl', 'b', 'br']))
rotWithShape = Bool(allow_none=True)
def __init__(self,
blurRad=None,
stA=None,
stPos=None,
endA=None,
endPos=None,
dist=None,
dir=None,
fadeDir=None,
sx=None,
sy=None,
kx=None,
ky=None,
algn=None,
rotWithShape=None,
):
self.blurRad = blurRad
self.stA = stA
self.stPos = stPos
self.endA = endA
self.endPos = endPos
self.dist = dist
self.dir = dir
self.fadeDir = fadeDir
self.sx = sx
self.sy = sy
self.kx = kx
self.ky = ky
self.algn = algn
self.rotWithShape = rotWithShape
class FieldItem(Serialisable):
tagname = "item"
n = String(allow_none=True)
t = Set(values=([
'data', 'default', 'sum', 'countA', 'avg', 'max', 'min', 'product',
'count', 'stdDev', 'stdDevP', 'var', 'varP', 'grand', 'blank'
]))
h = Bool(allow_none=True)
s = Bool(allow_none=True)
sd = Bool(allow_none=True)
f = Bool(allow_none=True)
m = Bool(allow_none=True)
c = Bool(allow_none=True)
x = Integer(allow_none=True)
d = Bool(allow_none=True)
e = Bool(allow_none=True)
def __init__(
self,
n=None,
t="data",
h=None,
s=None,
sd=True,
f=None,
m=None,
c=None,
x=None,
d=None,
e=None,
):
self.n = n
self.t = t
self.h = h
self.s = s
self.sd = sd
self.f = f
self.m = m
self.c = c
self.x = x
self.d = d
self.e = e
class TableFormula(Serialisable):
tagname = "tableFormula"
## Note formula is stored as the text value
array = Bool(allow_none=True)
attr_text = Descriptor()
text = Alias('attr_text')
def __init__(
self,
array=None,
attr_text=None,
):
self.array = array
self.attr_text = attr_text
class OuterShadow(ColorChoice):
tagname = "outerShdw"
blurRad = Float(allow_none=True)
dist = Float(allow_none=True)
dir = Integer(allow_none=True)
sx = Integer(allow_none=True)
sy = Integer(allow_none=True)
kx = Integer(allow_none=True)
ky = Integer(allow_none=True)
algn = Set(values=['tl', 't', 'tr', 'l', 'ctr', 'r', 'bl', 'b', 'br'])
rotWithShape = Bool(allow_none=True)
# uses element group EG_ColorChoice
scrgbClr = ColorChoice.scrgbClr
srgbClr = ColorChoice.srgbClr
hslClr = ColorChoice.hslClr
sysClr = ColorChoice.sysClr
schemeClr = ColorChoice.schemeClr
prstClr = ColorChoice.prstClr
__elements__ = ('scrgbClr', 'srgbClr', 'hslClr', 'sysClr', 'schemeClr', 'prstClr')
def __init__(self,
blurRad=None,
dist=None,
dir=None,
sx=None,
sy=None,
kx=None,
ky=None,
algn=None,
rotWithShape=None,
**kw
):
self.blurRad = blurRad
self.dist = dist
self.dir = dir
self.sx = sx
self.sy = sy
self.kx = kx
self.ky = ky
self.algn = algn
self.rotWithShape = rotWithShape
super(OuterShadow, self).__init__(**kw)
class CalcProperties(Serialisable):
tagname = "calcPr"
calcId = Integer()
calcMode = NoneSet(values=(['manual', 'auto', 'autoNoTable']))
fullCalcOnLoad = Bool(allow_none=True)
refMode = NoneSet(values=(['A1', 'R1C1']))
iterate = Bool(allow_none=True)
iterateCount = Integer(allow_none=True)
iterateDelta = Float(allow_none=True)
fullPrecision = Bool(allow_none=True)
calcCompleted = Bool(allow_none=True)
calcOnSave = Bool(allow_none=True)
concurrentCalc = Bool(allow_none=True)
concurrentManualCount = Integer(allow_none=True)
forceFullCalc = Bool(allow_none=True)
def __init__(
self,
calcId=124519,
calcMode=None,
fullCalcOnLoad=True,
refMode=None,
iterate=None,
iterateCount=None,
iterateDelta=None,
fullPrecision=None,
calcCompleted=None,
calcOnSave=None,
concurrentCalc=None,
concurrentManualCount=None,
forceFullCalc=None,
):
self.calcId = calcId
self.calcMode = calcMode
self.fullCalcOnLoad = fullCalcOnLoad
self.refMode = refMode
self.iterate = iterate
self.iterateCount = iterateCount
self.iterateDelta = iterateDelta
self.fullPrecision = fullPrecision
self.calcCompleted = calcCompleted
self.calcOnSave = calcOnSave
self.concurrentCalc = concurrentCalc
self.concurrentManualCount = concurrentManualCount
self.forceFullCalc = forceFullCalc
class NonVisualDrawingShapeProps(Serialisable):
tagname = "cNvSpPr"
spLocks = Typed(expected_type=GroupLocking, allow_none=True)
txBax = Bool(allow_none=True)
extLst = Typed(expected_type=OfficeArtExtensionList, allow_none=True)
__elements__ = ("spLocks", "txBax")
def __init__(
self,
spLocks=None,
txBox=None,
extLst=None,
):
self.spLocks = spLocks
self.txBox = txBox
class NonVisualPictureProperties(Serialisable):
tagname = "cNvPicPr"
preferRelativeResize = Bool(allow_none=True)
picLocks = Typed(expected_type=PictureLocking, allow_none=True)
extLst = Typed(expected_type=OfficeArtExtensionList, allow_none=True)
__elements__ = ("picLocks", )
def __init__(
self,
preferRelativeResize=None,
picLocks=None,
extLst=None,
):
self.preferRelativeResize = preferRelativeResize
self.picLocks = picLocks
class DataValidationList(Serialisable):
tagname = "dataValidations"
disablePrompts = Bool(allow_none=True)
xWindow = Integer(allow_none=True)
yWindow = Integer(allow_none=True)
dataValidation = Sequence(expected_type=DataValidation)
__elements__ = ('dataValidation', )
__attrs__ = ('disablePrompts', 'xWindow', 'yWindow', 'count')
def __init__(
self,
disablePrompts=None,
xWindow=None,
yWindow=None,
count=None,
dataValidation=(),
):
self.disablePrompts = disablePrompts
self.xWindow = xWindow
self.yWindow = yWindow
self.dataValidation = dataValidation
@property
def count(self):
return len(self)
def __len__(self):
return len(self.dataValidation)
def append(self, dv):
self.dataValidation.append(dv)
def to_tree(self, tagname=None):
"""
Need to skip validations that have no cell ranges
"""
ranges = self.dataValidation # copy
self.dataValidation = [r for r in self.dataValidation if bool(r.sqref)]
xml = super(DataValidationList, self).to_tree(tagname)
self.dataValidation = ranges
return xml
class Text(Serialisable):
tagname = "s"
tpls = Sequence(expected_type=TupleList)
x = Sequence(expected_type=Index)
v = String()
u = Bool(allow_none=True)
f = Bool(allow_none=True)
c = String(allow_none=True)
cp = Integer(allow_none=True)
_in = Integer(allow_none=True)
bc = HexBinary(allow_none=True)
fc = HexBinary(allow_none=True)
i = Bool(allow_none=True)
un = Bool(allow_none=True)
st = Bool(allow_none=True)
b = Bool(allow_none=True)
__elements__ = ('tpls', 'x')
def __init__(self,
tpls=(),
x=(),
v=None,
u=None,
f=None,
c=None,
cp=None,
_in=None,
bc=None,
fc=None,
i=None,
un=None,
st=None,
b=None,
):
self.tpls = tpls
self.x = x
self.v = v
self.u = u
self.f = f
self.c = c
self.cp = cp
self._in = _in
self.bc = bc
self.fc = fc
self.i = i
self.un = un
self.st = st
self.b = b
class Consolidation(Serialisable):
tagname = "consolidation"
autoPage = Bool(allow_none=True)
pages = NestedSequence(expected_type=Page, count=True)
rangeSets = NestedSequence(expected_type=RangeSet, count=True)
__elements__ = ('pages', 'rangeSets')
def __init__(
self,
autoPage=None,
pages=(),
rangeSets=(),
):
self.autoPage = autoPage
self.pages = pages
self.rangeSets = rangeSets
class PivotDimension(Serialisable):
tagname = "dimension"
measure = Bool()
name = String()
uniqueName = String()
caption = String()
def __init__(
self,
measure=None,
name=None,
uniqueName=None,
caption=None,
):
self.measure = measure
self.name = name
self.uniqueName = uniqueName
self.caption = caption
class FormatObject(Serialisable):
tagname = "cfvo"
type = Set(
values=(['num', 'percent', 'max', 'min', 'formula', 'percentile']))
val = ValueDescriptor(allow_none=True)
gte = Bool(allow_none=True)
extLst = Typed(expected_type=ExtensionList, allow_none=True)
__elements__ = ()
def __init__(
self,
type,
val=None,
gte=None,
extLst=None,
):
self.type = type
self.val = val
self.gte = gte
class ConnectorShape(Serialisable):
tagname = "cxnSp"
nvCxnSpPr = Typed(expected_type=ConnectorNonVisual)
spPr = Typed(expected_type=GraphicalProperties)
style = Typed(expected_type=ShapeStyle, allow_none=True)
macro = String(allow_none=True)
fPublished = Bool(allow_none=True)
def __init__(self,
nvCxnSpPr=None,
spPr=None,
style=None,
macro=None,
fPublished=None,
):
self.nvCxnSpPr = nvCxnSpPr
self.spPr = spPr
self.style = style
self.macro = macro
self.fPublished = fPublished
class ChartFormat(Serialisable):
tagname = "chartFormat"
chart = Integer()
format = Integer()
series = Bool()
pivotArea = Typed(expected_type=PivotArea, )
__elements__ = ('pivotArea', )
def __init__(
self,
chart=None,
format=None,
series=None,
pivotArea=None,
):
self.chart = chart
self.format = format
self.series = series
self.pivotArea = pivotArea
class ConditionalFormatting(Serialisable):
tagname = "conditionalFormatting"
sqref = Convertible(expected_type=MultiCellRange)
cells = Alias("sqref")
pivot = Bool(allow_none=True)
cfRule = Sequence(expected_type=Rule)
rules = Alias("cfRule")
def __init__(self, sqref=(), pivot=None, cfRule=(), extLst=None):
self.sqref = sqref
self.pivot = pivot
self.cfRule = cfRule
def __eq__(self, other):
if not isinstance(other, self.__class__):
return False
return self.sqref == other.sqref
def __hash__(self):
return hash(str(self.sqref))
def __repr__(self):
return "<{cls} {cells}>".format(cls=self.__class__.__name__, cells=self.sqref)
def __contains__(self, coord):
"""
Check whether a certain cell is affected by the formatting
"""
return coord in self.sqref
class XMLColumnProps(Serialisable):
tagname = "xmlColumnPr"
mapId = Integer()
xpath = String()
denormalized = Bool(allow_none=True)
xmlDataType = String()
extLst = Typed(expected_type=ExtensionList, allow_none=True)
__elements__ = ()
def __init__(
self,
mapId=None,
xpath=None,
denormalized=None,
xmlDataType=None,
extLst=None,
):
self.mapId = mapId
self.xpath = xpath
self.denormalized = denormalized
self.xmlDataType = xmlDataType
class DataBar(RuleType):
tagname = "dataBar"
minLength = Integer(allow_none=True)
maxLength = Integer(allow_none=True)
showValue = Bool(allow_none=True)
color = ColorDescriptor()
__elements__ = ('cfvo', 'color')
def __init__(
self,
minLength=None,
maxLength=None,
showValue=None,
cfvo=None,
color=None,
):
self.minLength = minLength
self.maxLength = maxLength
self.showValue = showValue
self.cfvo = cfvo
self.color = color