phones.p_sanyo8100

1 # THIS FILE IS AUTOMATICALLY GENERATED. EDIT THE SOURCE FILE NOT THIS ONE 2 3 """Various descriptions of data specific to Sanyo SCP-8100""" 4 5 from prototypes import * 6 7 # Make all sanyo stuff available in this module as well 8 from p_sanyo import * 9 from p_sanyomedia import * 10 from p_sanyonewer import * 11 12 # We use LSB for all integer like fields 13 UINT=UINTlsb 14 BOOL=BOOLlsb 15 _NUMPBSLOTS=300 16 _NUMSPEEDDIALS=8 17 _NUMLONGNUMBERS=5 18 _LONGPHONENUMBERLEN=30 19 _NUMEVENTSLOTS=100 20 _NUMCALLALARMSLOTS=15 21 _NUMCALLHISTORY=20 22 _MAXNUMBERLEN=48 23 _MAXEMAILLEN=48 24

25 -class phonenumber(BaseProtogenClass):

26 __fields=['number_len', 'number'] 27

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

29 dict={} 30 # What was supplied to this function 31 dict.update(kwargs) 32 # Parent constructor 33 super(phonenumber,self).__init__(**dict) 34 if self.__class__ is phonenumber: 35 self._update(args,dict)

36 37

38 - def getfields(self):

39 return self.__fields

40 41

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

43 super(phonenumber,self)._update(args,kwargs) 44 keys=kwargs.keys() 45 for key in keys: 46 if key in self.__fields: 47 setattr(self, key, kwargs[key]) 48 del kwargs[key] 49 # Were any unrecognized kwargs passed in? 50 if __debug__: 51 self._complainaboutunusedargs(phonenumber,kwargs) 52 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

53 # Make all P fields that haven't already been constructed 54 55

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

57 'Writes this packet to the supplied buffer' 58 self._bufferstartoffset=buf.getcurrentoffset() 59 try: self.__field_number_len 60 except: 61 self.__field_number_len=UINT(**{'sizeinbytes': 1, 'default': 0}) 62 self.__field_number_len.writetobuffer(buf) 63 try: self.__field_number 64 except: 65 self.__field_number=USTRING(**{'sizeinbytes': 49, 'default': ""}) 66 self.__field_number.writetobuffer(buf) 67 self._bufferendoffset=buf.getcurrentoffset() 68 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

69 70

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

72 'Reads this packet from the supplied buffer' 73 self._bufferstartoffset=buf.getcurrentoffset() 74 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 75 self.__field_number_len=UINT(**{'sizeinbytes': 1, 'default': 0}) 76 self.__field_number_len.readfrombuffer(buf) 77 self.__field_number=USTRING(**{'sizeinbytes': 49, 'default': ""}) 78 self.__field_number.readfrombuffer(buf) 79 self._bufferendoffset=buf.getcurrentoffset()

80 81

82 - def __getfield_number_len(self):

83 try: self.__field_number_len 84 except: 85 self.__field_number_len=UINT(**{'sizeinbytes': 1, 'default': 0}) 86 return self.__field_number_len.getvalue()

87

88 - def __setfield_number_len(self, value):

89 if isinstance(value,UINT): 90 self.__field_number_len=value 91 else: 92 self.__field_number_len=UINT(value,**{'sizeinbytes': 1, 'default': 0})

93

94 - def __delfield_number_len(self): del self.__field_number_len

95 96 number_len=property(__getfield_number_len, __setfield_number_len, __delfield_number_len, None) 97

98 - def __getfield_number(self):

99 try: self.__field_number 100 except: 101 self.__field_number=USTRING(**{'sizeinbytes': 49, 'default': ""}) 102 return self.__field_number.getvalue()

103

104 - def __setfield_number(self, value):

105 if isinstance(value,USTRING): 106 self.__field_number=value 107 else: 108 self.__field_number=USTRING(value,**{'sizeinbytes': 49, 'default': ""})

109

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

111 112 number=property(__getfield_number, __setfield_number, __delfield_number, None) 113

114 - def iscontainer(self):

115 return True

116

117 - def containerelements(self):

118 yield ('number_len', self.__field_number_len, None) 119 yield ('number', self.__field_number, None)

120 121 122 123

124 -class phonebookentry(BaseProtogenClass):

125 __fields=['slot', 'slotdup', 'name', 'numbers', 'email_len', 'email', 'url_len', 'url', 'secret', 'name_len'] 126

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

128 dict={} 129 # What was supplied to this function 130 dict.update(kwargs) 131 # Parent constructor 132 super(phonebookentry,self).__init__(**dict) 133 if self.__class__ is phonebookentry: 134 self._update(args,dict)

135 136

137 - def getfields(self):

138 return self.__fields

139 140

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

142 super(phonebookentry,self)._update(args,kwargs) 143 keys=kwargs.keys() 144 for key in keys: 145 if key in self.__fields: 146 setattr(self, key, kwargs[key]) 147 del kwargs[key] 148 # Were any unrecognized kwargs passed in? 149 if __debug__: 150 self._complainaboutunusedargs(phonebookentry,kwargs) 151 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

152 # Make all P fields that haven't already been constructed 153 154

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

156 'Writes this packet to the supplied buffer' 157 self._bufferstartoffset=buf.getcurrentoffset() 158 self.__field_slot.writetobuffer(buf) 159 self.__field_slotdup.writetobuffer(buf) 160 self.__field_name.writetobuffer(buf) 161 try: self.__field_numbers 162 except: 163 self.__field_numbers=LIST(**{'length': 7, 'createdefault': True, 'elementclass': phonenumber}) 164 self.__field_numbers.writetobuffer(buf) 165 try: self.__field_email_len 166 except: 167 self.__field_email_len=UINT(**{'sizeinbytes': 1}) 168 self.__field_email_len.writetobuffer(buf) 169 try: self.__field_email 170 except: 171 self.__field_email=USTRING(**{'sizeinbytes': 49, 'default': ""}) 172 self.__field_email.writetobuffer(buf) 173 try: self.__field_url_len 174 except: 175 self.__field_url_len=UINT(**{'sizeinbytes': 1}) 176 self.__field_url_len.writetobuffer(buf) 177 try: self.__field_url 178 except: 179 self.__field_url=USTRING(**{'sizeinbytes': 49, 'default': ""}) 180 self.__field_url.writetobuffer(buf) 181 try: self.__field_secret 182 except: 183 self.__field_secret=BOOL(**{'sizeinbytes': 1}) 184 self.__field_secret.writetobuffer(buf) 185 self.__field_name_len.writetobuffer(buf) 186 self._bufferendoffset=buf.getcurrentoffset() 187 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

188 189

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

191 'Reads this packet from the supplied buffer' 192 self._bufferstartoffset=buf.getcurrentoffset() 193 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 194 self.__field_slot=UINT(**{'sizeinbytes': 2}) 195 self.__field_slot.readfrombuffer(buf) 196 self.__field_slotdup=UINT(**{'sizeinbytes': 2}) 197 self.__field_slotdup.readfrombuffer(buf) 198 self.__field_name=USTRING(**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 199 self.__field_name.readfrombuffer(buf) 200 self.__field_numbers=LIST(**{'length': 7, 'createdefault': True, 'elementclass': phonenumber}) 201 self.__field_numbers.readfrombuffer(buf) 202 self.__field_email_len=UINT(**{'sizeinbytes': 1}) 203 self.__field_email_len.readfrombuffer(buf) 204 self.__field_email=USTRING(**{'sizeinbytes': 49, 'default': ""}) 205 self.__field_email.readfrombuffer(buf) 206 self.__field_url_len=UINT(**{'sizeinbytes': 1}) 207 self.__field_url_len.readfrombuffer(buf) 208 self.__field_url=USTRING(**{'sizeinbytes': 49, 'default': ""}) 209 self.__field_url.readfrombuffer(buf) 210 self.__field_secret=BOOL(**{'sizeinbytes': 1}) 211 self.__field_secret.readfrombuffer(buf) 212 self.__field_name_len=UINT(**{'sizeinbytes': 1}) 213 self.__field_name_len.readfrombuffer(buf) 214 self._bufferendoffset=buf.getcurrentoffset()

215 216

217 - def __getfield_slot(self):

218 return self.__field_slot.getvalue()

219

220 - def __setfield_slot(self, value):

221 if isinstance(value,UINT): 222 self.__field_slot=value 223 else: 224 self.__field_slot=UINT(value,**{'sizeinbytes': 2})

225

226 - def __delfield_slot(self): del self.__field_slot

227 228 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 229

230 - def __getfield_slotdup(self):

231 return self.__field_slotdup.getvalue()

232

233 - def __setfield_slotdup(self, value):

234 if isinstance(value,UINT): 235 self.__field_slotdup=value 236 else: 237 self.__field_slotdup=UINT(value,**{'sizeinbytes': 2})

238

239 - def __delfield_slotdup(self): del self.__field_slotdup

240 241 slotdup=property(__getfield_slotdup, __setfield_slotdup, __delfield_slotdup, None) 242

243 - def __getfield_name(self):

244 return self.__field_name.getvalue()

245

246 - def __setfield_name(self, value):

247 if isinstance(value,USTRING): 248 self.__field_name=value 249 else: 250 self.__field_name=USTRING(value,**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})

251

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

253 254 name=property(__getfield_name, __setfield_name, __delfield_name, None) 255

256 - def __getfield_numbers(self):

257 try: self.__field_numbers 258 except: 259 self.__field_numbers=LIST(**{'length': 7, 'createdefault': True, 'elementclass': phonenumber}) 260 return self.__field_numbers.getvalue()

261

262 - def __setfield_numbers(self, value):

263 if isinstance(value,LIST): 264 self.__field_numbers=value 265 else: 266 self.__field_numbers=LIST(value,**{'length': 7, 'createdefault': True, 'elementclass': phonenumber})

267

268 - def __delfield_numbers(self): del self.__field_numbers

269 270 numbers=property(__getfield_numbers, __setfield_numbers, __delfield_numbers, None) 271

272 - def __getfield_email_len(self):

273 try: self.__field_email_len 274 except: 275 self.__field_email_len=UINT(**{'sizeinbytes': 1}) 276 return self.__field_email_len.getvalue()

277

278 - def __setfield_email_len(self, value):

279 if isinstance(value,UINT): 280 self.__field_email_len=value 281 else: 282 self.__field_email_len=UINT(value,**{'sizeinbytes': 1})

283

284 - def __delfield_email_len(self): del self.__field_email_len

285 286 email_len=property(__getfield_email_len, __setfield_email_len, __delfield_email_len, None) 287

288 - def __getfield_email(self):

289 try: self.__field_email 290 except: 291 self.__field_email=USTRING(**{'sizeinbytes': 49, 'default': ""}) 292 return self.__field_email.getvalue()

293

294 - def __setfield_email(self, value):

295 if isinstance(value,USTRING): 296 self.__field_email=value 297 else: 298 self.__field_email=USTRING(value,**{'sizeinbytes': 49, 'default': ""})

299

300 - def __delfield_email(self): del self.__field_email

301 302 email=property(__getfield_email, __setfield_email, __delfield_email, None) 303

304 - def __getfield_url_len(self):

305 try: self.__field_url_len 306 except: 307 self.__field_url_len=UINT(**{'sizeinbytes': 1}) 308 return self.__field_url_len.getvalue()

309

310 - def __setfield_url_len(self, value):

311 if isinstance(value,UINT): 312 self.__field_url_len=value 313 else: 314 self.__field_url_len=UINT(value,**{'sizeinbytes': 1})

315

316 - def __delfield_url_len(self): del self.__field_url_len

317 318 url_len=property(__getfield_url_len, __setfield_url_len, __delfield_url_len, None) 319

320 - def __getfield_url(self):

321 try: self.__field_url 322 except: 323 self.__field_url=USTRING(**{'sizeinbytes': 49, 'default': ""}) 324 return self.__field_url.getvalue()

325

326 - def __setfield_url(self, value):

327 if isinstance(value,USTRING): 328 self.__field_url=value 329 else: 330 self.__field_url=USTRING(value,**{'sizeinbytes': 49, 'default': ""})

331

332 - def __delfield_url(self): del self.__field_url

333 334 url=property(__getfield_url, __setfield_url, __delfield_url, None) 335

336 - def __getfield_secret(self):

337 try: self.__field_secret 338 except: 339 self.__field_secret=BOOL(**{'sizeinbytes': 1}) 340 return self.__field_secret.getvalue()

341

342 - def __setfield_secret(self, value):

343 if isinstance(value,BOOL): 344 self.__field_secret=value 345 else: 346 self.__field_secret=BOOL(value,**{'sizeinbytes': 1})

347

348 - def __delfield_secret(self): del self.__field_secret

349 350 secret=property(__getfield_secret, __setfield_secret, __delfield_secret, None) 351

352 - def __getfield_name_len(self):

353 return self.__field_name_len.getvalue()

354

355 - def __setfield_name_len(self, value):

356 if isinstance(value,UINT): 357 self.__field_name_len=value 358 else: 359 self.__field_name_len=UINT(value,**{'sizeinbytes': 1})

360

361 - def __delfield_name_len(self): del self.__field_name_len

362 363 name_len=property(__getfield_name_len, __setfield_name_len, __delfield_name_len, None) 364

365 - def iscontainer(self):

366 return True

367

368 - def containerelements(self):

369 yield ('slot', self.__field_slot, None) 370 yield ('slotdup', self.__field_slotdup, None) 371 yield ('name', self.__field_name, None) 372 yield ('numbers', self.__field_numbers, None) 373 yield ('email_len', self.__field_email_len, None) 374 yield ('email', self.__field_email, None) 375 yield ('url_len', self.__field_url_len, None) 376 yield ('url', self.__field_url, None) 377 yield ('secret', self.__field_secret, None) 378 yield ('name_len', self.__field_name_len, None)

379 380 381 382

383 -class phonebookslotresponse(BaseProtogenClass):

384 __fields=['header', 'entry', 'pad'] 385

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

387 dict={} 388 # What was supplied to this function 389 dict.update(kwargs) 390 # Parent constructor 391 super(phonebookslotresponse,self).__init__(**dict) 392 if self.__class__ is phonebookslotresponse: 393 self._update(args,dict)

394 395

396 - def getfields(self):

397 return self.__fields

398 399

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

401 super(phonebookslotresponse,self)._update(args,kwargs) 402 keys=kwargs.keys() 403 for key in keys: 404 if key in self.__fields: 405 setattr(self, key, kwargs[key]) 406 del kwargs[key] 407 # Were any unrecognized kwargs passed in? 408 if __debug__: 409 self._complainaboutunusedargs(phonebookslotresponse,kwargs) 410 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

411 # Make all P fields that haven't already been constructed 412 413

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

415 'Writes this packet to the supplied buffer' 416 self._bufferstartoffset=buf.getcurrentoffset() 417 self.__field_header.writetobuffer(buf) 418 self.__field_entry.writetobuffer(buf) 419 self.__field_pad.writetobuffer(buf) 420 self._bufferendoffset=buf.getcurrentoffset() 421 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

422 423

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

425 'Reads this packet from the supplied buffer' 426 self._bufferstartoffset=buf.getcurrentoffset() 427 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 428 self.__field_header=sanyoheader() 429 self.__field_header.readfrombuffer(buf) 430 self.__field_entry=phonebookentry() 431 self.__field_entry.readfrombuffer(buf) 432 self.__field_pad=UNKNOWN() 433 self.__field_pad.readfrombuffer(buf) 434 self._bufferendoffset=buf.getcurrentoffset()

435 436

437 - def __getfield_header(self):

438 return self.__field_header.getvalue()

439

440 - def __setfield_header(self, value):

441 if isinstance(value,sanyoheader): 442 self.__field_header=value 443 else: 444 self.__field_header=sanyoheader(value,)

445

446 - def __delfield_header(self): del self.__field_header

447 448 header=property(__getfield_header, __setfield_header, __delfield_header, None) 449

450 - def __getfield_entry(self):

451 return self.__field_entry.getvalue()

452

453 - def __setfield_entry(self, value):

454 if isinstance(value,phonebookentry): 455 self.__field_entry=value 456 else: 457 self.__field_entry=phonebookentry(value,)

458

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

460 461 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 462

463 - def __getfield_pad(self):

464 return self.__field_pad.getvalue()

465

466 - def __setfield_pad(self, value):

467 if isinstance(value,UNKNOWN): 468 self.__field_pad=value 469 else: 470 self.__field_pad=UNKNOWN(value,)

471

472 - def __delfield_pad(self): del self.__field_pad

473 474 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 475

476 - def iscontainer(self):

477 return True

478

479 - def containerelements(self):

480 yield ('header', self.__field_header, None) 481 yield ('entry', self.__field_entry, None) 482 yield ('pad', self.__field_pad, None)

483 484 485 486

487 -class phonebookslotupdaterequest(BaseProtogenClass):

488 __fields=['header', 'entry', 'pad'] 489

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

491 dict={} 492 # What was supplied to this function 493 dict.update(kwargs) 494 # Parent constructor 495 super(phonebookslotupdaterequest,self).__init__(**dict) 496 if self.__class__ is phonebookslotupdaterequest: 497 self._update(args,dict)

498 499

500 - def getfields(self):

501 return self.__fields

502 503

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

505 super(phonebookslotupdaterequest,self)._update(args,kwargs) 506 keys=kwargs.keys() 507 for key in keys: 508 if key in self.__fields: 509 setattr(self, key, kwargs[key]) 510 del kwargs[key] 511 # Were any unrecognized kwargs passed in? 512 if __debug__: 513 self._complainaboutunusedargs(phonebookslotupdaterequest,kwargs) 514 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

515 # Make all P fields that haven't already been constructed 516 517

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

519 'Writes this packet to the supplied buffer' 520 self._bufferstartoffset=buf.getcurrentoffset() 521 try: self.__field_header 522 except: 523 self.__field_header=sanyowriteheader(**{'packettype': 0x0c, 'command': 0x28}) 524 self.__field_header.writetobuffer(buf) 525 self.__field_entry.writetobuffer(buf) 526 try: self.__field_pad 527 except: 528 self.__field_pad=UNKNOWN(**{'sizeinbytes': 500}) 529 self.__field_pad.writetobuffer(buf) 530 self._bufferendoffset=buf.getcurrentoffset() 531 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

532 533

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

535 'Reads this packet from the supplied buffer' 536 self._bufferstartoffset=buf.getcurrentoffset() 537 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 538 self.__field_header=sanyowriteheader(**{'packettype': 0x0c, 'command': 0x28}) 539 self.__field_header.readfrombuffer(buf) 540 self.__field_entry=phonebookentry() 541 self.__field_entry.readfrombuffer(buf) 542 self.__field_pad=UNKNOWN(**{'sizeinbytes': 500}) 543 self.__field_pad.readfrombuffer(buf) 544 self._bufferendoffset=buf.getcurrentoffset()

545 546

547 - def __getfield_header(self):

548 try: self.__field_header 549 except: 550 self.__field_header=sanyowriteheader(**{'packettype': 0x0c, 'command': 0x28}) 551 return self.__field_header.getvalue()

552

553 - def __setfield_header(self, value):

554 if isinstance(value,sanyowriteheader): 555 self.__field_header=value 556 else: 557 self.__field_header=sanyowriteheader(value,**{'packettype': 0x0c, 'command': 0x28})

558

559 - def __delfield_header(self): del self.__field_header

560 561 header=property(__getfield_header, __setfield_header, __delfield_header, None) 562

563 - def __getfield_entry(self):

564 return self.__field_entry.getvalue()

565

566 - def __setfield_entry(self, value):

567 if isinstance(value,phonebookentry): 568 self.__field_entry=value 569 else: 570 self.__field_entry=phonebookentry(value,)

571

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

573 574 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 575

576 - def __getfield_pad(self):

577 try: self.__field_pad 578 except: 579 self.__field_pad=UNKNOWN(**{'sizeinbytes': 500}) 580 return self.__field_pad.getvalue()

581

582 - def __setfield_pad(self, value):

583 if isinstance(value,UNKNOWN): 584 self.__field_pad=value 585 else: 586 self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 500})

587

588 - def __delfield_pad(self): del self.__field_pad

589 590 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 591

592 - def iscontainer(self):

593 return True

594

595 - def containerelements(self):

596 yield ('header', self.__field_header, None) 597 yield ('entry', self.__field_entry, None) 598 yield ('pad', self.__field_pad, None)

599 600 601 602

603 -class evententry(BaseProtogenClass):

604 __fields=['slot', 'flag', 'eventname', 'pad1', 'eventname_len', 'start', 'end', 'location', 'pad2', 'location_len', 'pad3', 'alarmdiff', 'period', 'dom', 'alarm', 'serial', 'pad4', 'ringtone'] 605

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

607 dict={} 608 # What was supplied to this function 609 dict.update(kwargs) 610 # Parent constructor 611 super(evententry,self).__init__(**dict) 612 if self.__class__ is evententry: 613 self._update(args,dict)

614 615

616 - def getfields(self):

617 return self.__fields

618 619

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

621 super(evententry,self)._update(args,kwargs) 622 keys=kwargs.keys() 623 for key in keys: 624 if key in self.__fields: 625 setattr(self, key, kwargs[key]) 626 del kwargs[key] 627 # Were any unrecognized kwargs passed in? 628 if __debug__: 629 self._complainaboutunusedargs(evententry,kwargs) 630 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

631 # Make all P fields that haven't already been constructed 632 633

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

635 'Writes this packet to the supplied buffer' 636 self._bufferstartoffset=buf.getcurrentoffset() 637 self.__field_slot.writetobuffer(buf) 638 self.__field_flag.writetobuffer(buf) 639 self.__field_eventname.writetobuffer(buf) 640 try: self.__field_pad1 641 except: 642 self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7}) 643 self.__field_pad1.writetobuffer(buf) 644 self.__field_eventname_len.writetobuffer(buf) 645 self.__field_start.writetobuffer(buf) 646 self.__field_end.writetobuffer(buf) 647 self.__field_location.writetobuffer(buf) 648 try: self.__field_pad2 649 except: 650 self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7}) 651 self.__field_pad2.writetobuffer(buf) 652 self.__field_location_len.writetobuffer(buf) 653 try: self.__field_pad3 654 except: 655 self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1}) 656 self.__field_pad3.writetobuffer(buf) 657 self.__field_alarmdiff.writetobuffer(buf) 658 self.__field_period.writetobuffer(buf) 659 self.__field_dom.writetobuffer(buf) 660 self.__field_alarm.writetobuffer(buf) 661 try: self.__field_serial 662 except: 663 self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 664 self.__field_serial.writetobuffer(buf) 665 try: self.__field_pad4 666 except: 667 self.__field_pad4=UNKNOWN(**{'sizeinbytes': 3}) 668 self.__field_pad4.writetobuffer(buf) 669 self.__field_ringtone.writetobuffer(buf) 670 self._bufferendoffset=buf.getcurrentoffset() 671 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

672 673

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

675 'Reads this packet from the supplied buffer' 676 self._bufferstartoffset=buf.getcurrentoffset() 677 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 678 self.__field_slot=UINT(**{'sizeinbytes': 1}) 679 self.__field_slot.readfrombuffer(buf) 680 self.__field_flag=UINT(**{'sizeinbytes': 1}) 681 self.__field_flag.readfrombuffer(buf) 682 self.__field_eventname=USTRING(**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 683 self.__field_eventname.readfrombuffer(buf) 684 self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7}) 685 self.__field_pad1.readfrombuffer(buf) 686 self.__field_eventname_len=UINT(**{'sizeinbytes': 1}) 687 self.__field_eventname_len.readfrombuffer(buf) 688 self.__field_start=UINT(**{'sizeinbytes': 4}) 689 self.__field_start.readfrombuffer(buf) 690 self.__field_end=UINT(**{'sizeinbytes': 4}) 691 self.__field_end.readfrombuffer(buf) 692 self.__field_location=USTRING(**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 693 self.__field_location.readfrombuffer(buf) 694 self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7}) 695 self.__field_pad2.readfrombuffer(buf) 696 self.__field_location_len=UINT(**{'sizeinbytes': 1}) 697 self.__field_location_len.readfrombuffer(buf) 698 self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1}) 699 self.__field_pad3.readfrombuffer(buf) 700 self.__field_alarmdiff=UINT(**{'sizeinbytes': 4}) 701 self.__field_alarmdiff.readfrombuffer(buf) 702 self.__field_period=UINT(**{'sizeinbytes': 1}) 703 self.__field_period.readfrombuffer(buf) 704 self.__field_dom=UINT(**{'sizeinbytes': 1}) 705 self.__field_dom.readfrombuffer(buf) 706 self.__field_alarm=UINT(**{'sizeinbytes': 4}) 707 self.__field_alarm.readfrombuffer(buf) 708 self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 709 self.__field_serial.readfrombuffer(buf) 710 self.__field_pad4=UNKNOWN(**{'sizeinbytes': 3}) 711 self.__field_pad4.readfrombuffer(buf) 712 self.__field_ringtone=UINT(**{'sizeinbytes': 1}) 713 self.__field_ringtone.readfrombuffer(buf) 714 self._bufferendoffset=buf.getcurrentoffset()

715 716

717 - def __getfield_slot(self):

718 return self.__field_slot.getvalue()

719

720 - def __setfield_slot(self, value):

721 if isinstance(value,UINT): 722 self.__field_slot=value 723 else: 724 self.__field_slot=UINT(value,**{'sizeinbytes': 1})

725

726 - def __delfield_slot(self): del self.__field_slot

727 728 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 729

730 - def __getfield_flag(self):

731 return self.__field_flag.getvalue()

732

733 - def __setfield_flag(self, value):

734 if isinstance(value,UINT): 735 self.__field_flag=value 736 else: 737 self.__field_flag=UINT(value,**{'sizeinbytes': 1})

738

739 - def __delfield_flag(self): del self.__field_flag

740 741 flag=property(__getfield_flag, __setfield_flag, __delfield_flag, "0: Not used, 1: Scheduled, 2: Already Happened") 742

743 - def __getfield_eventname(self):

744 return self.__field_eventname.getvalue()

745

746 - def __setfield_eventname(self, value):

747 if isinstance(value,USTRING): 748 self.__field_eventname=value 749 else: 750 self.__field_eventname=USTRING(value,**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})

751

752 - def __delfield_eventname(self): del self.__field_eventname

753 754 eventname=property(__getfield_eventname, __setfield_eventname, __delfield_eventname, None) 755

756 - def __getfield_pad1(self):

757 try: self.__field_pad1 758 except: 759 self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7}) 760 return self.__field_pad1.getvalue()

761

762 - def __setfield_pad1(self, value):

763 if isinstance(value,UNKNOWN): 764 self.__field_pad1=value 765 else: 766 self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 7})

767

768 - def __delfield_pad1(self): del self.__field_pad1

769 770 pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None) 771

772 - def __getfield_eventname_len(self):

773 return self.__field_eventname_len.getvalue()

774

775 - def __setfield_eventname_len(self, value):

776 if isinstance(value,UINT): 777 self.__field_eventname_len=value 778 else: 779 self.__field_eventname_len=UINT(value,**{'sizeinbytes': 1})

780

781 - def __delfield_eventname_len(self): del self.__field_eventname_len

782 783 eventname_len=property(__getfield_eventname_len, __setfield_eventname_len, __delfield_eventname_len, None) 784

785 - def __getfield_start(self):

786 return self.__field_start.getvalue()

787

788 - def __setfield_start(self, value):

789 if isinstance(value,UINT): 790 self.__field_start=value 791 else: 792 self.__field_start=UINT(value,**{'sizeinbytes': 4})

793

794 - def __delfield_start(self): del self.__field_start

795 796 start=property(__getfield_start, __setfield_start, __delfield_start, "# seconds since Jan 1, 1980 approximately") 797

798 - def __getfield_end(self):

799 return self.__field_end.getvalue()

800

801 - def __setfield_end(self, value):

802 if isinstance(value,UINT): 803 self.__field_end=value 804 else: 805 self.__field_end=UINT(value,**{'sizeinbytes': 4})

806

807 - def __delfield_end(self): del self.__field_end

808 809 end=property(__getfield_end, __setfield_end, __delfield_end, None) 810

811 - def __getfield_location(self):

812 return self.__field_location.getvalue()

813

814 - def __setfield_location(self, value):

815 if isinstance(value,USTRING): 816 self.__field_location=value 817 else: 818 self.__field_location=USTRING(value,**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})

819

820 - def __delfield_location(self): del self.__field_location

821 822 location=property(__getfield_location, __setfield_location, __delfield_location, None) 823

824 - def __getfield_pad2(self):

825 try: self.__field_pad2 826 except: 827 self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7}) 828 return self.__field_pad2.getvalue()

829

830 - def __setfield_pad2(self, value):

831 if isinstance(value,UNKNOWN): 832 self.__field_pad2=value 833 else: 834 self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 7})

835

836 - def __delfield_pad2(self): del self.__field_pad2

837 838 pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None) 839

840 - def __getfield_location_len(self):

841 return self.__field_location_len.getvalue()

842

843 - def __setfield_location_len(self, value):

844 if isinstance(value,UINT): 845 self.__field_location_len=value 846 else: 847 self.__field_location_len=UINT(value,**{'sizeinbytes': 1})

848

849 - def __delfield_location_len(self): del self.__field_location_len

850 851 location_len=property(__getfield_location_len, __setfield_location_len, __delfield_location_len, None) 852

853 - def __getfield_pad3(self):

854 try: self.__field_pad3 855 except: 856 self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1}) 857 return self.__field_pad3.getvalue()

858

859 - def __setfield_pad3(self, value):

860 if isinstance(value,UNKNOWN): 861 self.__field_pad3=value 862 else: 863 self.__field_pad3=UNKNOWN(value,**{'sizeinbytes': 1})

864

865 - def __delfield_pad3(self): del self.__field_pad3

866 867 pad3=property(__getfield_pad3, __setfield_pad3, __delfield_pad3, None) 868

869 - def __getfield_alarmdiff(self):

870 return self.__field_alarmdiff.getvalue()

871

872 - def __setfield_alarmdiff(self, value):

873 if isinstance(value,UINT): 874 self.__field_alarmdiff=value 875 else: 876 self.__field_alarmdiff=UINT(value,**{'sizeinbytes': 4})

877

878 - def __delfield_alarmdiff(self): del self.__field_alarmdiff

879 880 alarmdiff=property(__getfield_alarmdiff, __setfield_alarmdiff, __delfield_alarmdiff, "Displayed alarm time") 881

882 - def __getfield_period(self):

883 return self.__field_period.getvalue()

884

885 - def __setfield_period(self, value):

886 if isinstance(value,UINT): 887 self.__field_period=value 888 else: 889 self.__field_period=UINT(value,**{'sizeinbytes': 1})

890

891 - def __delfield_period(self): del self.__field_period

892 893 period=property(__getfield_period, __setfield_period, __delfield_period, "No, Daily, Weekly, Monthly, Yearly") 894

895 - def __getfield_dom(self):

896 return self.__field_dom.getvalue()

897

898 - def __setfield_dom(self, value):

899 if isinstance(value,UINT): 900 self.__field_dom=value 901 else: 902 self.__field_dom=UINT(value,**{'sizeinbytes': 1})

903

904 - def __delfield_dom(self): del self.__field_dom

905 906 dom=property(__getfield_dom, __setfield_dom, __delfield_dom, "Day of month for the event") 907

908 - def __getfield_alarm(self):

909 return self.__field_alarm.getvalue()

910

911 - def __setfield_alarm(self, value):

912 if isinstance(value,UINT): 913 self.__field_alarm=value 914 else: 915 self.__field_alarm=UINT(value,**{'sizeinbytes': 4})

916

917 - def __delfield_alarm(self): del self.__field_alarm

918 919 alarm=property(__getfield_alarm, __setfield_alarm, __delfield_alarm, None) 920

921 - def __getfield_serial(self):

922 try: self.__field_serial 923 except: 924 self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 925 return self.__field_serial.getvalue()

926

927 - def __setfield_serial(self, value):

928 if isinstance(value,UINT): 929 self.__field_serial=value 930 else: 931 self.__field_serial=UINT(value,**{'sizeinbytes': 1, 'default': 0})

932

933 - def __delfield_serial(self): del self.__field_serial

934 935 serial=property(__getfield_serial, __setfield_serial, __delfield_serial, "Some kind of serial number") 936

937 - def __getfield_pad4(self):

938 try: self.__field_pad4 939 except: 940 self.__field_pad4=UNKNOWN(**{'sizeinbytes': 3}) 941 return self.__field_pad4.getvalue()

942

943 - def __setfield_pad4(self, value):

944 if isinstance(value,UNKNOWN): 945 self.__field_pad4=value 946 else: 947 self.__field_pad4=UNKNOWN(value,**{'sizeinbytes': 3})

948

949 - def __delfield_pad4(self): del self.__field_pad4

950 951 pad4=property(__getfield_pad4, __setfield_pad4, __delfield_pad4, None) 952

953 - def __getfield_ringtone(self):

954 return self.__field_ringtone.getvalue()

955

956 - def __setfield_ringtone(self, value):

957 if isinstance(value,UINT): 958 self.__field_ringtone=value 959 else: 960 self.__field_ringtone=UINT(value,**{'sizeinbytes': 1})

961

962 - def __delfield_ringtone(self): del self.__field_ringtone

963 964 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, "0: Beep, 1: Voice, 2: Silent") 965

966 - def iscontainer(self):

967 return True

968

969 - def containerelements(self):

970 yield ('slot', self.__field_slot, None) 971 yield ('flag', self.__field_flag, "0: Not used, 1: Scheduled, 2: Already Happened") 972 yield ('eventname', self.__field_eventname, None) 973 yield ('pad1', self.__field_pad1, None) 974 yield ('eventname_len', self.__field_eventname_len, None) 975 yield ('start', self.__field_start, "# seconds since Jan 1, 1980 approximately") 976 yield ('end', self.__field_end, None) 977 yield ('location', self.__field_location, None) 978 yield ('pad2', self.__field_pad2, None) 979 yield ('location_len', self.__field_location_len, None) 980 yield ('pad3', self.__field_pad3, None) 981 yield ('alarmdiff', self.__field_alarmdiff, "Displayed alarm time") 982 yield ('period', self.__field_period, "No, Daily, Weekly, Monthly, Yearly") 983 yield ('dom', self.__field_dom, "Day of month for the event") 984 yield ('alarm', self.__field_alarm, None) 985 yield ('serial', self.__field_serial, "Some kind of serial number") 986 yield ('pad4', self.__field_pad4, None) 987 yield ('ringtone', self.__field_ringtone, "0: Beep, 1: Voice, 2: Silent")

988 989 990 991

992 -class eventresponse(BaseProtogenClass):

993 __fields=['header', 'entry', 'pad'] 994

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

996 dict={} 997 # What was supplied to this function 998 dict.update(kwargs) 999 # Parent constructor 1000 super(eventresponse,self).__init__(**dict) 1001 if self.__class__ is eventresponse: 1002 self._update(args,dict)

1003 1004

1005 - def getfields(self):

1006 return self.__fields

1007 1008

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

1010 super(eventresponse,self)._update(args,kwargs) 1011 keys=kwargs.keys() 1012 for key in keys: 1013 if key in self.__fields: 1014 setattr(self, key, kwargs[key]) 1015 del kwargs[key] 1016 # Were any unrecognized kwargs passed in? 1017 if __debug__: 1018 self._complainaboutunusedargs(eventresponse,kwargs) 1019 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

1020 # Make all P fields that haven't already been constructed 1021 1022

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

1024 'Writes this packet to the supplied buffer' 1025 self._bufferstartoffset=buf.getcurrentoffset() 1026 self.__field_header.writetobuffer(buf) 1027 self.__field_entry.writetobuffer(buf) 1028 self.__field_pad.writetobuffer(buf) 1029 self._bufferendoffset=buf.getcurrentoffset() 1030 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1031 1032

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

1034 'Reads this packet from the supplied buffer' 1035 self._bufferstartoffset=buf.getcurrentoffset() 1036 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1037 self.__field_header=sanyoheader() 1038 self.__field_header.readfrombuffer(buf) 1039 self.__field_entry=evententry() 1040 self.__field_entry.readfrombuffer(buf) 1041 self.__field_pad=UNKNOWN() 1042 self.__field_pad.readfrombuffer(buf) 1043 self._bufferendoffset=buf.getcurrentoffset()

1044 1045

1046 - def __getfield_header(self):

1047 return self.__field_header.getvalue()

1048

1049 - def __setfield_header(self, value):

1050 if isinstance(value,sanyoheader): 1051 self.__field_header=value 1052 else: 1053 self.__field_header=sanyoheader(value,)

1054

1055 - def __delfield_header(self): del self.__field_header

1056 1057 header=property(__getfield_header, __setfield_header, __delfield_header, None) 1058

1059 - def __getfield_entry(self):

1060 return self.__field_entry.getvalue()

1061

1062 - def __setfield_entry(self, value):

1063 if isinstance(value,evententry): 1064 self.__field_entry=value 1065 else: 1066 self.__field_entry=evententry(value,)

1067

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

1069 1070 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 1071

1072 - def __getfield_pad(self):

1073 return self.__field_pad.getvalue()

1074

1075 - def __setfield_pad(self, value):

1076 if isinstance(value,UNKNOWN): 1077 self.__field_pad=value 1078 else: 1079 self.__field_pad=UNKNOWN(value,)

1080

1081 - def __delfield_pad(self): del self.__field_pad

1082 1083 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 1084

1085 - def iscontainer(self):

1086 return True

1087

1088 - def containerelements(self):

1089 yield ('header', self.__field_header, None) 1090 yield ('entry', self.__field_entry, None) 1091 yield ('pad', self.__field_pad, None)

1092 1093 1094 1095

1096 -class eventupdaterequest(BaseProtogenClass):

1097 __fields=['header', 'entry', 'pad'] 1098

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

1100 dict={} 1101 # What was supplied to this function 1102 dict.update(kwargs) 1103 # Parent constructor 1104 super(eventupdaterequest,self).__init__(**dict) 1105 if self.__class__ is eventupdaterequest: 1106 self._update(args,dict)

1107 1108

1109 - def getfields(self):

1110 return self.__fields

1111 1112

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

1114 super(eventupdaterequest,self)._update(args,kwargs) 1115 keys=kwargs.keys() 1116 for key in keys: 1117 if key in self.__fields: 1118 setattr(self, key, kwargs[key]) 1119 del kwargs[key] 1120 # Were any unrecognized kwargs passed in? 1121 if __debug__: 1122 self._complainaboutunusedargs(eventupdaterequest,kwargs) 1123 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

1124 # Make all P fields that haven't already been constructed 1125 1126

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

1128 'Writes this packet to the supplied buffer' 1129 self._bufferstartoffset=buf.getcurrentoffset() 1130 try: self.__field_header 1131 except: 1132 self.__field_header=sanyowriteheader(**{'packettype': 0x0c, 'command':0x23}) 1133 self.__field_header.writetobuffer(buf) 1134 self.__field_entry.writetobuffer(buf) 1135 try: self.__field_pad 1136 except: 1137 self.__field_pad=UNKNOWN(**{'sizeinbytes': 400}) 1138 self.__field_pad.writetobuffer(buf) 1139 self._bufferendoffset=buf.getcurrentoffset() 1140 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1141 1142

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

1144 'Reads this packet from the supplied buffer' 1145 self._bufferstartoffset=buf.getcurrentoffset() 1146 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1147 self.__field_header=sanyowriteheader(**{'packettype': 0x0c, 'command':0x23}) 1148 self.__field_header.readfrombuffer(buf) 1149 self.__field_entry=evententry() 1150 self.__field_entry.readfrombuffer(buf) 1151 self.__field_pad=UNKNOWN(**{'sizeinbytes': 400}) 1152 self.__field_pad.readfrombuffer(buf) 1153 self._bufferendoffset=buf.getcurrentoffset()

1154 1155

1156 - def __getfield_header(self):

1157 try: self.__field_header 1158 except: 1159 self.__field_header=sanyowriteheader(**{'packettype': 0x0c, 'command':0x23}) 1160 return self.__field_header.getvalue()

1161

1162 - def __setfield_header(self, value):

1163 if isinstance(value,sanyowriteheader): 1164 self.__field_header=value 1165 else: 1166 self.__field_header=sanyowriteheader(value,**{'packettype': 0x0c, 'command':0x23})

1167

1168 - def __delfield_header(self): del self.__field_header

1169 1170 header=property(__getfield_header, __setfield_header, __delfield_header, None) 1171

1172 - def __getfield_entry(self):

1173 return self.__field_entry.getvalue()

1174

1175 - def __setfield_entry(self, value):

1176 if isinstance(value,evententry): 1177 self.__field_entry=value 1178 else: 1179 self.__field_entry=evententry(value,)

1180

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

1182 1183 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 1184

1185 - def __getfield_pad(self):

1186 try: self.__field_pad 1187 except: 1188 self.__field_pad=UNKNOWN(**{'sizeinbytes': 400}) 1189 return self.__field_pad.getvalue()

1190

1191 - def __setfield_pad(self, value):

1192 if isinstance(value,UNKNOWN): 1193 self.__field_pad=value 1194 else: 1195 self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 400})

1196

1197 - def __delfield_pad(self): del self.__field_pad

1198 1199 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 1200

1201 - def iscontainer(self):

1202 return True

1203

1204 - def containerelements(self):

1205 yield ('header', self.__field_header, None) 1206 yield ('entry', self.__field_entry, None) 1207 yield ('pad', self.__field_pad, None)

1208 1209 1210 1211

1212 -class callalarmentry(BaseProtogenClass):

1213 __fields=['ringtone', 'slot', 'flag', 'dunno1', 'phonenum', 'phonenum_len', 'date', 'period', 'dom', 'datedup', 'name', 'pad1', 'name_len', 'phonenumbertype', 'phonenumberslot', 'serial'] 1214

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

1216 dict={} 1217 # What was supplied to this function 1218 dict.update(kwargs) 1219 # Parent constructor 1220 super(callalarmentry,self).__init__(**dict) 1221 if self.__class__ is callalarmentry: 1222 self._update(args,dict)

1223 1224

1225 - def getfields(self):

1226 return self.__fields

1227 1228

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

1230 super(callalarmentry,self)._update(args,kwargs) 1231 keys=kwargs.keys() 1232 for key in keys: 1233 if key in self.__fields: 1234 setattr(self, key, kwargs[key]) 1235 del kwargs[key] 1236 # Were any unrecognized kwargs passed in? 1237 if __debug__: 1238 self._complainaboutunusedargs(callalarmentry,kwargs) 1239 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1240 # Make all P fields that haven't already been constructed 1241 try: self.__field_ringtone 1242 except: 1243 self.__field_ringtone=UINT(**{'constant': 0})

1244 1245

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

1247 'Writes this packet to the supplied buffer' 1248 self._bufferstartoffset=buf.getcurrentoffset() 1249 self.__field_slot.writetobuffer(buf) 1250 self.__field_flag.writetobuffer(buf) 1251 try: self.__field_dunno1 1252 except: 1253 self.__field_dunno1=UINT(**{'sizeinbytes': 1, 'default': 0}) 1254 self.__field_dunno1.writetobuffer(buf) 1255 self.__field_phonenum.writetobuffer(buf) 1256 self.__field_phonenum_len.writetobuffer(buf) 1257 self.__field_date.writetobuffer(buf) 1258 self.__field_period.writetobuffer(buf) 1259 self.__field_dom.writetobuffer(buf) 1260 self.__field_datedup.writetobuffer(buf) 1261 self.__field_name.writetobuffer(buf) 1262 try: self.__field_pad1 1263 except: 1264 self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1}) 1265 self.__field_pad1.writetobuffer(buf) 1266 self.__field_name_len.writetobuffer(buf) 1267 self.__field_phonenumbertype.writetobuffer(buf) 1268 self.__field_phonenumberslot.writetobuffer(buf) 1269 try: self.__field_serial 1270 except: 1271 self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 1272 self.__field_serial.writetobuffer(buf) 1273 self._bufferendoffset=buf.getcurrentoffset() 1274 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1275 1276

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

1278 'Reads this packet from the supplied buffer' 1279 self._bufferstartoffset=buf.getcurrentoffset() 1280 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1281 self.__field_slot=UINT(**{'sizeinbytes': 1}) 1282 self.__field_slot.readfrombuffer(buf) 1283 self.__field_flag=UINT(**{'sizeinbytes': 1}) 1284 self.__field_flag.readfrombuffer(buf) 1285 self.__field_dunno1=UINT(**{'sizeinbytes': 1, 'default': 0}) 1286 self.__field_dunno1.readfrombuffer(buf) 1287 self.__field_phonenum=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 1288 self.__field_phonenum.readfrombuffer(buf) 1289 self.__field_phonenum_len=UINT(**{'sizeinbytes': 1}) 1290 self.__field_phonenum_len.readfrombuffer(buf) 1291 self.__field_date=UINT(**{'sizeinbytes': 4}) 1292 self.__field_date.readfrombuffer(buf) 1293 self.__field_period=UINT(**{'sizeinbytes': 1}) 1294 self.__field_period.readfrombuffer(buf) 1295 self.__field_dom=UINT(**{'sizeinbytes': 1}) 1296 self.__field_dom.readfrombuffer(buf) 1297 self.__field_datedup=UINT(**{'sizeinbytes': 4}) 1298 self.__field_datedup.readfrombuffer(buf) 1299 self.__field_name=USTRING(**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 1300 self.__field_name.readfrombuffer(buf) 1301 self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1}) 1302 self.__field_pad1.readfrombuffer(buf) 1303 self.__field_name_len=UINT(**{'sizeinbytes': 1}) 1304 self.__field_name_len.readfrombuffer(buf) 1305 self.__field_phonenumbertype=UINT(**{'sizeinbytes': 1}) 1306 self.__field_phonenumbertype.readfrombuffer(buf) 1307 self.__field_phonenumberslot=UINT(**{'sizeinbytes': 2}) 1308 self.__field_phonenumberslot.readfrombuffer(buf) 1309 self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 1310 self.__field_serial.readfrombuffer(buf) 1311 self._bufferendoffset=buf.getcurrentoffset()

1312 1313

1314 - def __getfield_ringtone(self):

1315 return self.__field_ringtone.getvalue()

1316

1317 - def __setfield_ringtone(self, value):

1318 if isinstance(value,UINT): 1319 self.__field_ringtone=value 1320 else: 1321 self.__field_ringtone=UINT(value,**{'constant': 0})

1322

1323 - def __delfield_ringtone(self): del self.__field_ringtone

1324 1325 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 1326

1327 - def __getfield_slot(self):

1328 return self.__field_slot.getvalue()

1329

1330 - def __setfield_slot(self, value):

1331 if isinstance(value,UINT): 1332 self.__field_slot=value 1333 else: 1334 self.__field_slot=UINT(value,**{'sizeinbytes': 1})

1335

1336 - def __delfield_slot(self): del self.__field_slot

1337 1338 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 1339

1340 - def __getfield_flag(self):

1341 return self.__field_flag.getvalue()

1342

1343 - def __setfield_flag(self, value):

1344 if isinstance(value,UINT): 1345 self.__field_flag=value 1346 else: 1347 self.__field_flag=UINT(value,**{'sizeinbytes': 1})

1348

1349 - def __delfield_flag(self): del self.__field_flag

1350 1351 flag=property(__getfield_flag, __setfield_flag, __delfield_flag, "0: Not used, 1: Scheduled, 2: Already Happened") 1352

1353 - def __getfield_dunno1(self):

1354 try: self.__field_dunno1 1355 except: 1356 self.__field_dunno1=UINT(**{'sizeinbytes': 1, 'default': 0}) 1357 return self.__field_dunno1.getvalue()

1358

1359 - def __setfield_dunno1(self, value):

1360 if isinstance(value,UINT): 1361 self.__field_dunno1=value 1362 else: 1363 self.__field_dunno1=UINT(value,**{'sizeinbytes': 1, 'default': 0})

1364

1365 - def __delfield_dunno1(self): del self.__field_dunno1

1366 1367 dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, "Related to Snooze?") 1368

1369 - def __getfield_phonenum(self):

1370 return self.__field_phonenum.getvalue()

1371

1372 - def __setfield_phonenum(self, value):

1373 if isinstance(value,USTRING): 1374 self.__field_phonenum=value 1375 else: 1376 self.__field_phonenum=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False})

1377

1378 - def __delfield_phonenum(self): del self.__field_phonenum

1379 1380 phonenum=property(__getfield_phonenum, __setfield_phonenum, __delfield_phonenum, None) 1381

1382 - def __getfield_phonenum_len(self):

1383 return self.__field_phonenum_len.getvalue()

1384

1385 - def __setfield_phonenum_len(self, value):

1386 if isinstance(value,UINT): 1387 self.__field_phonenum_len=value 1388 else: 1389 self.__field_phonenum_len=UINT(value,**{'sizeinbytes': 1})

1390

1391 - def __delfield_phonenum_len(self): del self.__field_phonenum_len

1392 1393 phonenum_len=property(__getfield_phonenum_len, __setfield_phonenum_len, __delfield_phonenum_len, None) 1394

1395 - def __getfield_date(self):

1396 return self.__field_date.getvalue()

1397

1398 - def __setfield_date(self, value):

1399 if isinstance(value,UINT): 1400 self.__field_date=value 1401 else: 1402 self.__field_date=UINT(value,**{'sizeinbytes': 4})

1403

1404 - def __delfield_date(self): del self.__field_date

1405 1406 date=property(__getfield_date, __setfield_date, __delfield_date, "# seconds since Jan 1, 1980 approximately") 1407

1408 - def __getfield_period(self):

1409 return self.__field_period.getvalue()

1410

1411 - def __setfield_period(self, value):

1412 if isinstance(value,UINT): 1413 self.__field_period=value 1414 else: 1415 self.__field_period=UINT(value,**{'sizeinbytes': 1})

1416

1417 - def __delfield_period(self): del self.__field_period

1418 1419 period=property(__getfield_period, __setfield_period, __delfield_period, "No, Daily, Weekly, Monthly, Yearly") 1420

1421 - def __getfield_dom(self):

1422 return self.__field_dom.getvalue()

1423

1424 - def __setfield_dom(self, value):

1425 if isinstance(value,UINT): 1426 self.__field_dom=value 1427 else: 1428 self.__field_dom=UINT(value,**{'sizeinbytes': 1})

1429

1430 - def __delfield_dom(self): del self.__field_dom

1431 1432 dom=property(__getfield_dom, __setfield_dom, __delfield_dom, "Day of month for the event") 1433

1434 - def __getfield_datedup(self):

1435 return self.__field_datedup.getvalue()

1436

1437 - def __setfield_datedup(self, value):

1438 if isinstance(value,UINT): 1439 self.__field_datedup=value 1440 else: 1441 self.__field_datedup=UINT(value,**{'sizeinbytes': 4})

1442

1443 - def __delfield_datedup(self): del self.__field_datedup

1444 1445 datedup=property(__getfield_datedup, __setfield_datedup, __delfield_datedup, "Copy of the date. Always the same???") 1446

1447 - def __getfield_name(self):

1448 return self.__field_name.getvalue()

1449

1450 - def __setfield_name(self, value):

1451 if isinstance(value,USTRING): 1452 self.__field_name=value 1453 else: 1454 self.__field_name=USTRING(value,**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})

1455

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

1457 1458 name=property(__getfield_name, __setfield_name, __delfield_name, None) 1459

1460 - def __getfield_pad1(self):

1461 try: self.__field_pad1 1462 except: 1463 self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1}) 1464 return self.__field_pad1.getvalue()

1465

1466 - def __setfield_pad1(self, value):

1467 if isinstance(value,UNKNOWN): 1468 self.__field_pad1=value 1469 else: 1470 self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 1})

1471

1472 - def __delfield_pad1(self): del self.__field_pad1

1473 1474 pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None) 1475

1476 - def __getfield_name_len(self):

1477 return self.__field_name_len.getvalue()

1478

1479 - def __setfield_name_len(self, value):

1480 if isinstance(value,UINT): 1481 self.__field_name_len=value 1482 else: 1483 self.__field_name_len=UINT(value,**{'sizeinbytes': 1})

1484

1485 - def __delfield_name_len(self): del self.__field_name_len

1486 1487 name_len=property(__getfield_name_len, __setfield_name_len, __delfield_name_len, None) 1488

1489 - def __getfield_phonenumbertype(self):

1490 return self.__field_phonenumbertype.getvalue()

1491

1492 - def __setfield_phonenumbertype(self, value):

1493 if isinstance(value,UINT): 1494 self.__field_phonenumbertype=value 1495 else: 1496 self.__field_phonenumbertype=UINT(value,**{'sizeinbytes': 1})

1497

1498 - def __delfield_phonenumbertype(self): del self.__field_phonenumbertype

1499 1500 phonenumbertype=property(__getfield_phonenumbertype, __setfield_phonenumbertype, __delfield_phonenumbertype, "1: Home, 2: Work, ...") 1501

1502 - def __getfield_phonenumberslot(self):

1503 return self.__field_phonenumberslot.getvalue()

1504

1505 - def __setfield_phonenumberslot(self, value):

1506 if isinstance(value,UINT): 1507 self.__field_phonenumberslot=value 1508 else: 1509 self.__field_phonenumberslot=UINT(value,**{'sizeinbytes': 2})

1510

1511 - def __delfield_phonenumberslot(self): del self.__field_phonenumberslot

1512 1513 phonenumberslot=property(__getfield_phonenumberslot, __setfield_phonenumberslot, __delfield_phonenumberslot, None) 1514

1515 - def __getfield_serial(self):

1516 try: self.__field_serial 1517 except: 1518 self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 1519 return self.__field_serial.getvalue()

1520

1521 - def __setfield_serial(self, value):

1522 if isinstance(value,UINT): 1523 self.__field_serial=value 1524 else: 1525 self.__field_serial=UINT(value,**{'sizeinbytes': 1, 'default': 0})

1526

1527 - def __delfield_serial(self): del self.__field_serial

1528 1529 serial=property(__getfield_serial, __setfield_serial, __delfield_serial, None) 1530

1531 - def iscontainer(self):

1532 return True

1533

1534 - def containerelements(self):

1535 yield ('ringtone', self.__field_ringtone, None) 1536 yield ('slot', self.__field_slot, None) 1537 yield ('flag', self.__field_flag, "0: Not used, 1: Scheduled, 2: Already Happened") 1538 yield ('dunno1', self.__field_dunno1, "Related to Snooze?") 1539 yield ('phonenum', self.__field_phonenum, None) 1540 yield ('phonenum_len', self.__field_phonenum_len, None) 1541 yield ('date', self.__field_date, "# seconds since Jan 1, 1980 approximately") 1542 yield ('period', self.__field_period, "No, Daily, Weekly, Monthly, Yearly") 1543 yield ('dom', self.__field_dom, "Day of month for the event") 1544 yield ('datedup', self.__field_datedup, "Copy of the date. Always the same???") 1545 yield ('name', self.__field_name, None) 1546 yield ('pad1', self.__field_pad1, None) 1547 yield ('name_len', self.__field_name_len, None) 1548 yield ('phonenumbertype', self.__field_phonenumbertype, "1: Home, 2: Work, ...") 1549 yield ('phonenumberslot', self.__field_phonenumberslot, None) 1550 yield ('serial', self.__field_serial, None)

1551 1552 1553 1554

1555 -class callalarmresponse(BaseProtogenClass):

1556 __fields=['header', 'entry', 'pad'] 1557

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

1559 dict={} 1560 # What was supplied to this function 1561 dict.update(kwargs) 1562 # Parent constructor 1563 super(callalarmresponse,self).__init__(**dict) 1564 if self.__class__ is callalarmresponse: 1565 self._update(args,dict)

1566 1567

1568 - def getfields(self):

1569 return self.__fields

1570 1571

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

1573 super(callalarmresponse,self)._update(args,kwargs) 1574 keys=kwargs.keys() 1575 for key in keys: 1576 if key in self.__fields: 1577 setattr(self, key, kwargs[key]) 1578 del kwargs[key] 1579 # Were any unrecognized kwargs passed in? 1580 if __debug__: 1581 self._complainaboutunusedargs(callalarmresponse,kwargs) 1582 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

1583 # Make all P fields that haven't already been constructed 1584 1585

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

1587 'Writes this packet to the supplied buffer' 1588 self._bufferstartoffset=buf.getcurrentoffset() 1589 self.__field_header.writetobuffer(buf) 1590 self.__field_entry.writetobuffer(buf) 1591 self.__field_pad.writetobuffer(buf) 1592 self._bufferendoffset=buf.getcurrentoffset() 1593 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1594 1595

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

1597 'Reads this packet from the supplied buffer' 1598 self._bufferstartoffset=buf.getcurrentoffset() 1599 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1600 self.__field_header=sanyoheader() 1601 self.__field_header.readfrombuffer(buf) 1602 self.__field_entry=callalarmentry() 1603 self.__field_entry.readfrombuffer(buf) 1604 self.__field_pad=UNKNOWN() 1605 self.__field_pad.readfrombuffer(buf) 1606 self._bufferendoffset=buf.getcurrentoffset()

1607 1608

1609 - def __getfield_header(self):

1610 return self.__field_header.getvalue()

1611

1612 - def __setfield_header(self, value):

1613 if isinstance(value,sanyoheader): 1614 self.__field_header=value 1615 else: 1616 self.__field_header=sanyoheader(value,)

1617

1618 - def __delfield_header(self): del self.__field_header

1619 1620 header=property(__getfield_header, __setfield_header, __delfield_header, None) 1621

1622 - def __getfield_entry(self):

1623 return self.__field_entry.getvalue()

1624

1625 - def __setfield_entry(self, value):

1626 if isinstance(value,callalarmentry): 1627 self.__field_entry=value 1628 else: 1629 self.__field_entry=callalarmentry(value,)

1630

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

1632 1633 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 1634

1635 - def __getfield_pad(self):

1636 return self.__field_pad.getvalue()

1637

1638 - def __setfield_pad(self, value):

1639 if isinstance(value,UNKNOWN): 1640 self.__field_pad=value 1641 else: 1642 self.__field_pad=UNKNOWN(value,)

1643

1644 - def __delfield_pad(self): del self.__field_pad

1645 1646 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 1647

1648 - def iscontainer(self):

1649 return True

1650

1651 - def containerelements(self):

1652 yield ('header', self.__field_header, None) 1653 yield ('entry', self.__field_entry, None) 1654 yield ('pad', self.__field_pad, None)

1655 1656 1657 1658

1659 -class callalarmupdaterequest(BaseProtogenClass):

1660 __fields=['header', 'entry', 'pad'] 1661

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

1663 dict={} 1664 # What was supplied to this function 1665 dict.update(kwargs) 1666 # Parent constructor 1667 super(callalarmupdaterequest,self).__init__(**dict) 1668 if self.__class__ is callalarmupdaterequest: 1669 self._update(args,dict)

1670 1671

1672 - def getfields(self):

1673 return self.__fields

1674 1675

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

1677 super(callalarmupdaterequest,self)._update(args,kwargs) 1678 keys=kwargs.keys() 1679 for key in keys: 1680 if key in self.__fields: 1681 setattr(self, key, kwargs[key]) 1682 del kwargs[key] 1683 # Were any unrecognized kwargs passed in? 1684 if __debug__: 1685 self._complainaboutunusedargs(callalarmupdaterequest,kwargs) 1686 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

1687 # Make all P fields that haven't already been constructed 1688 1689

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

1691 'Writes this packet to the supplied buffer' 1692 self._bufferstartoffset=buf.getcurrentoffset() 1693 try: self.__field_header 1694 except: 1695 self.__field_header=sanyowriteheader(**{'packettype': 0x0c, 'command':0x24}) 1696 self.__field_header.writetobuffer(buf) 1697 self.__field_entry.writetobuffer(buf) 1698 try: self.__field_pad 1699 except: 1700 self.__field_pad=UNKNOWN(**{'sizeinbytes': 400}) 1701 self.__field_pad.writetobuffer(buf) 1702 self._bufferendoffset=buf.getcurrentoffset() 1703 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1704 1705

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

1707 'Reads this packet from the supplied buffer' 1708 self._bufferstartoffset=buf.getcurrentoffset() 1709 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1710 self.__field_header=sanyowriteheader(**{'packettype': 0x0c, 'command':0x24}) 1711 self.__field_header.readfrombuffer(buf) 1712 self.__field_entry=callalarmentry() 1713 self.__field_entry.readfrombuffer(buf) 1714 self.__field_pad=UNKNOWN(**{'sizeinbytes': 400}) 1715 self.__field_pad.readfrombuffer(buf) 1716 self._bufferendoffset=buf.getcurrentoffset()

1717 1718

1719 - def __getfield_header(self):

1720 try: self.__field_header 1721 except: 1722 self.__field_header=sanyowriteheader(**{'packettype': 0x0c, 'command':0x24}) 1723 return self.__field_header.getvalue()

1724

1725 - def __setfield_header(self, value):

1726 if isinstance(value,sanyowriteheader): 1727 self.__field_header=value 1728 else: 1729 self.__field_header=sanyowriteheader(value,**{'packettype': 0x0c, 'command':0x24})

1730

1731 - def __delfield_header(self): del self.__field_header

1732 1733 header=property(__getfield_header, __setfield_header, __delfield_header, None) 1734

1735 - def __getfield_entry(self):

1736 return self.__field_entry.getvalue()

1737

1738 - def __setfield_entry(self, value):

1739 if isinstance(value,callalarmentry): 1740 self.__field_entry=value 1741 else: 1742 self.__field_entry=callalarmentry(value,)

1743

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

1745 1746 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 1747

1748 - def __getfield_pad(self):

1749 try: self.__field_pad 1750 except: 1751 self.__field_pad=UNKNOWN(**{'sizeinbytes': 400}) 1752 return self.__field_pad.getvalue()

1753

1754 - def __setfield_pad(self, value):

1755 if isinstance(value,UNKNOWN): 1756 self.__field_pad=value 1757 else: 1758 self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 400})

1759

1760 - def __delfield_pad(self): del self.__field_pad

1761 1762 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 1763

1764 - def iscontainer(self):

1765 return True

1766

1767 - def containerelements(self):

1768 yield ('header', self.__field_header, None) 1769 yield ('entry', self.__field_entry, None) 1770 yield ('pad', self.__field_pad, None)

1771

Source Code for Module phones.p_sanyo8100_bell