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)