phones.p_lglx5450

1 # THIS FILE IS AUTOMATICALLY GENERATED. EDIT THE SOURCE FILE NOT THIS ONE 2 3 """Various descriptions of data specific to LG LX5450""" 4 5 from prototypes import * 6 7 # Make all lg stuff available in this module as well 8 from p_lg import * 9 10 # we are the same as lgvx4400 except as noted 11 # below 12 from p_lgvx4400 import * 13 14 # We use LSB for all integer like fields 15 UINT=UINTlsb 16 BOOL=BOOLlsb 17 18 NUMSPEEDDIALS=100 19 FIRSTSPEEDDIAL=2 20 LASTSPEEDDIAL=99 21 NUMPHONEBOOKENTRIES=500 22 MAXCALENDARDESCRIPTION=38 23 24 # Calendar parameters 25 NUMCALENDARENTRIES=300 26 CAL_REP_NONE=0x10 27 CAL_REP_DAILY=0x11 28 CAL_REP_MONFRI=0x12 29 CAL_REP_WEEKLY=0x13 30 CAL_REP_MONTHLY=0x14 31 CAL_REP_YEARLY=0x15 32 CAL_DOW_SUN=0x0800 33 CAL_DOW_MON=0x0400 34 CAL_DOW_TUE=0x0200 35 CAL_DOW_WED=0x0100 36 CAL_DOW_THU=0x0080 37 CAL_DOW_FRI=0x0040 38 CAL_DOW_SAT=0x0020 39 CAL_DOW_EXCEPTIONS=0x0010 40 CAL_REMINDER_NONE=0 41 CAL_REMINDER_ONTIME=1 42 CAL_REMINDER_5MIN=2 43 CAL_REMINDER_10MIN=3 44 CAL_REMINDER_1HOUR=4 45 CAL_REMINDER_1DAY=5 46 CAL_REMINDER_2DAYS=6 47 CAL_REPEAT_DATE=(2100, 12, 31) 48 49 cal_dir='sch' 50 cal_data_file_name='sch/schedule.dat' 51 cal_exception_file_name='sch/schexception.dat' 52 cal_has_voice_id=False 53 54 PHONE_ENCODING='iso8859_1' 55

56 -class speeddial(BaseProtogenClass):

57 __fields=['entry', 'number'] 58

59 - def __init__(self, *args, **kwargs):

60 dict={} 61 # What was supplied to this function 62 dict.update(kwargs) 63 # Parent constructor 64 super(speeddial,self).__init__(**dict) 65 if self.__class__ is speeddial: 66 self._update(args,dict)

67 68

69 - def getfields(self):

70 return self.__fields

71 72

73 - def _update(self, args, kwargs):

74 super(speeddial,self)._update(args,kwargs) 75 keys=kwargs.keys() 76 for key in keys: 77 if key in self.__fields: 78 setattr(self, key, kwargs[key]) 79 del kwargs[key] 80 # Were any unrecognized kwargs passed in? 81 if __debug__: 82 self._complainaboutunusedargs(speeddial,kwargs) 83 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

84 # Make all P fields that haven't already been constructed 85 86

87 - def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):

88 'Writes this packet to the supplied buffer' 89 self._bufferstartoffset=buf.getcurrentoffset() 90 try: self.__field_entry 91 except: 92 self.__field_entry=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 93 self.__field_entry.writetobuffer(buf) 94 try: self.__field_number 95 except: 96 self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff}) 97 self.__field_number.writetobuffer(buf) 98 self._bufferendoffset=buf.getcurrentoffset() 99 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

100 101

102 - def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):

103 'Reads this packet from the supplied buffer' 104 self._bufferstartoffset=buf.getcurrentoffset() 105 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 106 self.__field_entry=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 107 self.__field_entry.readfrombuffer(buf) 108 self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff}) 109 self.__field_number.readfrombuffer(buf) 110 self._bufferendoffset=buf.getcurrentoffset()

111 112

113 - def __getfield_entry(self):

114 try: self.__field_entry 115 except: 116 self.__field_entry=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 117 return self.__field_entry.getvalue()

118

119 - def __setfield_entry(self, value):

120 if isinstance(value,UINT): 121 self.__field_entry=value 122 else: 123 self.__field_entry=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff})

124

125 - def __delfield_entry(self): del self.__field_entry

126 127 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 128

129 - def __getfield_number(self):

130 try: self.__field_number 131 except: 132 self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff}) 133 return self.__field_number.getvalue()

134

135 - def __setfield_number(self, value):

136 if isinstance(value,UINT): 137 self.__field_number=value 138 else: 139 self.__field_number=UINT(value,**{'sizeinbytes': 1, 'default': 0xff})

140

141 - def __delfield_number(self): del self.__field_number

142 143 number=property(__getfield_number, __setfield_number, __delfield_number, None) 144

145 - def iscontainer(self):

146 return True

147

148 - def containerelements(self):

149 yield ('entry', self.__field_entry, None) 150 yield ('number', self.__field_number, None)

151 152 153 154

155 -class speeddials(BaseProtogenClass):

156 __fields=['speeddials'] 157

158 - def __init__(self, *args, **kwargs):

159 dict={} 160 # What was supplied to this function 161 dict.update(kwargs) 162 # Parent constructor 163 super(speeddials,self).__init__(**dict) 164 if self.__class__ is speeddials: 165 self._update(args,dict)

166 167

168 - def getfields(self):

169 return self.__fields

170 171

172 - def _update(self, args, kwargs):

173 super(speeddials,self)._update(args,kwargs) 174 keys=kwargs.keys() 175 for key in keys: 176 if key in self.__fields: 177 setattr(self, key, kwargs[key]) 178 del kwargs[key] 179 # Were any unrecognized kwargs passed in? 180 if __debug__: 181 self._complainaboutunusedargs(speeddials,kwargs) 182 if len(args): 183 dict2={'length': NUMSPEEDDIALS, 'elementclass': speeddial} 184 dict2.update(kwargs) 185 kwargs=dict2 186 self.__field_speeddials=LIST(*args,**dict2)

187 # Make all P fields that haven't already been constructed 188 189

190 - def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):

191 'Writes this packet to the supplied buffer' 192 self._bufferstartoffset=buf.getcurrentoffset() 193 try: self.__field_speeddials 194 except: 195 self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial}) 196 self.__field_speeddials.writetobuffer(buf) 197 self._bufferendoffset=buf.getcurrentoffset() 198 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

199 200

201 - def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):

202 'Reads this packet from the supplied buffer' 203 self._bufferstartoffset=buf.getcurrentoffset() 204 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 205 self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial}) 206 self.__field_speeddials.readfrombuffer(buf) 207 self._bufferendoffset=buf.getcurrentoffset()

208 209

210 - def __getfield_speeddials(self):

211 try: self.__field_speeddials 212 except: 213 self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial}) 214 return self.__field_speeddials.getvalue()

215

216 - def __setfield_speeddials(self, value):

217 if isinstance(value,LIST): 218 self.__field_speeddials=value 219 else: 220 self.__field_speeddials=LIST(value,**{'length': NUMSPEEDDIALS, 'elementclass': speeddial})

221

222 - def __delfield_speeddials(self): del self.__field_speeddials

223 224 speeddials=property(__getfield_speeddials, __setfield_speeddials, __delfield_speeddials, None) 225

226 - def iscontainer(self):

227 return True

228

229 - def containerelements(self):

230 yield ('speeddials', self.__field_speeddials, None)

231 232 233 234

235 -class indexentry(BaseProtogenClass):

236 __fields=['index', 'name'] 237

238 - def __init__(self, *args, **kwargs):

239 dict={} 240 # What was supplied to this function 241 dict.update(kwargs) 242 # Parent constructor 243 super(indexentry,self).__init__(**dict) 244 if self.__class__ is indexentry: 245 self._update(args,dict)

246 247

248 - def getfields(self):

249 return self.__fields

250 251

252 - def _update(self, args, kwargs):

253 super(indexentry,self)._update(args,kwargs) 254 keys=kwargs.keys() 255 for key in keys: 256 if key in self.__fields: 257 setattr(self, key, kwargs[key]) 258 del kwargs[key] 259 # Were any unrecognized kwargs passed in? 260 if __debug__: 261 self._complainaboutunusedargs(indexentry,kwargs) 262 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

263 # Make all P fields that haven't already been constructed 264 265

266 - def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):

267 'Writes this packet to the supplied buffer' 268 self._bufferstartoffset=buf.getcurrentoffset() 269 try: self.__field_index 270 except: 271 self.__field_index=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 272 self.__field_index.writetobuffer(buf) 273 try: self.__field_name 274 except: 275 self.__field_name=USTRING(**{'sizeinbytes': 50, 'default': ""}) 276 self.__field_name.writetobuffer(buf) 277 self._bufferendoffset=buf.getcurrentoffset() 278 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

279 280

281 - def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):

282 'Reads this packet from the supplied buffer' 283 self._bufferstartoffset=buf.getcurrentoffset() 284 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 285 self.__field_index=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 286 self.__field_index.readfrombuffer(buf) 287 self.__field_name=USTRING(**{'sizeinbytes': 50, 'default': ""}) 288 self.__field_name.readfrombuffer(buf) 289 self._bufferendoffset=buf.getcurrentoffset()

290 291

292 - def __getfield_index(self):

293 try: self.__field_index 294 except: 295 self.__field_index=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 296 return self.__field_index.getvalue()

297

298 - def __setfield_index(self, value):

299 if isinstance(value,UINT): 300 self.__field_index=value 301 else: 302 self.__field_index=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff})

303

304 - def __delfield_index(self): del self.__field_index

305 306 index=property(__getfield_index, __setfield_index, __delfield_index, None) 307

308 - def __getfield_name(self):

309 try: self.__field_name 310 except: 311 self.__field_name=USTRING(**{'sizeinbytes': 50, 'default': ""}) 312 return self.__field_name.getvalue()

313

314 - def __setfield_name(self, value):

315 if isinstance(value,USTRING): 316 self.__field_name=value 317 else: 318 self.__field_name=USTRING(value,**{'sizeinbytes': 50, 'default': ""})

319

320 - def __delfield_name(self): del self.__field_name

321 322 name=property(__getfield_name, __setfield_name, __delfield_name, None) 323

324 - def iscontainer(self):

325 return True

326

327 - def containerelements(self):

328 yield ('index', self.__field_index, None) 329 yield ('name', self.__field_name, None)

330 331 332 333

334 -class indexfile(BaseProtogenClass):

335 "Used for tracking wallpaper and ringtones" 336 __fields=['numactiveitems', 'items'] 337

338 - def __init__(self, *args, **kwargs):

339 dict={} 340 # What was supplied to this function 341 dict.update(kwargs) 342 # Parent constructor 343 super(indexfile,self).__init__(**dict) 344 if self.__class__ is indexfile: 345 self._update(args,dict)

346 347

348 - def getfields(self):

349 return self.__fields

350 351

352 - def _update(self, args, kwargs):

353 super(indexfile,self)._update(args,kwargs) 354 keys=kwargs.keys() 355 for key in keys: 356 if key in self.__fields: 357 setattr(self, key, kwargs[key]) 358 del kwargs[key] 359 # Were any unrecognized kwargs passed in? 360 if __debug__: 361 self._complainaboutunusedargs(indexfile,kwargs) 362 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

363 # Make all P fields that haven't already been constructed 364 365

366 - def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):

367 'Writes this packet to the supplied buffer' 368 self._bufferstartoffset=buf.getcurrentoffset() 369 self.__field_numactiveitems.writetobuffer(buf) 370 try: self.__field_items 371 except: 372 self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True}) 373 self.__field_items.writetobuffer(buf) 374 self._bufferendoffset=buf.getcurrentoffset() 375 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

376 377

378 - def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):

379 'Reads this packet from the supplied buffer' 380 self._bufferstartoffset=buf.getcurrentoffset() 381 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 382 self.__field_numactiveitems=UINT(**{'sizeinbytes': 2}) 383 self.__field_numactiveitems.readfrombuffer(buf) 384 self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True}) 385 self.__field_items.readfrombuffer(buf) 386 self._bufferendoffset=buf.getcurrentoffset()

387 388

389 - def __getfield_numactiveitems(self):

390 return self.__field_numactiveitems.getvalue()

391

392 - def __setfield_numactiveitems(self, value):

393 if isinstance(value,UINT): 394 self.__field_numactiveitems=value 395 else: 396 self.__field_numactiveitems=UINT(value,**{'sizeinbytes': 2})

397

398 - def __delfield_numactiveitems(self): del self.__field_numactiveitems

399 400 numactiveitems=property(__getfield_numactiveitems, __setfield_numactiveitems, __delfield_numactiveitems, None) 401

402 - def __getfield_items(self):

403 try: self.__field_items 404 except: 405 self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True}) 406 return self.__field_items.getvalue()

407

408 - def __setfield_items(self, value):

409 if isinstance(value,LIST): 410 self.__field_items=value 411 else: 412 self.__field_items=LIST(value,**{'elementclass': indexentry, 'createdefault': True})

413

414 - def __delfield_items(self): del self.__field_items

415 416 items=property(__getfield_items, __setfield_items, __delfield_items, None) 417

418 - def iscontainer(self):

419 return True

420

421 - def containerelements(self):

422 yield ('numactiveitems', self.__field_numactiveitems, None) 423 yield ('items', self.__field_items, None)

424 425 426 427

428 -class camindexentry(BaseProtogenClass):

429 __fields=['index', 'name', 'taken', 'dunno'] 430

431 - def __init__(self, *args, **kwargs):

432 dict={} 433 # What was supplied to this function 434 dict.update(kwargs) 435 # Parent constructor 436 super(camindexentry,self).__init__(**dict) 437 if self.__class__ is camindexentry: 438 self._update(args,dict)

439 440

441 - def getfields(self):

442 return self.__fields

443 444

445 - def _update(self, args, kwargs):

446 super(camindexentry,self)._update(args,kwargs) 447 keys=kwargs.keys() 448 for key in keys: 449 if key in self.__fields: 450 setattr(self, key, kwargs[key]) 451 del kwargs[key] 452 # Were any unrecognized kwargs passed in? 453 if __debug__: 454 self._complainaboutunusedargs(camindexentry,kwargs) 455 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

456 # Make all P fields that haven't already been constructed 457 458

459 - def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):

460 'Writes this packet to the supplied buffer' 461 self._bufferstartoffset=buf.getcurrentoffset() 462 try: self.__field_index 463 except: 464 self.__field_index=UINT(**{'sizeinbytes': 1, 'default': 0}) 465 self.__field_index.writetobuffer(buf) 466 try: self.__field_name 467 except: 468 self.__field_name=USTRING(**{'sizeinbytes': 11, 'default': ""}) 469 self.__field_name.writetobuffer(buf) 470 try: self.__field_taken 471 except: 472 self.__field_taken=LGCALDATE(**{'sizeinbytes': 4}) 473 self.__field_taken.writetobuffer(buf) 474 try: self.__field_dunno 475 except: 476 self.__field_dunno=UINT(**{'sizeinbytes': 4, 'default': 0x00ff0100}) 477 self.__field_dunno.writetobuffer(buf) 478 self._bufferendoffset=buf.getcurrentoffset() 479 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

480 481

482 - def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):

483 'Reads this packet from the supplied buffer' 484 self._bufferstartoffset=buf.getcurrentoffset() 485 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 486 self.__field_index=UINT(**{'sizeinbytes': 1, 'default': 0}) 487 self.__field_index.readfrombuffer(buf) 488 self.__field_name=USTRING(**{'sizeinbytes': 11, 'default': ""}) 489 self.__field_name.readfrombuffer(buf) 490 self.__field_taken=LGCALDATE(**{'sizeinbytes': 4}) 491 self.__field_taken.readfrombuffer(buf) 492 self.__field_dunno=UINT(**{'sizeinbytes': 4, 'default': 0x00ff0100}) 493 self.__field_dunno.readfrombuffer(buf) 494 self._bufferendoffset=buf.getcurrentoffset()

495 496

497 - def __getfield_index(self):

498 try: self.__field_index 499 except: 500 self.__field_index=UINT(**{'sizeinbytes': 1, 'default': 0}) 501 return self.__field_index.getvalue()

502

503 - def __setfield_index(self, value):

504 if isinstance(value,UINT): 505 self.__field_index=value 506 else: 507 self.__field_index=UINT(value,**{'sizeinbytes': 1, 'default': 0})

508

509 - def __delfield_index(self): del self.__field_index

510 511 index=property(__getfield_index, __setfield_index, __delfield_index, None) 512

513 - def __getfield_name(self):

514 try: self.__field_name 515 except: 516 self.__field_name=USTRING(**{'sizeinbytes': 11, 'default': ""}) 517 return self.__field_name.getvalue()

518

519 - def __setfield_name(self, value):

520 if isinstance(value,USTRING): 521 self.__field_name=value 522 else: 523 self.__field_name=USTRING(value,**{'sizeinbytes': 11, 'default': ""})

524

525 - def __delfield_name(self): del self.__field_name

526 527 name=property(__getfield_name, __setfield_name, __delfield_name, None) 528

529 - def __getfield_taken(self):

530 try: self.__field_taken 531 except: 532 self.__field_taken=LGCALDATE(**{'sizeinbytes': 4}) 533 return self.__field_taken.getvalue()

534

535 - def __setfield_taken(self, value):

536 if isinstance(value,LGCALDATE): 537 self.__field_taken=value 538 else: 539 self.__field_taken=LGCALDATE(value,**{'sizeinbytes': 4})

540

541 - def __delfield_taken(self): del self.__field_taken

542 543 taken=property(__getfield_taken, __setfield_taken, __delfield_taken, None) 544

545 - def __getfield_dunno(self):

546 try: self.__field_dunno 547 except: 548 self.__field_dunno=UINT(**{'sizeinbytes': 4, 'default': 0x00ff0100}) 549 return self.__field_dunno.getvalue()

550

551 - def __setfield_dunno(self, value):

552 if isinstance(value,UINT): 553 self.__field_dunno=value 554 else: 555 self.__field_dunno=UINT(value,**{'sizeinbytes': 4, 'default': 0x00ff0100})

556

557 - def __delfield_dunno(self): del self.__field_dunno

558 559 dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None) 560

561 - def iscontainer(self):

562 return True

563

564 - def containerelements(self):

565 yield ('index', self.__field_index, None) 566 yield ('name', self.__field_name, None) 567 yield ('taken', self.__field_taken, None) 568 yield ('dunno', self.__field_dunno, None)

569 570 571 572

573 -class campicsdat(BaseProtogenClass):

574 "the cam/pics.dat file" 575 __fields=['items'] 576

577 - def __init__(self, *args, **kwargs):

578 dict={} 579 # What was supplied to this function 580 dict.update(kwargs) 581 # Parent constructor 582 super(campicsdat,self).__init__(**dict) 583 if self.__class__ is campicsdat: 584 self._update(args,dict)

585 586

587 - def getfields(self):

588 return self.__fields

589 590

591 - def _update(self, args, kwargs):

592 super(campicsdat,self)._update(args,kwargs) 593 keys=kwargs.keys() 594 for key in keys: 595 if key in self.__fields: 596 setattr(self, key, kwargs[key]) 597 del kwargs[key] 598 # Were any unrecognized kwargs passed in? 599 if __debug__: 600 self._complainaboutunusedargs(campicsdat,kwargs) 601 if len(args): 602 dict2={'length': 20, 'elementclass': camindexentry, 'createdefault': True} 603 dict2.update(kwargs) 604 kwargs=dict2 605 self.__field_items=LIST(*args,**dict2)

606 # Make all P fields that haven't already been constructed 607 608

609 - def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):

610 'Writes this packet to the supplied buffer' 611 self._bufferstartoffset=buf.getcurrentoffset() 612 try: self.__field_items 613 except: 614 self.__field_items=LIST(**{'length': 20, 'elementclass': camindexentry, 'createdefault': True}) 615 self.__field_items.writetobuffer(buf) 616 self._bufferendoffset=buf.getcurrentoffset() 617 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

618 619

620 - def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):

621 'Reads this packet from the supplied buffer' 622 self._bufferstartoffset=buf.getcurrentoffset() 623 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 624 self.__field_items=LIST(**{'length': 20, 'elementclass': camindexentry, 'createdefault': True}) 625 self.__field_items.readfrombuffer(buf) 626 self._bufferendoffset=buf.getcurrentoffset()

627 628

629 - def __getfield_items(self):

630 try: self.__field_items 631 except: 632 self.__field_items=LIST(**{'length': 20, 'elementclass': camindexentry, 'createdefault': True}) 633 return self.__field_items.getvalue()

634

635 - def __setfield_items(self, value):

636 if isinstance(value,LIST): 637 self.__field_items=value 638 else: 639 self.__field_items=LIST(value,**{'length': 20, 'elementclass': camindexentry, 'createdefault': True})

640

641 - def __delfield_items(self): del self.__field_items

642 643 items=property(__getfield_items, __setfield_items, __delfield_items, None) 644

645 - def iscontainer(self):

646 return True

647

648 - def containerelements(self):

649 yield ('items', self.__field_items, None)

650 651 652 653

654 -class scheduleexception(BaseProtogenClass):

655 __fields=['pos', 'day', 'month', 'year'] 656

657 - def __init__(self, *args, **kwargs):

658 dict={} 659 # What was supplied to this function 660 dict.update(kwargs) 661 # Parent constructor 662 super(scheduleexception,self).__init__(**dict) 663 if self.__class__ is scheduleexception: 664 self._update(args,dict)

665 666

667 - def getfields(self):

668 return self.__fields

669 670

671 - def _update(self, args, kwargs):

672 super(scheduleexception,self)._update(args,kwargs) 673 keys=kwargs.keys() 674 for key in keys: 675 if key in self.

Source Code for Module phones.p_lglx5450