tkintertable.TableModels

32 """A base model for managing the data in a TableCanvas class""" 33 34 keywords = {'columnnames':'columnNames', 'columntypes':'columntypes', 35 'columnlabels':'columnlabels', 'columnorder':'columnOrder', 36 'colors':'colors'} 37

38 - def __init__(self, newdict=None, rows=None, columns=None):

39 """Constructor""" 40 self.initialiseFields() 41 self.setupModel(newdict, rows, columns) 42 return

43

44 - def setupModel(self, newdict, rows=None, columns=None):

45 """Create table model""" 46 if newdict != None: 47 self.data = copy.deepcopy(newdict) 48 for k in self.keywords: 49 if self.data.has_key(k): 50 self.__dict__[self.keywords[k]] = self.data[k] 51 del self.data[k] 52 #read in the record list order 53 if self.data.has_key('reclist'): 54 temp = self.data['reclist'] 55 del self.data['reclist'] 56 self.reclist = temp 57 else: 58 self.reclist = self.data.keys() 59 else: 60 #just make a new empty model 61 self.createEmptyModel() 62 63 if not set(self.reclist) == set(self.data.keys()): 64 print 'reclist does not match data keys' 65 #restore last column order 66 if hasattr(self, 'columnOrder') and self.columnOrder != None: 67 self.columnNames=[] 68 for i in self.columnOrder.keys(): 69 self.columnNames.append(self.columnOrder[i]) 70 i=i+1 71 self.defaulttypes = ['text', 'number'] 72 #setup default display for column types 73 self.default_display = {'text' : 'showstring', 74 'number' : 'numtostring'} 75 #set default sort order as first col 76 if len(self.columnNames)>0: 77 self.sortkey = self.columnNames[0] 78 else: 79 self.sortkey = None 80 #add rows and cols if they are given in the constructor 81 if newdict == None: 82 if rows != None: 83 self.autoAddRows(rows) 84 if columns != None: 85 self.autoAddColumns(columns) 86 self.filteredrecs = None 87 return

88

89 - def initialiseFields(self):

90 """Create base fields, some of which are not saved""" 91 self.data = None # holds the table dict 92 self.colors = {} # holds cell colors 93 self.colors['fg']={} 94 self.colors['bg']={} 95 #default types 96 self.defaulttypes = ['text', 'number'] 97 #list of editable column types 98 self.editable={} 99 self.nodisplay = [] 100 self.columnwidths={} #used to store col widths, not held in saved data 101 return

102

103 - def createEmptyModel(self):

104 """Create the basic empty model dict""" 105 self.data = {} 106 # Define the starting column names and locations in the table. 107 self.columnNames = [] 108 self.columntypes = {} 109 self.columnOrder = None 110 #record column labels for use in a table header 111 self.columnlabels={} 112 for colname in self.columnNames: 113 self.columnlabels[colname]=colname 114 self.reclist = self.data.keys() 115 return

116

117 - def importDict(self, newdata):

118 """Try to create a table model from a dict of the form 119 {{'rec1': {'col1': 3, 'col2': 2}, ..}""" 120 121 #get cols from sub data keys 122 colnames = [] 123 for k in newdata: 124 fields = newdata[k].keys() 125 for f in fields: 126 if not f in colnames: 127 colnames.append(f) 128 for c in colnames: 129 self.addColumn(c) 130 #add the data 131 self.data.update(newdata) 132 self.reclist = self.data.keys() 133 return

134

135 - def getDefaultTypes(self):

136 """Get possible field types for this table model""" 137 return self.defaulttypes

138

139 - def getData(self):

140 """Return the current data for saving""" 141 data = copy.deepcopy(self.data) 142 data['colors'] = self.colors 143 data['columnnames'] = self.columnNames 144 #we keep original record order 145 data['reclist'] = self.reclist 146 #record current col order 147 data['columnorder']={} 148 i=0 149 for name in self.columnNames: 150 data['columnorder'][i] = name 151 i=i+1 152 data['columntypes'] = self.columntypes 153 data['columnlabels'] = self.columnlabels 154 return data

155

156 - def getAllCells(self):

157 """Return a dict of the form rowname: list of cell contents 158 Useful for a simple table export for example""" 159 records={} 160 for row in range(len(self.reclist)): 161 recdata=[] 162 for col in range(len(self.columnNames)): 163 recdata.append(self.getValueAt(row,col)) 164 records[row]=recdata 165 return records

166

167 - def getColCells(self, colIndex):

168 """Get the viewable contents of a col into a list""" 169 collist = [] 170 if self.getColumnType(colIndex) == 'Link': 171 return ['xxxxxx'] 172 else: 173 for row in range(len(self.reclist)): 174 v = self.getValueAt(row, colIndex) 175 collist.append(v) 176 return collist

177

178 - def getlongestEntry(self, columnIndex):

179 """Get the longest cell entry in the col""" 180 collist = self.getColCells(columnIndex) 181 maxw=5 182 for c in collist: 183 try: 184 w = len(str(c)) 185 except UnicodeEncodeError: 186 pass 187 if w > maxw: 188 maxw = w 189 #print 'longest width', maxw 190 return maxw

191

192 - def getRecordAtRow(self, rowIndex):

193 """Get the entire record at the specifed row.""" 194 name = self.getRecName(rowIndex) 195 record = self.data[name] 196 return record

197

198 - def getCellRecord(self, rowIndex, columnIndex):

199 """Get the data held in this row and column""" 200 value = None 201 colname = self.getColumnName(columnIndex) 202 coltype = self.columntypes[colname] 203 name = self.getRecName(rowIndex) 204 #print self.data[name] 205 if self.data[name].has_key(colname): 206 celldata=self.data[name][colname] 207 else: 208 celldata=None 209 return celldata

210

211 - def deleteCellRecord(self, rowIndex, columnIndex):

212 """Remove the cell data at this row/column""" 213 colname = self.getColumnName(columnIndex) 214 coltype = self.columntypes[colname] 215 name = self.getRecName(rowIndex) 216 if self.data[name].has_key(colname): 217 del self.data[name][colname] 218 return

219

220 - def getRecName(self, rowIndex):

221 """Get record name from row number""" 222 if len(self.reclist)==0: 223 return None 224 if self.filteredrecs != None: 225 name = self.filteredrecs[rowIndex] 226 else: 227 name = self.reclist[rowIndex] 228 return name

229

230 - def setRecName(self, newname, rowIndex):

231 """Set the record name to another value - requires re-setting in all 232 dicts that this rec is referenced""" 233 if len(self.reclist)==0: 234 return None 235 currname = self.getRecName(rowIndex) 236 self.reclist[rowIndex] = newname 237 temp = copy.deepcopy(self.data[currname]) 238 self.data[newname] = temp 239 #self.data[newname]['Name'] = newname 240 del self.data[currname] 241 for key in ['bg', 'fg']: 242 if self.colors[key].has_key(currname): 243 temp = copy.deepcopy(self.colors[key][currname]) 244 self.colors[key][newname] = temp 245 del self.colors[key][currname] 246 print 'renamed' 247 #would also need to resolve all refs to this rec in formulas here! 248 249 return

250

251 - def getRecordAttributeAtColumn(self, rowIndex=None, columnIndex=None, 252 recName=None, columnName=None):

253 """Get the attribute of the record at the specified column index. 254 This determines what will be displayed in the cell""" 255 256 value = None 257 if columnName != None and recName != None: 258 if not self.data[recName].has_key(columnName): 259 return '' 260 cell = self.data[recName][columnName] 261 else: 262 cell = self.getCellRecord(rowIndex, columnIndex) 263 columnName = self.getColumnName(columnIndex) 264 if cell == None: 265 cell='' 266 # Set the value based on the data record field 267 coltype = self.columntypes[columnName] 268 if Formula.isFormula(cell) == True: 269 value = self.doFormula(cell) 270 return value 271 272 if not type(cell) is DictType: 273 if coltype == 'text' or coltype == 'Text': 274 value = cell 275 elif coltype == 'number': 276 value = str(cell) 277 else: 278 value = 'other' 279 if value==None: 280 value='' 281 return value

282

283 - def getRecordIndex(self, recname):

284 rowIndex = self.reclist.index(recname) 285 return rowIndex

286

287 - def setSortOrder(self, columnIndex=None, columnName=None, reverse=0):

288 """Changes the order that records are sorted in, which will 289 be reflected in the table upon redrawing""" 290 291 if columnName != None and columnName in self.columnNames: 292 self.sortkey = columnName 293 elif columnIndex != None: 294 self.sortkey = self.getColumnName(columnIndex) 295 else: 296 return 297 self.reclist = self.createSortMap(self.reclist, self.sortkey, reverse) 298 if self.filteredrecs != None: 299 self.filteredrecs = self.createSortMap(self.filteredrecs, self.sortkey, reverse) 300 return

301

302 - def createSortMap(self, names, sortkey, reverse=0):

303 """Create a sort mapping for given list""" 304 305 recdata = [] 306 for rec in names: 307 recdata.append(self.getRecordAttributeAtColumn(recName=rec, columnName=sortkey)) 308 #try create list of floats if col has numbers only 309 try: 310 recdata = self.toFloats(recdata) 311 except: 312 pass 313 smap = zip(names, recdata) 314 #sort the mapping by the second key 315 smap = sorted(smap, key=operator.itemgetter(1), reverse=reverse) 316 #now sort the main reclist by the mapping order 317 sortmap = map(operator.itemgetter(0), smap) 318 return sortmap

319

320 - def toFloats(self, l):

321 x=[] 322 for i in l: 323 if i == '': 324 x.append(0.0) 325 else: 326 x.append(float(i)) 327 return x

328 329 '''def getSortIndex(self): 330 """Return the current sort order index""" 331 if self.sortcolumnIndex: 332 return self.sortcolumnIndex 333 else: 334 return 0''' 335

336 - def moveColumn(self, oldcolumnIndex, newcolumnIndex):

337 """Changes the order of columns""" 338 self.oldnames = self.columnNames 339 self.columnNames=[] 340 341 #write out a new column names list - tedious 342 moved = self.oldnames[oldcolumnIndex] 343 del self.oldnames[oldcolumnIndex] 344 #print self.oldnames 345 i=0 346 for c in self.oldnames: 347 if i==newcolumnIndex: 348 self.columnNames.append(moved) 349 self.columnNames.append(c) 350 i=i+1 351 #if new col is at end just append 352 if moved not in self.columnNames: 353 self.columnNames.append(moved) 354 return

355

356 - def getNextKey(self):

357 """Return the next numeric key in the dict""" 358 num = len(self.reclist)+1 359 return num

360

361 - def addRow(self, key=None, **kwargs):

362 """Add a row""" 363 if key == '': 364 return 365 if key==None: 366 key = self.getNextKey() 367 if self.data.has_key(key) or key in self.reclist: 368 print 'name already present!!' 369 return 370 self.data[key]={} 371 for k in kwargs: 372 if not k in self.columnNames: 373 self.addColumn(k) 374 self.data[key][k] = str(kwargs[k]) 375 self.reclist.append(key) 376 return key

377

378 - def deleteRow(self, rowIndex=None, key=None, update=True):

379 """Delete a row""" 380 if key == None or not key in self.reclist: 381 key = self.getRecName(rowIndex) 382 del self.data[key] 383 if update==True: 384 self.reclist.remove(key) 385 return

386

387 - def deleteRows(self, rowlist=None):

388 """Delete multiple or all rows""" 389 if rowlist == None: 390 rowlist = range(len(self.reclist)) 391 names = [self.getRecName(i) for i in rowlist] 392 for name in names: 393 self.deleteRow(key=name, update=True) 394 return

395

396 - def addColumn(self, colname=None, coltype=None):

397 """Add a column""" 398 index = self.getColumnCount()+ 1 399 if colname == None: 400 colname=str(index) 401 if colname in self.columnNames: 402 #print 'name is present!' 403 return 404 self.columnNames.append(colname) 405 self.columnlabels[colname] = colname 406 if coltype == None: 407 self.columntypes[colname]='text' 408 else: 409 self.columntypes[colname]=coltype 410 return

411

412 - def deleteColumn(self, columnIndex):

413 """delete a column""" 414 colname = self.getColumnName(columnIndex) 415 self.columnNames.remove(colname) 416 del self.columnlabels[colname] 417 del self.columntypes[colname] 418 #remove this field from every record 419 for recname in self.reclist: 420 if self.data[recname].has_key(colname): 421 del self.data[recname][colname] 422 if self.sortkey != None: 423 currIndex = self.getColumnIndex(self.sortkey) 424 if columnIndex == currIndex: 425 self.setSortOrder(0) 426 #print 'column deleted' 427 #print 'new cols:', self.columnNames 428 return

429

430 - def deleteColumns(self, cols=None):

431 """Remove all cols or list provided""" 432 if cols == None: 433 cols = self.columnNames 434 if self.getColumnCount() == 0: 435 return 436 for col in cols: 437 self.deleteColumn(col) 438 return

439

440 - def autoAddRows(self, numrows=None):

441 """Automatically add x number of records""" 442 rows = self.getRowCount() 443 ints = [i for i in self.reclist if isinstance(i, int)] 444 if len(ints)>0: 445 start = max(ints)+1 446 else: 447 start = 0 448 #we don't use addRow as it's too slow 449 keys = range(start,start+numrows) 450 #make sure no keys are present already 451 keys = list(set(keys)-set(self.reclist)) 452 newdata = {} 453 for k in keys: 454 newdata[k] = {} 455 self.data.update(newdata) 456 self.reclist.extend(newdata.keys()) 457 return keys

458

459 - def autoAddColumns(self, numcols=None):

460 """Automatically add x number of cols""" 461 462 alphabet = string.lowercase[:26] 463 currcols=self.getColumnCount() 464 #find where to start 465 start = currcols + 1 466 end = currcols + numcols + 1 467 new = [] 468 for n in range(start, end): 469 new.append(str(n)) 470 #check if any of these colnames present 471 common = set(new) & set(self.columnNames) 472 extra = len(common) 473 end = end + extra 474 for x in range(start, end): 475 self.addColumn(str(x)) 476 return

477

478 - def relabel_Column(self, columnIndex, newname):

479 """Change the column label - can be used in a table header""" 480 colname = self.getColumnName(columnIndex) 481 self.columnlabels[colname]=newname 482 return

483

484 - def getColumnType(self, columnIndex):

485 """Get the column type""" 486 colname = self.getColumnName(columnIndex) 487 coltype = self.columntypes[colname] 488 return coltype

489

490 - def getColumnCount(self):

491 """Returns the number of columns in the data model.""" 492 return len(self.columnNames)

493

494 - def getColumnName(self, columnIndex):

495 """Returns the name of the given column by columnIndex.""" 496 return self.columnNames[columnIndex]

497

498 - def getColumnLabel(self, columnIndex):

499 """Returns the label for this column""" 500 colname = self.getColumnName(columnIndex) 501 return self.columnlabels[colname]

502

503 - def getColumnIndex(self, columnName):

504 """Returns the column index for this column""" 505 colindex = self.columnNames.index(columnName) 506 return colindex

507

508 - def getColumnData(self, columnIndex=None, columnName=None, 509 filters=None):

510 """Return the data in a list for this col, 511 filters is a tuple of the form (key,value,operator,bool)""" 512 if columnIndex != None and columnIndex < len(self.columnNames): 513 columnName = self.getColumnName(columnIndex) 514 names = Filtering.doFiltering(searchfunc=self.filterBy, 515 filters=filters) 516 coldata = [self.data[n][columnName] for n in names] 517 return coldata

518

519 - def getColumns(self, colnames, filters=None, allowempty=True):

520 """Get column data for multiple cols, with given filter options, 521 filterby: list of tuples of the form (key,value,operator,bool) 522 allowempty: boolean if false means rows with empty vals for any 523 required fields are not returned 524 returns: lists of column data""" 525 526 def evaluate(l): 527 for i in l: 528 if i == '' or i == None: 529 return False 530 return True

531 coldata=[] 532 for c in colnames: 533 vals = self.getColumnData(columnName=c, filters=filters) 534 coldata.append(vals) 535 if allowempty == False: 536 result = [i for i in zip(*coldata) if evaluate(i) == True] 537 coldata = zip(*result) 538 return coldata

Source Code for Module tkintertable.TableModels