Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.8/site-packages/openpyxl/pivot/cache.py: 60%

1# Copyright (c) 2010-2024 openpyxl 

2 

3from openpyxl.descriptors.serialisable import Serialisable 

4from openpyxl.descriptors import ( 

5 Typed, 

6 Bool, 

7 Float, 

8 Set, 

9 NoneSet, 

10 String, 

11 Integer, 

12 DateTime, 

13 Sequence, 

14) 

15 

16from openpyxl.descriptors.excel import ( 

17 HexBinary, 

18 ExtensionList, 

19 Relation, 

20) 

21from openpyxl.descriptors.nested import NestedInteger 

22from openpyxl.descriptors.sequence import ( 

23 NestedSequence, 

24 MultiSequence, 

25 MultiSequencePart, 

26) 

27from openpyxl.xml.constants import SHEET_MAIN_NS 

28from openpyxl.xml.functions import tostring 

29from openpyxl.packaging.relationship import ( 

30 RelationshipList, 

31 Relationship, 

32 get_rels_path 

33) 

34 

35from .table import ( 

36 PivotArea, 

37 Reference, 

38) 

39from .fields import ( 

40 Boolean, 

41 Error, 

42 Missing, 

43 Number, 

44 Text, 

45 TupleList, 

46 DateTimeField, 

47) 

48 

49class MeasureDimensionMap(Serialisable): 

50 

51 tagname = "map" 

52 

53 measureGroup = Integer(allow_none=True) 

54 dimension = Integer(allow_none=True) 

55 

56 def __init__(self, 

57 measureGroup=None, 

58 dimension=None, 

59 ): 

60 self.measureGroup = measureGroup 

61 self.dimension = dimension 

62 

63 

64class MeasureGroup(Serialisable): 

65 

66 tagname = "measureGroup" 

67 

68 name = String() 

69 caption = String() 

70 

71 def __init__(self, 

72 name=None, 

73 caption=None, 

74 ): 

75 self.name = name 

76 self.caption = caption 

77 

78 

79class PivotDimension(Serialisable): 

80 

81 tagname = "dimension" 

82 

83 measure = Bool() 

84 name = String() 

85 uniqueName = String() 

86 caption = String() 

87 

88 def __init__(self, 

89 measure=None, 

90 name=None, 

91 uniqueName=None, 

92 caption=None, 

93 ): 

94 self.measure = measure 

95 self.name = name 

96 self.uniqueName = uniqueName 

97 self.caption = caption 

98 

99 

100class CalculatedMember(Serialisable): 

101 

102 tagname = "calculatedMember" 

103 

104 name = String() 

105 mdx = String() 

106 memberName = String(allow_none=True) 

107 hierarchy = String(allow_none=True) 

108 parent = String(allow_none=True) 

109 solveOrder = Integer(allow_none=True) 

110 set = Bool() 

111 extLst = Typed(expected_type=ExtensionList, allow_none=True) 

112 

113 __elements__ = () 

114 

115 def __init__(self, 

116 name=None, 

117 mdx=None, 

118 memberName=None, 

119 hierarchy=None, 

120 parent=None, 

121 solveOrder=None, 

122 set=None, 

123 extLst=None, 

124 ): 

125 self.name = name 

126 self.mdx = mdx 

127 self.memberName = memberName 

128 self.hierarchy = hierarchy 

129 self.parent = parent 

130 self.solveOrder = solveOrder 

131 self.set = set 

132 #self.extLst = extLst 

133 

134 

135class CalculatedItem(Serialisable): 

136 

137 tagname = "calculatedItem" 

138 

139 field = Integer(allow_none=True) 

140 formula = String() 

141 pivotArea = Typed(expected_type=PivotArea, ) 

142 extLst = Typed(expected_type=ExtensionList, allow_none=True) 

143 

144 __elements__ = ('pivotArea', 'extLst') 

145 

146 def __init__(self, 

147 field=None, 

148 formula=None, 

149 pivotArea=None, 

150 extLst=None, 

151 ): 

152 self.field = field 

153 self.formula = formula 

154 self.pivotArea = pivotArea 

155 self.extLst = extLst 

156 

157 

158class ServerFormat(Serialisable): 

159 

160 tagname = "serverFormat" 

161 

162 culture = String(allow_none=True) 

163 format = String(allow_none=True) 

164 

165 def __init__(self, 

166 culture=None, 

167 format=None, 

168 ): 

169 self.culture = culture 

170 self.format = format 

171 

172 

173class Query(Serialisable): 

174 

175 tagname = "query" 

176 

177 mdx = String() 

178 tpls = Typed(expected_type=TupleList, allow_none=True) 

179 

180 __elements__ = ('tpls',) 

181 

182 def __init__(self, 

183 mdx=None, 

184 tpls=None, 

185 ): 

186 self.mdx = mdx 

187 self.tpls = tpls 

188 

189 

190class OLAPSet(Serialisable): 

191 

192 tagname = "set" 

193 

194 count = Integer() 

195 maxRank = Integer() 

196 setDefinition = String() 

197 sortType = NoneSet(values=(['ascending', 'descending', 'ascendingAlpha', 

198 'descendingAlpha', 'ascendingNatural', 'descendingNatural'])) 

199 queryFailed = Bool() 

200 tpls = Typed(expected_type=TupleList, allow_none=True) 

201 sortByTuple = Typed(expected_type=TupleList, allow_none=True) 

202 

203 __elements__ = ('tpls', 'sortByTuple') 

204 

205 def __init__(self, 

206 count=None, 

207 maxRank=None, 

208 setDefinition=None, 

209 sortType=None, 

210 queryFailed=None, 

211 tpls=None, 

212 sortByTuple=None, 

213 ): 

214 self.count = count 

215 self.maxRank = maxRank 

216 self.setDefinition = setDefinition 

217 self.sortType = sortType 

218 self.queryFailed = queryFailed 

219 self.tpls = tpls 

220 self.sortByTuple = sortByTuple 

221 

222 

223class PCDSDTCEntries(Serialisable): 

224 # Implements CT_PCDSDTCEntries 

225 

226 tagname = "entries" 

227 

228 count = Integer(allow_none=True) 

229 # elements are choice 

230 m = Typed(expected_type=Missing, allow_none=True) 

231 n = Typed(expected_type=Number, allow_none=True) 

232 e = Typed(expected_type=Error, allow_none=True) 

233 s = Typed(expected_type=Text, allow_none=True) 

234 

235 __elements__ = ('m', 'n', 'e', 's') 

236 

237 def __init__(self, 

238 count=None, 

239 m=None, 

240 n=None, 

241 e=None, 

242 s=None, 

243 ): 

244 self.count = count 

245 self.m = m 

246 self.n = n 

247 self.e = e 

248 self.s = s 

249 

250 

251class TupleCache(Serialisable): 

252 

253 tagname = "tupleCache" 

254 

255 entries = Typed(expected_type=PCDSDTCEntries, allow_none=True) 

256 sets = NestedSequence(expected_type=OLAPSet, count=True) 

257 queryCache = NestedSequence(expected_type=Query, count=True) 

258 serverFormats = NestedSequence(expected_type=ServerFormat, count=True) 

259 extLst = Typed(expected_type=ExtensionList, allow_none=True) 

260 

261 __elements__ = ('entries', 'sets', 'queryCache', 'serverFormats', 'extLst') 

262 

263 def __init__(self, 

264 entries=None, 

265 sets=(), 

266 queryCache=(), 

267 serverFormats=(), 

268 extLst=None, 

269 ): 

270 self.entries = entries 

271 self.sets = sets 

272 self.queryCache = queryCache 

273 self.serverFormats = serverFormats 

274 self.extLst = extLst 

275 

276 

277class OLAPKPI(Serialisable): 

278 

279 tagname = "kpi" 

280 

281 uniqueName = String() 

282 caption = String(allow_none=True) 

283 displayFolder = String(allow_none=True) 

284 measureGroup = String(allow_none=True) 

285 parent = String(allow_none=True) 

286 value = String() 

287 goal = String(allow_none=True) 

288 status = String(allow_none=True) 

289 trend = String(allow_none=True) 

290 weight = String(allow_none=True) 

291 time = String(allow_none=True) 

292 

293 def __init__(self, 

294 uniqueName=None, 

295 caption=None, 

296 displayFolder=None, 

297 measureGroup=None, 

298 parent=None, 

299 value=None, 

300 goal=None, 

301 status=None, 

302 trend=None, 

303 weight=None, 

304 time=None, 

305 ): 

306 self.uniqueName = uniqueName 

307 self.caption = caption 

308 self.displayFolder = displayFolder 

309 self.measureGroup = measureGroup 

310 self.parent = parent 

311 self.value = value 

312 self.goal = goal 

313 self.status = status 

314 self.trend = trend 

315 self.weight = weight 

316 self.time = time 

317 

318 

319class GroupMember(Serialisable): 

320 

321 tagname = "groupMember" 

322 

323 uniqueName = String() 

324 group = Bool() 

325 

326 def __init__(self, 

327 uniqueName=None, 

328 group=None, 

329 ): 

330 self.uniqueName = uniqueName 

331 self.group = group 

332 

333 

334class LevelGroup(Serialisable): 

335 

336 tagname = "group" 

337 

338 name = String() 

339 uniqueName = String() 

340 caption = String() 

341 uniqueParent = String() 

342 id = Integer() 

343 groupMembers = NestedSequence(expected_type=GroupMember, count=True) 

344 

345 __elements__ = ('groupMembers',) 

346 

347 def __init__(self, 

348 name=None, 

349 uniqueName=None, 

350 caption=None, 

351 uniqueParent=None, 

352 id=None, 

353 groupMembers=(), 

354 ): 

355 self.name = name 

356 self.uniqueName = uniqueName 

357 self.caption = caption 

358 self.uniqueParent = uniqueParent 

359 self.id = id 

360 self.groupMembers = groupMembers 

361 

362 

363class GroupLevel(Serialisable): 

364 

365 tagname = "groupLevel" 

366 

367 uniqueName = String() 

368 caption = String() 

369 user = Bool() 

370 customRollUp = Bool() 

371 groups = NestedSequence(expected_type=LevelGroup, count=True) 

372 extLst = Typed(expected_type=ExtensionList, allow_none=True) 

373 

374 __elements__ = ('groups', 'extLst') 

375 

376 def __init__(self, 

377 uniqueName=None, 

378 caption=None, 

379 user=None, 

380 customRollUp=None, 

381 groups=(), 

382 extLst=None, 

383 ): 

384 self.uniqueName = uniqueName 

385 self.caption = caption 

386 self.user = user 

387 self.customRollUp = customRollUp 

388 self.groups = groups 

389 self.extLst = extLst 

390 

391 

392class FieldUsage(Serialisable): 

393 

394 tagname = "fieldUsage" 

395 

396 x = Integer() 

397 

398 def __init__(self, 

399 x=None, 

400 ): 

401 self.x = x 

402 

403 

404class CacheHierarchy(Serialisable): 

405 

406 tagname = "cacheHierarchy" 

407 

408 uniqueName = String() 

409 caption = String(allow_none=True) 

410 measure = Bool() 

411 set = Bool() 

412 parentSet = Integer(allow_none=True) 

413 iconSet = Integer() 

414 attribute = Bool() 

415 time = Bool() 

416 keyAttribute = Bool() 

417 defaultMemberUniqueName = String(allow_none=True) 

418 allUniqueName = String(allow_none=True) 

419 allCaption = String(allow_none=True) 

420 dimensionUniqueName = String(allow_none=True) 

421 displayFolder = String(allow_none=True) 

422 measureGroup = String(allow_none=True) 

423 measures = Bool() 

424 count = Integer() 

425 oneField = Bool() 

426 memberValueDatatype = Integer(allow_none=True) 

427 unbalanced = Bool(allow_none=True) 

428 unbalancedGroup = Bool(allow_none=True) 

429 hidden = Bool() 

430 fieldsUsage = NestedSequence(expected_type=FieldUsage, count=True) 

431 groupLevels = NestedSequence(expected_type=GroupLevel, count=True) 

432 extLst = Typed(expected_type=ExtensionList, allow_none=True) 

433 

434 __elements__ = ('fieldsUsage', 'groupLevels') 

435 

436 def __init__(self, 

437 uniqueName="", 

438 caption=None, 

439 measure=None, 

440 set=None, 

441 parentSet=None, 

442 iconSet=0, 

443 attribute=None, 

444 time=None, 

445 keyAttribute=None, 

446 defaultMemberUniqueName=None, 

447 allUniqueName=None, 

448 allCaption=None, 

449 dimensionUniqueName=None, 

450 displayFolder=None, 

451 measureGroup=None, 

452 measures=None, 

453 count=None, 

454 oneField=None, 

455 memberValueDatatype=None, 

456 unbalanced=None, 

457 unbalancedGroup=None, 

458 hidden=None, 

459 fieldsUsage=(), 

460 groupLevels=(), 

461 extLst=None, 

462 ): 

463 self.uniqueName = uniqueName 

464 self.caption = caption 

465 self.measure = measure 

466 self.set = set 

467 self.parentSet = parentSet 

468 self.iconSet = iconSet 

469 self.attribute = attribute 

470 self.time = time 

471 self.keyAttribute = keyAttribute 

472 self.defaultMemberUniqueName = defaultMemberUniqueName 

473 self.allUniqueName = allUniqueName 

474 self.allCaption = allCaption 

475 self.dimensionUniqueName = dimensionUniqueName 

476 self.displayFolder = displayFolder 

477 self.measureGroup = measureGroup 

478 self.measures = measures 

479 self.count = count 

480 self.oneField = oneField 

481 self.memberValueDatatype = memberValueDatatype 

482 self.unbalanced = unbalanced 

483 self.unbalancedGroup = unbalancedGroup 

484 self.hidden = hidden 

485 self.fieldsUsage = fieldsUsage 

486 self.groupLevels = groupLevels 

487 self.extLst = extLst 

488 

489 

490class GroupItems(Serialisable): 

491 

492 tagname = "groupItems" 

493 

494 m = Sequence(expected_type=Missing) 

495 n = Sequence(expected_type=Number) 

496 b = Sequence(expected_type=Boolean) 

497 e = Sequence(expected_type=Error) 

498 s = Sequence(expected_type=Text) 

499 d = Sequence(expected_type=DateTimeField,) 

500 

501 __elements__ = ('m', 'n', 'b', 'e', 's', 'd') 

502 __attrs__ = ("count", ) 

503 

504 def __init__(self, 

505 count=None, 

506 m=(), 

507 n=(), 

508 b=(), 

509 e=(), 

510 s=(), 

511 d=(), 

512 ): 

513 self.m = m 

514 self.n = n 

515 self.b = b 

516 self.e = e 

517 self.s = s 

518 self.d = d 

519 

520 

521 @property 

522 def count(self): 

523 return len(self.m + self.n + self.b + self.e + self.s + self.d) 

524 

525 

526class RangePr(Serialisable): 

527 

528 tagname = "rangePr" 

529 

530 autoStart = Bool(allow_none=True) 

531 autoEnd = Bool(allow_none=True) 

532 groupBy = NoneSet(values=(['range', 'seconds', 'minutes', 'hours', 'days', 

533 'months', 'quarters', 'years'])) 

534 startNum = Float(allow_none=True) 

535 endNum = Float(allow_none=True) 

536 startDate = DateTime(allow_none=True) 

537 endDate = DateTime(allow_none=True) 

538 groupInterval = Float(allow_none=True) 

539 

540 def __init__(self, 

541 autoStart=True, 

542 autoEnd=True, 

543 groupBy="range", 

544 startNum=None, 

545 endNum=None, 

546 startDate=None, 

547 endDate=None, 

548 groupInterval=1, 

549 ): 

550 self.autoStart = autoStart 

551 self.autoEnd = autoEnd 

552 self.groupBy = groupBy 

553 self.startNum = startNum 

554 self.endNum = endNum 

555 self.startDate = startDate 

556 self.endDate = endDate 

557 self.groupInterval = groupInterval 

558 

559 

560class FieldGroup(Serialisable): 

561 

562 tagname = "fieldGroup" 

563 

564 par = Integer(allow_none=True) 

565 base = Integer(allow_none=True) 

566 rangePr = Typed(expected_type=RangePr, allow_none=True) 

567 discretePr = NestedSequence(expected_type=NestedInteger, count=True) 

568 groupItems = Typed(expected_type=GroupItems, allow_none=True) 

569 

570 __elements__ = ('rangePr', 'discretePr', 'groupItems') 

571 

572 def __init__(self, 

573 par=None, 

574 base=None, 

575 rangePr=None, 

576 discretePr=(), 

577 groupItems=None, 

578 ): 

579 self.par = par 

580 self.base = base 

581 self.rangePr = rangePr 

582 self.discretePr = discretePr 

583 self.groupItems = groupItems 

584 

585 

586class SharedItems(Serialisable): 

587 

588 tagname = "sharedItems" 

589 

590 _fields = MultiSequence() 

591 m = MultiSequencePart(expected_type=Missing, store="_fields") 

592 n = MultiSequencePart(expected_type=Number, store="_fields") 

593 b = MultiSequencePart(expected_type=Boolean, store="_fields") 

594 e = MultiSequencePart(expected_type=Error, store="_fields") 

595 s = MultiSequencePart(expected_type=Text, store="_fields") 

596 d = MultiSequencePart(expected_type=DateTimeField, store="_fields") 

597 # attributes are optional and must be derived from associated cache records 

598 containsSemiMixedTypes = Bool(allow_none=True) 

599 containsNonDate = Bool(allow_none=True) 

600 containsDate = Bool(allow_none=True) 

601 containsString = Bool(allow_none=True) 

602 containsBlank = Bool(allow_none=True) 

603 containsMixedTypes = Bool(allow_none=True) 

604 containsNumber = Bool(allow_none=True) 

605 containsInteger = Bool(allow_none=True) 

606 minValue = Float(allow_none=True) 

607 maxValue = Float(allow_none=True) 

608 minDate = DateTime(allow_none=True) 

609 maxDate = DateTime(allow_none=True) 

610 longText = Bool(allow_none=True) 

611 

612 __attrs__ = ('count', 'containsBlank', 'containsDate', 'containsInteger', 

613 'containsMixedTypes', 'containsNonDate', 'containsNumber', 

614 'containsSemiMixedTypes', 'containsString', 'minValue', 'maxValue', 

615 'minDate', 'maxDate', 'longText') 

616 

617 def __init__(self, 

618 _fields=(), 

619 containsSemiMixedTypes=None, 

620 containsNonDate=None, 

621 containsDate=None, 

622 containsString=None, 

623 containsBlank=None, 

624 containsMixedTypes=None, 

625 containsNumber=None, 

626 containsInteger=None, 

627 minValue=None, 

628 maxValue=None, 

629 minDate=None, 

630 maxDate=None, 

631 count=None, 

632 longText=None, 

633 ): 

634 self._fields = _fields 

635 self.containsBlank = containsBlank 

636 self.containsDate = containsDate 

637 self.containsNonDate = containsNonDate 

638 self.containsString = containsString 

639 self.containsMixedTypes = containsMixedTypes 

640 self.containsSemiMixedTypes = containsSemiMixedTypes 

641 self.containsNumber = containsNumber 

642 self.containsInteger = containsInteger 

643 self.minValue = minValue 

644 self.maxValue = maxValue 

645 self.minDate = minDate 

646 self.maxDate = maxDate 

647 self.longText = longText 

648 

649 

650 @property 

651 def count(self): 

652 return len(self._fields) 

653 

654 

655class CacheField(Serialisable): 

656 

657 tagname = "cacheField" 

658 

659 sharedItems = Typed(expected_type=SharedItems, allow_none=True) 

660 fieldGroup = Typed(expected_type=FieldGroup, allow_none=True) 

661 mpMap = NestedInteger(allow_none=True, attribute="v") 

662 extLst = Typed(expected_type=ExtensionList, allow_none=True) 

663 name = String() 

664 caption = String(allow_none=True) 

665 propertyName = String(allow_none=True) 

666 serverField = Bool(allow_none=True) 

667 uniqueList = Bool(allow_none=True) 

668 numFmtId = Integer(allow_none=True) 

669 formula = String(allow_none=True) 

670 sqlType = Integer(allow_none=True) 

671 hierarchy = Integer(allow_none=True) 

672 level = Integer(allow_none=True) 

673 databaseField = Bool(allow_none=True) 

674 mappingCount = Integer(allow_none=True) 

675 memberPropertyField = Bool(allow_none=True) 

676 

677 __elements__ = ('sharedItems', 'fieldGroup', 'mpMap') 

678 

679 def __init__(self, 

680 sharedItems=None, 

681 fieldGroup=None, 

682 mpMap=None, 

683 extLst=None, 

684 name=None, 

685 caption=None, 

686 propertyName=None, 

687 serverField=None, 

688 uniqueList=True, 

689 numFmtId=None, 

690 formula=None, 

691 sqlType=0, 

692 hierarchy=0, 

693 level=0, 

694 databaseField=True, 

695 mappingCount=None, 

696 memberPropertyField=None, 

697 ): 

698 self.sharedItems = sharedItems 

699 self.fieldGroup = fieldGroup 

700 self.mpMap = mpMap 

701 self.extLst = extLst 

702 self.name = name 

703 self.caption = caption 

704 self.propertyName = propertyName 

705 self.serverField = serverField 

706 self.uniqueList = uniqueList 

707 self.numFmtId = numFmtId 

708 self.formula = formula 

709 self.sqlType = sqlType 

710 self.hierarchy = hierarchy 

711 self.level = level 

712 self.databaseField = databaseField 

713 self.mappingCount = mappingCount 

714 self.memberPropertyField = memberPropertyField 

715 

716 

717class RangeSet(Serialisable): 

718 

719 tagname = "rangeSet" 

720 

721 i1 = Integer(allow_none=True) 

722 i2 = Integer(allow_none=True) 

723 i3 = Integer(allow_none=True) 

724 i4 = Integer(allow_none=True) 

725 ref = String() 

726 name = String(allow_none=True) 

727 sheet = String(allow_none=True) 

728 

729 def __init__(self, 

730 i1=None, 

731 i2=None, 

732 i3=None, 

733 i4=None, 

734 ref=None, 

735 name=None, 

736 sheet=None, 

737 ): 

738 self.i1 = i1 

739 self.i2 = i2 

740 self.i3 = i3 

741 self.i4 = i4 

742 self.ref = ref 

743 self.name = name 

744 self.sheet = sheet 

745 

746 

747class PageItem(Serialisable): 

748 

749 tagname = "pageItem" 

750 

751 name = String() 

752 

753 def __init__(self, 

754 name=None, 

755 ): 

756 self.name = name 

757 

758 

759class Consolidation(Serialisable): 

760 

761 tagname = "consolidation" 

762 

763 autoPage = Bool(allow_none=True) 

764 pages = NestedSequence(expected_type=PageItem, count=True) 

765 rangeSets = NestedSequence(expected_type=RangeSet, count=True) 

766 

767 __elements__ = ('pages', 'rangeSets') 

768 

769 def __init__(self, 

770 autoPage=None, 

771 pages=(), 

772 rangeSets=(), 

773 ): 

774 self.autoPage = autoPage 

775 self.pages = pages 

776 self.rangeSets = rangeSets 

777 

778 

779class WorksheetSource(Serialisable): 

780 

781 tagname = "worksheetSource" 

782 

783 ref = String(allow_none=True) 

784 name = String(allow_none=True) 

785 sheet = String(allow_none=True) 

786 

787 def __init__(self, 

788 ref=None, 

789 name=None, 

790 sheet=None, 

791 ): 

792 self.ref = ref 

793 self.name = name 

794 self.sheet = sheet 

795 

796 

797class CacheSource(Serialisable): 

798 

799 tagname = "cacheSource" 

800 

801 type = Set(values=(['worksheet', 'external', 'consolidation', 'scenario'])) 

802 connectionId = Integer(allow_none=True) 

803 # some elements are choice 

804 worksheetSource = Typed(expected_type=WorksheetSource, allow_none=True) 

805 consolidation = Typed(expected_type=Consolidation, allow_none=True) 

806 extLst = Typed(expected_type=ExtensionList, allow_none=True) 

807 

808 __elements__ = ('worksheetSource', 'consolidation',) 

809 

810 def __init__(self, 

811 type=None, 

812 connectionId=None, 

813 worksheetSource=None, 

814 consolidation=None, 

815 extLst=None, 

816 ): 

817 self.type = type 

818 self.connectionId = connectionId 

819 self.worksheetSource = worksheetSource 

820 self.consolidation = consolidation 

821 

822 

823class CacheDefinition(Serialisable): 

824 

825 mime_type = "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml" 

826 rel_type = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheDefinition" 

827 _id = 1 

828 _path = "/xl/pivotCache/pivotCacheDefinition{0}.xml" 

829 records = None 

830 

831 tagname = "pivotCacheDefinition" 

832 

833 invalid = Bool(allow_none=True) 

834 saveData = Bool(allow_none=True) 

835 refreshOnLoad = Bool(allow_none=True) 

836 optimizeMemory = Bool(allow_none=True) 

837 enableRefresh = Bool(allow_none=True) 

838 refreshedBy = String(allow_none=True) 

839 refreshedDate = Float(allow_none=True) 

840 refreshedDateIso = DateTime(allow_none=True) 

841 backgroundQuery = Bool(allow_none=True) 

842 missingItemsLimit = Integer(allow_none=True) 

843 createdVersion = Integer(allow_none=True) 

844 refreshedVersion = Integer(allow_none=True) 

845 minRefreshableVersion = Integer(allow_none=True) 

846 recordCount = Integer(allow_none=True) 

847 upgradeOnRefresh = Bool(allow_none=True)