class SortState(Serialisable):
tagname = "sortState"
columnSort = Bool(allow_none=True)
caseSensitive = Bool(allow_none=True)
sortMethod = NoneSet(values=(['stroke', 'pinYin']))
ref = CellRange()
sortCondition = Sequence(expected_type=SortCondition, allow_none=True)
extLst = Typed(expected_type=ExtensionList, allow_none=True)
__elements__ = ('sortCondition', )
def __init__(
self,
columnSort=None,
caseSensitive=None,
sortMethod=None,
ref=None,
sortCondition=(),
extLst=None,
):
self.columnSort = columnSort
self.caseSensitive = caseSensitive
self.sortMethod = sortMethod
self.ref = ref
self.sortCondition = sortCondition
def __bool__(self):
return self.ref is not None
__nonzero__ = __bool__
class GroupLevel(Serialisable):
tagname = "groupLevel"
uniqueName = String()
caption = String()
user = Bool()
customRollUp = Bool()
groups = Typed(expected_type=Groups, allow_none=True)
extLst = Typed(expected_type=ExtensionList, allow_none=True)
__elements__ = ('groups', 'extLst')
def __init__(
self,
uniqueName=None,
caption=None,
user=None,
customRollUp=None,
groups=None,
extLst=None,
):
self.uniqueName = uniqueName
self.caption = caption
self.user = user
self.customRollUp = customRollUp
self.groups = groups
self.extLst = extLst
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 ChartsheetProtection(Serialisable, _Protected):
tagname = "sheetProtection"
algorithmName = String(allow_none=True)
hashValue = Base64Binary(allow_none=True)
saltValue = Base64Binary(allow_none=True)
spinCount = Integer(allow_none=True)
content = Bool(allow_none=True)
objects = Bool(allow_none=True)
__attrs__ = ("content", "objects", "password", "hashValue", "spinCount",
"saltValue", "algorithmName")
def __init__(
self,
content=None,
objects=None,
hashValue=None,
spinCount=None,
saltValue=None,
algorithmName=None,
password=None,
):
self.content = content
self.objects = objects
self.hashValue = hashValue
self.spinCount = spinCount
self.saltValue = saltValue
self.algorithmName = algorithmName
if password is not None:
self.password = password
class Shape(Serialisable):
macro = String(allow_none=True)
textlink = String(allow_none=True)
fPublished = Bool(allow_none=True)
fLocksText = Bool(allow_none=True)
nvSpPr = Typed(expected_type=ShapeMeta, allow_none=True)
meta = Alias("nvSpPr")
spPr = Typed(expected_type=GraphicalProperties)
graphicalProperties = Alias("spPr")
style = Typed(expected_type=ShapeStyle, allow_none=True)
txBody = Typed(expected_type=RichText, allow_none=True)
def __init__(self,
macro=None,
textlink=None,
fPublished=None,
fLocksText=None,
nvSpPr=None,
spPr=None,
style=None,
txBody=None,
):
self.macro = macro
self.textlink = textlink
self.fPublished = fPublished
self.fLocksText = fLocksText
self.nvSpPr = nvSpPr
self.spPr = spPr
self.style = style
self.txBody = txBody
class MemberProperty(Serialisable):
tagname = "mps"
name = String(allow_none=True)
showCell = Bool(allow_none=True)
showTip = Bool(allow_none=True)
showAsCaption = Bool(allow_none=True)
nameLen = Integer(allow_none=True)
pPos = Integer(allow_none=True)
pLen = Integer(allow_none=True)
level = Integer(allow_none=True)
field = Integer()
def __init__(
self,
name=None,
showCell=None,
showTip=None,
showAsCaption=None,
nameLen=None,
pPos=None,
pLen=None,
level=None,
field=None,
):
self.name = name
self.showCell = showCell
self.showTip = showTip
self.showAsCaption = showAsCaption
self.nameLen = nameLen
self.pPos = pPos
self.pLen = pLen
self.level = level
self.field = field
class Border(Serialisable):
"""Border positioning for use in styles."""
tagname = "border"
__fields__ = ('left', 'right', 'top', 'bottom', 'diagonal',
'diagonal_direction', 'vertical', 'horizontal')
__elements__ = ('start', 'end', 'left', 'right', 'top', 'bottom',
'diagonal', 'vertical', 'horizontal')
# child elements
start = Typed(expected_type=Side, allow_none=True)
end = Typed(expected_type=Side, allow_none=True)
left = Typed(expected_type=Side, allow_none=True)
right = Typed(expected_type=Side, allow_none=True)
top = Typed(expected_type=Side, allow_none=True)
bottom = Typed(expected_type=Side)
diagonal = Typed(expected_type=Side, allow_none=True)
vertical = Typed(expected_type=Side, allow_none=True)
horizontal = Typed(expected_type=Side, allow_none=True)
# attributes
outline = Bool()
diagonalUp = Bool()
diagonalDown = Bool()
def __init__(self,
left=Side(),
right=Side(),
top=Side(),
bottom=Side(),
diagonal=Side(),
diagonal_direction=None,
vertical=None,
horizontal=None,
diagonalUp=False,
diagonalDown=False,
outline=True,
start=None,
end=None):
self.left = left
self.right = right
self.top = top
self.bottom = bottom
self.diagonal = diagonal
self.vertical = vertical
self.horizontal = horizontal
self.diagonal_direction = diagonal_direction
self.diagonalUp = diagonalUp
self.diagonalDown = diagonalDown
self.outline = outline
self.start = start
self.end = end
def __iter__(self):
for attr in self.__attrs__:
value = getattr(self, attr)
if value and attr != "outline":
yield attr, safe_string(value)
elif attr == "outline" and not value:
yield attr, safe_string(value)
class PivotTableStyle(Serialisable):
tagname = "pivotTableStyleInfo"
name = String(allow_none=True)
showRowHeaders = Bool()
showColHeaders = Bool()
showRowStripes = Bool()
showColStripes = Bool()
showLastColumn = Bool()
def __init__(
self,
name=None,
showRowHeaders=None,
showColHeaders=None,
showRowStripes=None,
showColStripes=None,
showLastColumn=None,
):
self.name = name
self.showRowHeaders = showRowHeaders
self.showColHeaders = showColHeaders
self.showRowStripes = showRowStripes
self.showColStripes = showColStripes
self.showLastColumn = showLastColumn
class DateTimeField(Serialisable):
tagname = "d"
x = Sequence(expected_type=Index)
v = DateTime()
u = Bool(allow_none=True)
f = Bool(allow_none=True)
c = String(allow_none=True)
cp = Integer(allow_none=True)
__elements__ = ('x', )
def __init__(
self,
x=(),
v=None,
u=None,
f=None,
c=None,
cp=None,
):
self.x = x
self.v = v
self.u = u
self.f = f
self.c = c
self.cp = cp
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 Transform2D(Serialisable):
tagname = "xfrm"
namespace = DRAWING_NS
rot = Integer(allow_none=True)
flipH = Bool(allow_none=True)
flipV = Bool(allow_none=True)
off = Typed(expected_type=Point2D, allow_none=True)
ext = Typed(expected_type=PositiveSize2D, allow_none=True)
chOff = Typed(expected_type=Point2D, allow_none=True)
chExt = Typed(expected_type=PositiveSize2D, allow_none=True)
__elements__ = ('off', 'ext', 'chOff', 'chExt')
def __init__(
self,
rot=None,
flipH=None,
flipV=None,
off=None,
ext=None,
chOff=None,
chExt=None,
):
self.rot = rot
self.flipH = flipH
self.flipV = flipV
self.off = off
self.ext = ext
self.chOff = chOff
self.chExt = chExt
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 Alignment(Serialisable):
"""Alignment options for use in styles."""
tagname = "alignment"
__fields__ = ('horizontal',
'vertical',
'textRotation',
'wrapText',
'shrinkToFit',
'indent',
'relativeIndent',
'justifyLastLine',
'readingOrder',
)
horizontal = NoneSet(values=horizontal_alignments)
vertical = NoneSet(values=vertical_aligments)
textRotation = NoneSet(values=range(181))
textRotation.values.add(255)
text_rotation = Alias('textRotation')
wrapText = Bool(allow_none=True)
wrap_text = Alias('wrapText')
shrinkToFit = Bool(allow_none=True)
shrink_to_fit = Alias('shrinkToFit')
indent = Min(min=0)
relativeIndent = Min(min=0)
justifyLastLine = Bool(allow_none=True)
readingOrder = Min(min=0)
def __init__(self, horizontal=None, vertical=None,
textRotation=0, wrapText=None, shrinkToFit=None, indent=0, relativeIndent=0,
justifyLastLine=None, readingOrder=0, text_rotation=None,
wrap_text=None, shrink_to_fit=None, mergeCell=None):
self.horizontal = horizontal
self.vertical = vertical
self.indent = indent
self.relativeIndent = relativeIndent
self.justifyLastLine = justifyLastLine
self.readingOrder = readingOrder
if text_rotation is not None:
textRotation = text_rotation
if textRotation is not None:
self.textRotation = int(textRotation)
if wrap_text is not None:
wrapText = wrap_text
self.wrapText = wrapText
if shrink_to_fit is not None:
shrinkToFit = shrink_to_fit
self.shrinkToFit = shrinkToFit
# mergeCell is vestigial
def __iter__(self):
for attr in self.__attrs__:
value = getattr(self, attr)
if value is not None and value != 0:
yield attr, safe_string(value)
class PageSetupProperties(Serialisable):
tagname = "pageSetUpPr"
autoPageBreaks = Bool(allow_none=True)
fitToPage = Bool(allow_none=True)
def __init__(self, autoPageBreaks=None, fitToPage=None):
self.autoPageBreaks = autoPageBreaks
self.fitToPage = fitToPage
class PivotHierarchy(Serialisable):
tagname = "pivotHierarchy"
outline = Bool()
multipleItemSelectionAllowed = Bool()
subtotalTop = Bool()
showInFieldList = Bool()
dragToRow = Bool()
dragToCol = Bool()
dragToPage = Bool()
dragToData = Bool()
dragOff = Bool()
includeNewItemsInFilter = Bool()
caption = String(allow_none=True)
mps = NestedSequence(expected_type=MemberProperty, count=True)
members = Typed(expected_type=MemberList, allow_none=True)
extLst = Typed(expected_type=ExtensionList, allow_none=True)
__elements__ = (
'mps',
'members',
)
def __init__(
self,
outline=None,
multipleItemSelectionAllowed=None,
subtotalTop=None,
showInFieldList=None,
dragToRow=None,
dragToCol=None,
dragToPage=None,
dragToData=None,
dragOff=None,
includeNewItemsInFilter=None,
caption=None,
mps=(),
members=None,
extLst=None,
):
self.outline = outline
self.multipleItemSelectionAllowed = multipleItemSelectionAllowed
self.subtotalTop = subtotalTop
self.showInFieldList = showInFieldList
self.dragToRow = dragToRow
self.dragToCol = dragToCol
self.dragToPage = dragToPage
self.dragToData = dragToData
self.dragOff = dragOff
self.includeNewItemsInFilter = includeNewItemsInFilter
self.caption = caption
self.mps = mps
self.members = members
self.extLst = extLst
class Protection(Serialisable):
"""Protection options for use in styles."""
tagname = "protection"
locked = Bool()
hidden = Bool()
def __init__(self, locked=True, hidden=False):
self.locked = locked
self.hidden = hidden
class AnchorClientData(Serialisable):
fLocksWithSheet = Bool(allow_none=True)
fPrintsWithSheet = Bool(allow_none=True)
def __init__(self,
fLocksWithSheet=None,
fPrintsWithSheet=None,
):
self.fLocksWithSheet = fLocksWithSheet
self.fPrintsWithSheet = fPrintsWithSheet
class BookView(Serialisable):
tagname = "workbookView"
visibility = NoneSet(values=(['visible', 'hidden', 'veryHidden']))
minimized = Bool(allow_none=True)
showHorizontalScroll = Bool(allow_none=True)
showVerticalScroll = Bool(allow_none=True)
showSheetTabs = Bool(allow_none=True)
xWindow = Integer(allow_none=True)
yWindow = Integer(allow_none=True)
windowWidth = Integer(allow_none=True)
windowHeight = Integer(allow_none=True)
tabRatio = Integer(allow_none=True)
firstSheet = Integer(allow_none=True)
activeTab = Integer(allow_none=True)
autoFilterDateGrouping = Bool(allow_none=True)
extLst = Typed(expected_type=ExtensionList, allow_none=True)
__elements__ = ()
def __init__(
self,
visibility="visible",
minimized=False,
showHorizontalScroll=True,
showVerticalScroll=True,
showSheetTabs=True,
xWindow=None,
yWindow=None,
windowWidth=None,
windowHeight=None,
tabRatio=600,
firstSheet=0,
activeTab=0,
autoFilterDateGrouping=True,
extLst=None,
):
self.visibility = visibility
self.minimized = minimized
self.showHorizontalScroll = showHorizontalScroll
self.showVerticalScroll = showVerticalScroll
self.showSheetTabs = showSheetTabs
self.xWindow = xWindow
self.yWindow = yWindow
self.windowWidth = windowWidth
self.windowHeight = windowHeight
self.tabRatio = tabRatio
self.firstSheet = firstSheet
self.activeTab = activeTab
self.autoFilterDateGrouping = autoFilterDateGrouping
class FilterColumn(Serialisable):
tagname = "filterColumn"
colId = Integer()
col_id = Alias('colId')
hiddenButton = Bool(allow_none=True)
showButton = Bool(allow_none=True)
# some elements are choice
filters = Typed(expected_type=Filters, allow_none=True)
top10 = Typed(expected_type=Top10, allow_none=True)
customFilters = Typed(expected_type=CustomFilters, allow_none=True)
dynamicFilter = Typed(expected_type=DynamicFilter, allow_none=True)
colorFilter = Typed(expected_type=ColorFilter, allow_none=True)
iconFilter = Typed(expected_type=IconFilter, allow_none=True)
extLst = Typed(expected_type=ExtensionList, allow_none=True)
__elements__ = ('filters', 'top10', 'customFilters', 'dynamicFilter',
'colorFilter', 'iconFilter')
def __init__(
self,
colId=None,
hiddenButton=None,
showButton=None,
filters=None,
top10=None,
customFilters=None,
dynamicFilter=None,
colorFilter=None,
iconFilter=None,
extLst=None,
blank=None,
vals=None,
):
self.colId = colId
self.hiddenButton = hiddenButton
self.showButton = showButton
self.filters = filters
self.top10 = top10
self.customFilters = customFilters
self.dynamicFilter = dynamicFilter
self.colorFilter = colorFilter
self.iconFilter = iconFilter
if blank is not None and self.filters:
self.filters.blank = blank
if vals is not None and self.filters:
self.filters.filter = vals
class PictureFrame(Serialisable):
tagname = "pic"
macro = String(allow_none=True)
fPublished = Bool(allow_none=True)
nvPicPr = Typed(expected_type=PictureNonVisual, )
blipFill = Typed(expected_type=BlipFillProperties, )
spPr = Typed(expected_type=GraphicalProperties, )
graphicalProperties = Alias('spPr')
style = Typed(expected_type=ShapeStyle, allow_none=True)
__elements__ = ("nvPicPr", "blipFill", "spPr", "style")
def __init__(
self,
macro=None,
fPublished=None,
nvPicPr=None,
blipFill=None,
spPr=None,
style=None,
):
self.macro = macro
self.fPublished = fPublished
if nvPicPr is None:
nvPicPr = PictureNonVisual()
self.nvPicPr = nvPicPr
if blipFill is None:
blipFill = BlipFillProperties()
self.blipFill = blipFill
if spPr is None:
spPr = GraphicalProperties()
self.spPr = spPr
self.style = style
class FileSharing(Serialisable):
tagname = "fileSharing"
readOnlyRecommended = Bool(allow_none=True)
userName = String(allow_none=True)
reservationPassword = HexBinary(allow_none=True)
algorithmName = String(allow_none=True)
hashValue = HexBinary(allow_none=True)
saltValue = HexBinary(allow_none=True)
spinCount = Integer(allow_none=True)
def __init__(
self,
readOnlyRecommended=None,
userName=None,
reservationPassword=None,
algorithmName=None,
hashValue=None,
saltValue=None,
spinCount=None,
):
self.readOnlyRecommended = readOnlyRecommended
self.userName = userName
self.reservationPassword = reservationPassword
self.algorithmName = algorithmName
self.hashValue = hashValue
self.saltValue = saltValue
self.spinCount = spinCount
class WebPublishObject(Serialisable):
tagname = "webPublishingObject"
id = Integer()
divId = String()
sourceObject = String(allow_none=True)
destinationFile = String()
title = String(allow_none=True)
autoRepublish = Bool(allow_none=True)
def __init__(self,
id=None,
divId=None,
sourceObject=None,
destinationFile=None,
title=None,
autoRepublish=None,
):
self.id = id
self.divId = divId
self.sourceObject = sourceObject
self.destinationFile = destinationFile
self.title = title
self.autoRepublish = autoRepublish
class GraphicFrame(Serialisable):
tagname = "graphicFrame"
nvGraphicFramePr = Typed(expected_type=NonVisualGraphicFrame)
xfrm = Typed(expected_type=XDRTransform2D)
graphic = Typed(expected_type=GraphicObject)
macro = String(allow_none=True)
fPublished = Bool(allow_none=True)
__elements__ = ('nvGraphicFramePr', 'xfrm', 'graphic', 'macro',
'fPublished')
def __init__(
self,
nvGraphicFramePr=None,
xfrm=None,
graphic=None,
macro=None,
fPublished=None,
):
if nvGraphicFramePr is None:
nvGraphicFramePr = NonVisualGraphicFrame()
self.nvGraphicFramePr = nvGraphicFramePr
if xfrm is None:
xfrm = XDRTransform2D()
self.xfrm = xfrm
if graphic is None:
graphic = GraphicObject()
self.graphic = graphic
self.macro = macro
self.fPublished = fPublished
class WebPublishItem(Serialisable):
tagname = "webPublishItem"
id = Integer()
divId = String()
sourceType = Set(values=([
'sheet', 'printArea', 'autoFilter', 'range', 'chart', 'pivotTable',
'query', 'label'
]))
sourceRef = String()
sourceObject = String(allow_none=True)
destinationFile = String()
title = String(allow_none=True)
autoRepublish = Bool(allow_none=True)
def __init__(
self,
id=None,
divId=None,
sourceType=None,
sourceRef=None,
sourceObject=None,
destinationFile=None,
title=None,
autoRepublish=None,
):
self.id = id
self.divId = divId
self.sourceType = sourceType
self.sourceRef = sourceRef
self.sourceObject = sourceObject
self.destinationFile = destinationFile
self.title = title
self.autoRepublish = autoRepublish
class CalculatedMember(Serialisable):
tagname = "calculatedMember"
name = String()
mdx = String()
memberName = String()
hierarchy = String()
parent = String()
solveOrder = Integer()
set = Bool()
extLst = Typed(expected_type=ExtensionList, allow_none=True)
__elements__ = ('extLst', )
def __init__(
self,
name=None,
mdx=None,
memberName=None,
hierarchy=None,
parent=None,
solveOrder=None,
set=None,
extLst=None,
):
self.name = name
self.mdx = mdx
self.memberName = memberName
self.hierarchy = hierarchy
self.parent = parent
self.solveOrder = solveOrder
self.set = set
self.extLst = extLst
class OLAPSet(Serialisable):
tagname = "set"
count = Integer()
maxRank = Integer()
setDefinition = String()
sortType = NoneSet(values=([
'ascending', 'descending', 'ascendingAlpha', 'descendingAlpha',
'ascendingNatural', 'descendingNatural'
]))
queryFailed = Bool()
tpls = Typed(expected_type=TupleList, allow_none=True)
sortByTuple = Typed(expected_type=TupleList, allow_none=True)
__elements__ = ('tpls', 'sortByTuple')
def __init__(
self,
count=None,
maxRank=None,
setDefinition=None,
sortType=None,
queryFailed=None,
tpls=None,
sortByTuple=None,
):
self.count = count
self.maxRank = maxRank
self.setDefinition = setDefinition
self.sortType = sortType
self.queryFailed = queryFailed
self.tpls = tpls
self.sortByTuple = sortByTuple
class NonVisualDrawingProps(Serialisable):
tagname = "cNvPr"
id = Integer()
name = String()
descr = String(allow_none=True)
hidden = Bool(allow_none=True)
title = String(allow_none=True)
hlinkClick = Typed(expected_type=Hyperlink, allow_none=True)
hlinkHover = Typed(expected_type=Hyperlink, allow_none=True)
extLst = Typed(expected_type=OfficeArtExtensionList, allow_none=True)
__elements__ = ["hlinkClick", "hlinkHover"]
def __init__(
self,
id=None,
name=None,
descr=None,
hidden=None,
title=None,
hlinkClick=None,
hlinkHover=None,
extLst=None,
):
self.id = id
self.name = name
self.descr = descr
self.hidden = hidden
self.title = title
self.hlinkClick = hlinkClick
self.hlinkHover = hlinkHover
self.extLst = extLst
class SortCondition(Serialisable):
tagname = "sortCondition"
descending = Bool(allow_none=True)
sortBy = NoneSet(values=(['value', 'cellColor', 'fontColor', 'icon']))
ref = CellRange()
customList = String(allow_none=True)
dxfId = Integer(allow_none=True)
iconSet = NoneSet(values=([
'3Arrows', '3ArrowsGray', '3Flags', '3TrafficLights1',
'3TrafficLights2', '3Signs', '3Symbols', '3Symbols2', '4Arrows',
'4ArrowsGray', '4RedToBlack', '4Rating', '4TrafficLights', '5Arrows',
'5ArrowsGray', '5Rating', '5Quarters'
]))
iconId = Integer(allow_none=True)
def __init__(
self,
ref=None,
descending=None,
sortBy=None,
customList=None,
dxfId=None,
iconSet=None,
iconId=None,
):
self.descending = descending
self.sortBy = sortBy
self.ref = ref
self.customList = customList
self.dxfId = dxfId
self.iconSet = iconSet
self.iconId = iconId
class Filters(Serialisable):
tagname = "filters"
blank = Bool(allow_none=True)
calendarType = NoneSet(values=[
"gregorian", "gregorianUs", "gregorianMeFrench", "gregorianArabic",
"hijri", "hebrew", "taiwan", "japan", "thai", "korea", "saka",
"gregorianXlitEnglish", "gregorianXlitFrench"
])
filter = ValueSequence(expected_type=unicode)
dateGroupItem = Sequence(expected_type=DateGroupItem, allow_none=True)
__elements__ = ('filter', 'dateGroupItem')
def __init__(
self,
blank=None,
calendarType=None,
filter=(),
dateGroupItem=(),
):
self.blank = blank
self.calendarType = calendarType
self.filter = filter
self.dateGroupItem = dateGroupItem
class CustomChartsheetView(Serialisable):
tagname = "customSheetView"
guid = Guid()
scale = Integer()
state = Set(values=(['visible', 'hidden', 'veryHidden']))
zoomToFit = Bool(allow_none=True)
pageMargins = Typed(expected_type=PageMargins, allow_none=True)
pageSetup = Typed(expected_type=PrintPageSetup, allow_none=True)
headerFooter = Typed(expected_type=HeaderFooter, allow_none=True)
__elements__ = ('pageMargins', 'pageSetup', 'headerFooter')
def __init__(
self,
guid=None,
scale=None,
state='visible',
zoomToFit=None,
pageMargins=None,
pageSetup=None,
headerFooter=None,
):
self.guid = guid
self.scale = scale
self.state = state
self.zoomToFit = zoomToFit
self.pageMargins = pageMargins
self.pageSetup = pageSetup
self.headerFooter = headerFooter
