class RangePr(Serialisable):
tagname = "rangePr"
autoStart = Bool(allow_none=True)
autoEnd = Bool(allow_none=True)
groupBy = Set(values=([
'range', 'seconds', 'minutes', 'hours', 'days', 'months', 'quarters',
'years'
]))
startNum = Float(allow_none=True)
endNum = Float(allow_none=True)
startDate = DateTime(allow_none=True)
endDate = DateTime(allow_none=True)
groupInterval = Float(allow_none=True)
def __init__(
self,
autoStart=True,
autoEnd=True,
groupBy=range,
startNum=None,
endNum=None,
startDate=None,
endDate=None,
groupInterval=1,
):
self.autoStart = autoStart
self.autoEnd = autoEnd
self.groupBy = groupBy
self.startNum = startNum
self.endNum = endNum
self.startDate = startDate
self.endDate = endDate
self.groupInterval = groupInterval
class DynamicFilter(Serialisable):
tagname = "dynamicFilter"
type = Set(values=([
'null', 'aboveAverage', 'belowAverage', 'tomorrow', 'today',
'yesterday', 'nextWeek', 'thisWeek', 'lastWeek', 'nextMonth',
'thisMonth', 'lastMonth', 'nextQuarter', 'thisQuarter', 'lastQuarter',
'nextYear', 'thisYear', 'lastYear', 'yearToDate', 'Q1', 'Q2', 'Q3',
'Q4', 'M1', 'M2', 'M3', 'M4', 'M5', 'M6', 'M7', 'M8', 'M9', 'M10',
'M11', 'M12'
]))
val = Float(allow_none=True)
valIso = DateTime(allow_none=True)
maxVal = Float(allow_none=True)
maxValIso = DateTime(allow_none=True)
def __init__(
self,
type=None,
val=None,
valIso=None,
maxVal=None,
maxValIso=None,
):
self.type = type
self.val = val
self.valIso = valIso
self.maxVal = maxVal
self.maxValIso = maxValIso
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 InnerShadowEffect(ColorChoice):
blurRad = Float()
dist = Float()
dir = Integer()
# 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,
**kw
):
self.blurRad = blurRad
self.dist = dist
self.dir = dir
super(InnerShadowEffect, self).__init__(**kw)
class RangePr(Serialisable):
autoStart = Bool()
autoEnd = Bool()
groupBy = Set(values=(['range', 'seconds', 'minutes', 'hours', 'days', 'months', 'quarters', 'years']))
startNum = Float()
endNum = Float()
startDate = DateTime()
endDate = DateTime()
groupInterval = Float()
def __init__(self,
autoStart=None,
autoEnd=None,
groupBy=None,
startNum=None,
endNum=None,
startDate=None,
endDate=None,
groupInterval=None,
):
self.autoStart = autoStart
self.autoEnd = autoEnd
self.groupBy = groupBy
self.startNum = startNum
self.endNum = endNum
self.startDate = startDate
self.endDate = endDate
self.groupInterval = groupInterval
class GradientFill(Fill):
tagname = "gradientFill"
__fields__ = ('type', 'degree', 'left', 'right', 'top', 'bottom', 'stop')
type = Set(values=('linear', 'path'))
fill_type = Alias("type")
degree = Float()
left = Float()
right = Float()
top = Float()
bottom = Float()
stop = Sequence(expected_type=Color, nested=True)
def __init__(self, type="linear", degree=0, left=0, right=0, top=0,
bottom=0, stop=(), fill_type=None):
self.degree = degree
self.left = left
self.right = right
self.top = top
self.bottom = bottom
self.stop = stop
if fill_type is not None:
type = fill_type
self.type = type
def __iter__(self):
for attr in self.__attrs__:
value = getattr(self, attr)
if value:
yield attr, safe_string(value)
@classmethod
def _from_tree(cls, node):
colors = []
for color in safe_iterator(node, "{%s}color" % SHEET_MAIN_NS):
colors.append(Color.from_tree(color))
return cls(stop=colors, **node.attrib)
def _serialise_nested(self, sequence):
"""
Colors need special handling
"""
for idx, color in enumerate(sequence):
stop = Element("stop", position=str(idx))
stop.append(color.to_tree())
yield stop
def to_tree(self, tagname=None):
parent = Element("fill")
el = super(GradientFill, self).to_tree()
parent.append(el)
return parent
class GradientFill(Fill):
"""Fill areas with gradient
Two types of gradient fill are supported:
- A type='linear' gradient interpolates colours between
a set of specified Stops, across the length of an area.
The gradient is left-to-right by default, but this
orientation can be modified with the degree
attribute. A list of Colors can be provided instead
and they will be positioned with equal distance between them.
- A type='path' gradient applies a linear gradient from each
edge of the area. Attributes top, right, bottom, left specify
the extent of fill from the respective borders. Thus top="0.2"
will fill the top 20% of the cell.
"""
tagname = "gradientFill"
type = Set(values=('linear', 'path'))
fill_type = Alias("type")
degree = Float()
left = Float()
right = Float()
top = Float()
bottom = Float()
stop = StopList()
def __init__(self,
type="linear",
degree=0,
left=0,
right=0,
top=0,
bottom=0,
stop=()):
self.degree = degree
self.left = left
self.right = right
self.top = top
self.bottom = bottom
self.stop = stop
self.type = type
def __iter__(self):
for attr in self.__attrs__:
value = getattr(self, attr)
if value:
yield attr, safe_string(value)
def to_tree(self, tagname=None, namespace=None, idx=None):
parent = Element("fill")
el = super(GradientFill, self).to_tree()
parent.append(el)
return parent
class GradientFill(Fill):
tagname = "gradientFill"
type = Set(values=('linear', 'path'))
fill_type = Alias("type")
degree = Float()
left = Float()
right = Float()
top = Float()
bottom = Float()
stop = ValueSequence(expected_type=Color, to_tree=_serialise_stop)
def __init__(self,
type="linear",
degree=0,
left=0,
right=0,
top=0,
bottom=0,
stop=(),
fill_type=None):
self.degree = degree
self.left = left
self.right = right
self.top = top
self.bottom = bottom
self.stop = stop
if fill_type is not None:
type = fill_type
self.type = type
def __iter__(self):
for attr in self.__attrs__:
value = getattr(self, attr)
if value:
yield attr, safe_string(value)
@classmethod
def _from_tree(cls, node):
colors = []
for color in safe_iterator(node, "{%s}color" % SHEET_MAIN_NS):
colors.append(Color.from_tree(color))
return cls(stop=colors, **node.attrib)
def to_tree(self, tagname=None, namespace=None, idx=None):
parent = Element("fill")
el = super(GradientFill, self).to_tree()
parent.append(el)
return parent
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 PresetShadowEffect(ColorChoice):
prst = Set(values=(['shdw1', 'shdw2', 'shdw3', 'shdw4', 'shdw5', 'shdw6',
'shdw7', 'shdw8', 'shdw9', 'shdw10', 'shdw11', 'shdw12', 'shdw13',
'shdw14', 'shdw15', 'shdw16', 'shdw17', 'shdw18', 'shdw19', 'shdw20']))
dist = Float()
dir = Integer()
# 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,
prst=None,
dist=None,
dir=None,
**kw
):
self.prst = prst
self.dist = dist
self.dir = dir
super(PresetShadowEffect, self).__init__(**kw)
class SoftEdgesEffect(Serialisable):
rad = Float()
def __init__(self,
rad=None,
):
self.rad = rad
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(RowDimension, self).__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 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 Pane(Serialisable):
xSplit = Float(allow_none=True)
ySplit = Float(allow_none=True)
topLeftCell = String(allow_none=True)
activePane = Set(values=("bottomRight", "topRight", "bottomLeft", "topLeft"))
state = Set(values=("split", "frozen", "frozenSplit"))
def __init__(self,
xSplit=None,
ySplit=None,
topLeftCell=None,
activePane="topLeft",
state="split"):
self.xSplit = xSplit
self.ySplit = ySplit
self.topLeftCell = topLeftCell
self.activePane = activePane
self.state = state
class GradientFill(Fill):
spec = """18.8.24"""
__fields__ = ('fill_type', 'degree', 'left', 'right', 'top', 'bottom',
'stop')
fill_type = Set(values=('linear', 'path'))
type = Alias("fill_type")
degree = Float()
left = Float()
right = Float()
top = Float()
bottom = Float()
stop = Sequence(expected_type=Color)
def __init__(self,
fill_type="linear",
degree=0,
left=0,
right=0,
top=0,
bottom=0,
stop=(),
type=None):
self.degree = degree
self.left = left
self.right = right
self.top = top
self.bottom = bottom
self.stop = stop
# cannot use type attribute but allow it is an argument (ie. when parsing)
if type is not None:
fill_type = type
self.fill_type = fill_type
def __iter__(self):
"""
Dictionary interface for easier serialising.
All values converted to strings
"""
for key in ('type', 'degree', 'left', 'right', 'top', 'bottom'):
value = getattr(self, key)
if bool(value):
yield key, safe_string(value)
class ColumnDimension(Dimension):
"""Information about the display properties of a column."""
width = Float(allow_none=True)
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,
index='A',
width=None,
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,
worksheet=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(ColumnDimension, self).__init__(index, hidden, outlineLevel,
collapsed, worksheet, style=style)
@property
def customWidth(self):
"""Always true if there is a width for the column"""
return self.width is not None
def __iter__(self):
for key in self.__fields__[1:]:
if key == 'style':
value = getattr(self, '_style')
else:
value = getattr(self, key)
if value:
yield key, safe_string(value)
class Top10(Serialisable):
tagname = "top10"
top = Bool(allow_none=True)
percent = Bool(allow_none=True)
val = Float()
filterVal = Float(allow_none=True)
def __init__(self,
top=None,
percent=None,
val=None,
filterVal=None,
):
self.top = top
self.percent = percent
self.val = val
self.filterVal = filterVal
class Path2D(Serialisable):
w = Float()
h = Float()
fill = NoneSet(values=(['norm', 'lighten', 'lightenLess', 'darken', 'darkenLess']))
stroke = Bool(allow_none=True)
extrusionOk = Bool(allow_none=True)
def __init__(self,
w=None,
h=None,
fill=None,
stroke=None,
extrusionOk=None,
):
self.w = w
self.h = h
self.fill = fill
self.stroke = stroke
self.extrusionOk = extrusionOk
class BlurEffect(Serialisable):
rad = Float()
grow = Bool(allow_none=True)
def __init__(self,
rad=None,
grow=None,
):
self.rad = rad
self.grow = grow
class PageMargins(Serialisable):
"""
Information about page margins for view/print layouts.
Standard values (in inches)
left, right = 0.75
top, bottom = 1
header, footer = 0.5
"""
tagname = "pageMargins"
left = Float()
right = Float()
top = Float()
bottom = Float()
header = Float()
footer = Float()
def __init__(self, left=0.75, right=0.75, top=1, bottom=1, header=0.5,
footer=0.5):
self.left = left
self.right = right
self.top = top
self.bottom = bottom
self.header = header
self.footer = footer
class PageMargins(Strict):
"""
Information about page margins for view/print layouts.
Standard values (in inches)
left, right = 0.75
top, bottom = 1
header, footer = 0.5
"""
left = Float()
right = Float()
top = Float()
bottom = Float()
header = Float()
footer = Float()
def __init__(self, left=0.75, right=0.75, top=1, bottom=1, header=0.5, footer=0.5):
self.left = left
self.right = right
self.top = top
self.bottom = bottom
self.header = header
self.footer = footer
def __iter__(self):
for key in ("left", "right", "top", "bottom", "header", "footer"):
value = getattr(self, key)
yield key, safe_string(value)
class Number(Serialisable):
tagname = "n"
tpls = Sequence(expected_type=TupleList)
x = Sequence(expected_type=Index)
v = Float()
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 Number(Serialisable):
v = Float()
u = Bool()
f = Bool()
c = String()
cp = Integer()
_in = Integer(allow_none=True)
bc = hexBinary()
fc = hexBinary()
i = Bool(allow_none=True)
un = Bool(allow_none=True)
st = Bool(allow_none=True)
b = Bool(allow_none=True)
tpls = Typed(expected_type=Tuples, allow_none=True)
x = Typed(expected_type=X, allow_none=True)
__elements__ = ('tpls', 'x')
def __init__(
self,
v=None,
u=None,
f=None,
c=None,
cp=None,
_in=None,
bc=None,
fc=None,
i=None,
un=None,
st=None,
b=None,
tpls=None,
x=None,
):
self.v = v
self.u = u
self.f = f
self.c = c
self.cp = cp
self.bc = bc
self.fc = fc
self.i = i
self.un = un
self.st = st
self.b = b
self.tpls = tpls
self.x = x
self._in = _in
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 GlowEffect(ColorChoice):
rad = Float()
# 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, rad=None, **kw):
self.rad = rad
super(GlowEffect, self).__init__(**kw)
class CustomFilter(Serialisable):
tagname = "customFilter"
operator = NoneSet(values=([
'equal', 'lessThan', 'lessThanOrEqual', 'notEqual',
'greaterThanOrEqual', 'greaterThan'
]))
val = Float()
def __init__(
self,
operator=None,
val=None,
):
self.operator = operator
self.val = val
class PageMargins(Serialisable):
"""
Identical to openpyxl.worksheet.page.Pagemargins but element names are different :-/
"""
tagname = "pageMargins"
l = Float()
left = Alias('l')
r = Float()
right = Alias('r')
t = Float()
top = Alias('t')
b = Float()
bottom = Alias('b')
header = Float()
footer = Float()
def __init__(self, l=0.75, r=0.75, t=1, b=1, header=0.5, footer=0.5):
self.l = l
self.r = r
self.t = t
self.b = b
self.header = header
self.footer = footer
class SharedItems(Serialisable):
tagname = "sharedItems"
_fields = MultiSequence()
m = MultiSequencePart(expected_type=Missing, store="_fields")
n = MultiSequencePart(expected_type=Number, store="_fields")
b = MultiSequencePart(expected_type=Boolean, store="_fields")
e = MultiSequencePart(expected_type=Error, store="_fields")
s = MultiSequencePart(expected_type=Text, store="_fields")
d = MultiSequencePart(expected_type=DateTimeField, store="_fields")
# attributes are optional and must be derived from associated cache records
containsSemiMixedTypes = Bool(allow_none=True)
containsNonDate = Bool(allow_none=True)
containsDate = Bool(allow_none=True)
containsString = Bool(allow_none=True)
containsBlank = Bool(allow_none=True)
containsMixedTypes = Bool(allow_none=True)
containsNumber = Bool(allow_none=True)
containsInteger = Bool(allow_none=True)
minValue = Float(allow_none=True)
maxValue = Float(allow_none=True)
minDate = DateTime(allow_none=True)
maxDate = DateTime(allow_none=True)
longText = Bool(allow_none=True)
__attrs__ = ('count', 'containsBlank', 'containsDate', 'containsInteger',
'containsMixedTypes', 'containsNonDate', 'containsNumber',
'containsSemiMixedTypes', 'containsString', 'minValue',
'maxValue', 'minDate', 'maxDate', 'longText')
def __init__(
self,
_fields=(),
containsSemiMixedTypes=None,
containsNonDate=None,
containsDate=None,
containsString=None,
containsBlank=None,
containsMixedTypes=None,
containsNumber=None,
containsInteger=None,
minValue=None,
maxValue=None,
minDate=None,
maxDate=None,
count=None,
longText=None,
):
self._fields = _fields
self.containsBlank = containsBlank
self.containsDate = containsDate
self.containsNonDate = containsNonDate
self.containsString = containsString
self.containsMixedTypes = containsMixedTypes
self.containsSemiMixedTypes = containsSemiMixedTypes
self.containsNumber = containsNumber
self.containsInteger = containsInteger
self.minValue = minValue
self.maxValue = maxValue
self.minDate = minDate
self.maxDate = maxDate
self.longText = longText
@property
def count(self):
return len(self._fields)
class CacheDefinition(Serialisable):
mime_type = "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml"
rel_type = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheDefinition"
_id = 1
_path = "/xl/pivotCache/pivotCacheDefinition{0}.xml"
records = None
tagname = "pivotCacheDefinition"
invalid = Bool(allow_none=True)
saveData = Bool(allow_none=True)
refreshOnLoad = Bool(allow_none=True)
optimizeMemory = Bool(allow_none=True)
enableRefresh = Bool(allow_none=True)
refreshedBy = String(allow_none=True)
refreshedDate = Float(allow_none=True)
refreshedDateIso = DateTime(allow_none=True)
backgroundQuery = Bool(allow_none=True)
missingItemsLimit = Integer(allow_none=True)
createdVersion = Integer(allow_none=True)
refreshedVersion = Integer(allow_none=True)
minRefreshableVersion = Integer(allow_none=True)
recordCount = Integer(allow_none=True)
upgradeOnRefresh = Bool(allow_none=True)
tupleCache = Bool(allow_none=True)
supportSubquery = Bool(allow_none=True)
supportAdvancedDrill = Bool(allow_none=True)
cacheSource = Typed(expected_type=CacheSource)
cacheFields = NestedSequence(expected_type=CacheField, count=True)
cacheHierarchies = NestedSequence(expected_type=CacheHierarchy,
allow_none=True)
kpis = NestedSequence(expected_type=PCDKPI, allow_none=True)
tupleCache = Typed(expected_type=TupleCache, allow_none=True)
calculatedItems = NestedSequence(expected_type=CalculatedItem, count=True)
calculatedMembers = NestedSequence(expected_type=CalculatedMember,
count=True)
dimensions = NestedSequence(expected_type=PivotDimension, allow_none=True)
measureGroups = NestedSequence(expected_type=MeasureGroup, count=True)
maps = NestedSequence(expected_type=MeasureDimensionMap, count=True)
extLst = Typed(expected_type=ExtensionList, allow_none=True)
id = Relation()
__elements__ = (
'cacheSource',
'cacheFields',
'cacheHierarchies',
'kpis',
'tupleCache',
'calculatedItems',
'calculatedMembers',
'dimensions',
'measureGroups',
'maps',
)
def __init__(
self,
invalid=None,
saveData=None,
refreshOnLoad=None,
optimizeMemory=None,
enableRefresh=None,
refreshedBy=None,
refreshedDate=None,
refreshedDateIso=None,
backgroundQuery=None,
missingItemsLimit=None,
createdVersion=None,
refreshedVersion=None,
minRefreshableVersion=None,
recordCount=None,
upgradeOnRefresh=None,
tupleCache=None,
supportSubquery=None,
supportAdvancedDrill=None,
cacheSource=None,
cacheFields=(),
cacheHierarchies=(),
kpis=(),
calculatedItems=(),
calculatedMembers=(),
dimensions=(),
measureGroups=(),
maps=(),
extLst=None,
id=None,
):
self.invalid = invalid
self.saveData = saveData
self.refreshOnLoad = refreshOnLoad
self.optimizeMemory = optimizeMemory
self.enableRefresh = enableRefresh
self.refreshedBy = refreshedBy
self.refreshedDate = refreshedDate
self.refreshedDateIso = refreshedDateIso
self.backgroundQuery = backgroundQuery
self.missingItemsLimit = missingItemsLimit
self.createdVersion = createdVersion
self.refreshedVersion = refreshedVersion
self.minRefreshableVersion = minRefreshableVersion
self.recordCount = recordCount
self.upgradeOnRefresh = upgradeOnRefresh
self.tupleCache = tupleCache
self.supportSubquery = supportSubquery
self.supportAdvancedDrill = supportAdvancedDrill
self.cacheSource = cacheSource
self.cacheFields = cacheFields
self.cacheHierarchies = cacheHierarchies
self.kpis = kpis
self.tupleCache = tupleCache
self.calculatedItems = calculatedItems
self.calculatedMembers = calculatedMembers
self.dimensions = dimensions
self.measureGroups = measureGroups
self.maps = maps
self.id = id
def to_tree(self):
node = super(CacheDefinition, self).to_tree()
node.set("xmlns", SHEET_MAIN_NS)
return node
@property
def path(self):
return self._path.format(self._id)
def _write(self, archive, manifest):
"""
Add to zipfile and update manifest
"""
self._write_rels(archive, manifest)
xml = tostring(self.to_tree())
archive.writestr(self.path[1:], xml)
manifest.append(self)
def _write_rels(self, archive, manifest):
"""
Write the relevant child objects and add links
"""
if self.records is None:
return
rels = RelationshipList()
r = Relationship(Type=self.records.rel_type, Target=self.records.path)
rels.append(r)
self.id = r.id
self.records._id = self._id
self.records._write(archive, manifest)
path = get_rels_path(self.path)
xml = tostring(rels.to_tree())
archive.writestr(path[1:], xml)
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(ColumnDimension, self).__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)
def to_tree(self):
attrs = dict(self)
if attrs.keys() != {'min', 'max'}:
return Element("col", **attrs)
