phones.p_motov710

1 # THIS FILE IS AUTOMATICALLY GENERATED. EDIT THE SOURCE FILE NOT THIS ONE 2 3 """Various descriptions of data specific to Motorola phones""" 4 5 from prototypes import * 6 from prototypes_moto import * 7 from p_etsi import * 8 from p_moto import * 9 10 # We use LSB for all integer like fields 11 UINT=UINTlsb 12 BOOL=BOOLlsb 13 14 PB_TOTAL_GROUP=30 15 PB_GROUP_RANGE=xrange(1, PB_TOTAL_GROUP+1) 16 PB_GROUP_NAME_LEN=24 17 18 RT_BUILTIN=0x0C 19 RT_CUSTOM=0x0D 20 RT_INDEX_FILE='/MyToneDB.db' 21 RT_PATH='motorola/shared/audio' 22 23 WP_PATH='motorola/shared/picture' 24 WP_EXCLUDED_FILES=frozenset([]) 25 26 # Calendar const 27 CAL_TOTAL_ENTRIES=500 28 CAL_MAX_ENTRY=499 29 CAL_TOTAL_ENTRY_EXCEPTIONS=8 30 CAL_TITLE_LEN=64 31 32 CAL_REP_NONE=0 33 CAL_REP_DAILY=1 34 CAL_REP_WEEKLY=2 35 CAL_REP_MONTHLY=3 36 CAL_REP_MONTHLY_NTH=4 37 CAL_REP_YEARLY=5 38 39 CAL_ALARM_NOTIME='00:00' 40 CAL_ALARM_NODATE='00-00-2000' 41

42 -class group_count_req(BaseProtogenClass):

43 __fields=['command'] 44

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

46 dict={} 47 # What was supplied to this function 48 dict.update(kwargs) 49 # Parent constructor 50 super(group_count_req,self).__init__(**dict) 51 if self.__class__ is group_count_req: 52 self._update(args,dict)

53 54

55 - def getfields(self):

56 return self.__fields

57 58

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

60 super(group_count_req,self)._update(args,kwargs) 61 keys=kwargs.keys() 62 for key in keys: 63 if key in self.__fields: 64 setattr(self, key, kwargs[key]) 65 del kwargs[key] 66 # Were any unrecognized kwargs passed in? 67 if __debug__: 68 self._complainaboutunusedargs(group_count_req,kwargs) 69 if len(args): 70 dict2={ 'quotechar': None, 'terminator': None, 'default': '+MPGR=?' } 71 dict2.update(kwargs) 72 kwargs=dict2 73 self.__field_command=CSVSTRING(*args,**dict2)

74 # Make all P fields that haven't already been constructed 75 76

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

78 'Writes this packet to the supplied buffer' 79 self._bufferstartoffset=buf.getcurrentoffset() 80 try: self.__field_command 81 except: 82 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MPGR=?' }) 83 self.__field_command.writetobuffer(buf) 84 self._bufferendoffset=buf.getcurrentoffset() 85 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

86 87

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

89 'Reads this packet from the supplied buffer' 90 self._bufferstartoffset=buf.getcurrentoffset() 91 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 92 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MPGR=?' }) 93 self.__field_command.readfrombuffer(buf) 94 self._bufferendoffset=buf.getcurrentoffset()

95 96

97 - def __getfield_command(self):

98 try: self.__field_command 99 except: 100 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MPGR=?' }) 101 return self.__field_command.getvalue()

102

103 - def __setfield_command(self, value):

104 if isinstance(value,CSVSTRING): 105 self.__field_command=value 106 else: 107 self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None, 'default': '+MPGR=?' })

108

109 - def __delfield_command(self): del self.__field_command

110 111 command=property(__getfield_command, __setfield_command, __delfield_command, None) 112

113 - def iscontainer(self):

114 return True

115

116 - def containerelements(self):

117 yield ('command', self.__field_command, None)

118 119 120 121

122 -class group_count_resp(BaseProtogenClass):

123 __fields=['command', 'countstring', 'dontcare'] 124

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

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

133 134

135 - def getfields(self):

136 return self.__fields

137 138

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

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

150 # Make all P fields that haven't already been constructed 151 152

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

154 'Writes this packet to the supplied buffer' 155 self._bufferstartoffset=buf.getcurrentoffset() 156 self.__field_command.writetobuffer(buf) 157 self.__field_countstring.writetobuffer(buf) 158 self.__field_dontcare.writetobuffer(buf) 159 self._bufferendoffset=buf.getcurrentoffset() 160 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

161 162

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

164 'Reads this packet from the supplied buffer' 165 self._bufferstartoffset=buf.getcurrentoffset() 166 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 167 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': ord(' '), 'default': '+MPGR:' }) 168 self.__field_command.readfrombuffer(buf) 169 self.__field_countstring=CSVSTRING(**{ 'quotechar': None }) 170 self.__field_countstring.readfrombuffer(buf) 171 self.__field_dontcare=DATA() 172 self.__field_dontcare.readfrombuffer(buf) 173 self._bufferendoffset=buf.getcurrentoffset()

174 175

176 - def __getfield_command(self):

177 return self.__field_command.getvalue()

178

179 - def __setfield_command(self, value):

180 if isinstance(value,CSVSTRING): 181 self.__field_command=value 182 else: 183 self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': ord(' '), 'default': '+MPGR:' })

184

185 - def __delfield_command(self): del self.__field_command

186 187 command=property(__getfield_command, __setfield_command, __delfield_command, None) 188

189 - def __getfield_countstring(self):

190 return self.__field_countstring.getvalue()

191

192 - def __setfield_countstring(self, value):

193 if isinstance(value,CSVSTRING): 194 self.__field_countstring=value 195 else: 196 self.__field_countstring=CSVSTRING(value,**{ 'quotechar': None })

197

198 - def __delfield_countstring(self): del self.__field_countstring

199 200 countstring=property(__getfield_countstring, __setfield_countstring, __delfield_countstring, None) 201

202 - def __getfield_dontcare(self):

203 return self.__field_dontcare.getvalue()

204

205 - def __setfield_dontcare(self, value):

206 if isinstance(value,DATA): 207 self.__field_dontcare=value 208 else: 209 self.__field_dontcare=DATA(value,)

210

211 - def __delfield_dontcare(self): del self.__field_dontcare

212 213 dontcare=property(__getfield_dontcare, __setfield_dontcare, __delfield_dontcare, None) 214

215 - def iscontainer(self):

216 return True

217

218 - def containerelements(self):

219 yield ('command', self.__field_command, None) 220 yield ('countstring', self.__field_countstring, None) 221 yield ('dontcare', self.__field_dontcare, None)

222 223 224 225

226 -class read_group_req(BaseProtogenClass):

227 __fields=['command', 'start_index', 'end_index'] 228

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

230 dict={} 231 # What was supplied to this function 232 dict.update(kwargs) 233 # Parent constructor 234 super(read_group_req,self).__init__(**dict) 235 if self.__class__ is read_group_req: 236 self._update(args,dict)

237 238

239 - def getfields(self):

240 return self.__fields

241 242

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

244 super(read_group_req,self)._update(args,kwargs) 245 keys=kwargs.keys() 246 for key in keys: 247 if key in self.__fields: 248 setattr(self, key, kwargs[key]) 249 del kwargs[key] 250 # Were any unrecognized kwargs passed in? 251 if __debug__: 252 self._complainaboutunusedargs(read_group_req,kwargs) 253 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

254 # Make all P fields that haven't already been constructed 255 256

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

258 'Writes this packet to the supplied buffer' 259 self._bufferstartoffset=buf.getcurrentoffset() 260 try: self.__field_command 261 except: 262 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MPGR=' }) 263 self.__field_command.writetobuffer(buf) 264 try: self.__field_start_index 265 except: 266 self.__field_start_index=CSVINT(**{ 'default': 1 }) 267 self.__field_start_index.writetobuffer(buf) 268 try: self.__field_end_index 269 except: 270 self.__field_end_index=CSVINT(**{ 'terminator': None, 'default': PB_TOTAL_GROUP }) 271 self.__field_end_index.writetobuffer(buf) 272 self._bufferendoffset=buf.getcurrentoffset() 273 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

274 275

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

277 'Reads this packet from the supplied buffer' 278 self._bufferstartoffset=buf.getcurrentoffset() 279 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 280 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MPGR=' }) 281 self.__field_command.readfrombuffer(buf) 282 self.__field_start_index=CSVINT(**{ 'default': 1 }) 283 self.__field_start_index.readfrombuffer(buf) 284 self.__field_end_index=CSVINT(**{ 'terminator': None, 'default': PB_TOTAL_GROUP }) 285 self.__field_end_index.readfrombuffer(buf) 286 self._bufferendoffset=buf.getcurrentoffset()

287 288

289 - def __getfield_command(self):

290 try: self.__field_command 291 except: 292 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MPGR=' }) 293 return self.__field_command.getvalue()

294

295 - def __setfield_command(self, value):

296 if isinstance(value,CSVSTRING): 297 self.__field_command=value 298 else: 299 self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None, 'default': '+MPGR=' })

300

301 - def __delfield_command(self): del self.__field_command

302 303 command=property(__getfield_command, __setfield_command, __delfield_command, None) 304

305 - def __getfield_start_index(self):

306 try: self.__field_start_index 307 except: 308 self.__field_start_index=CSVINT(**{ 'default': 1 }) 309 return self.__field_start_index.getvalue()

310

311 - def __setfield_start_index(self, value):

312 if isinstance(value,CSVINT): 313 self.__field_start_index=value 314 else: 315 self.__field_start_index=CSVINT(value,**{ 'default': 1 })

316

317 - def __delfield_start_index(self): del self.__field_start_index

318 319 start_index=property(__getfield_start_index, __setfield_start_index, __delfield_start_index, None) 320

321 - def __getfield_end_index(self):

322 try: self.__field_end_index 323 except: 324 self.__field_end_index=CSVINT(**{ 'terminator': None, 'default': PB_TOTAL_GROUP }) 325 return self.__field_end_index.getvalue()

326

327 - def __setfield_end_index(self, value):

328 if isinstance(value,CSVINT): 329 self.__field_end_index=value 330 else: 331 self.__field_end_index=CSVINT(value,**{ 'terminator': None, 'default': PB_TOTAL_GROUP })

332

333 - def __delfield_end_index(self): del self.__field_end_index

334 335 end_index=property(__getfield_end_index, __setfield_end_index, __delfield_end_index, None) 336

337 - def iscontainer(self):

338 return True

339

340 - def containerelements(self):

341 yield ('command', self.__field_command, None) 342 yield ('start_index', self.__field_start_index, None) 343 yield ('end_index', self.__field_end_index, None)

344 345 346 347

348 -class read_group_resp(BaseProtogenClass):

349 __fields=['command', 'index', 'name', 'ringtone', 'dunno'] 350

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

352 dict={} 353 # What was supplied to this function 354 dict.update(kwargs) 355 # Parent constructor 356 super(read_group_resp,self).__init__(**dict) 357 if self.__class__ is read_group_resp: 358 self._update(args,dict)

359 360

361 - def getfields(self):

362 return self.__fields

363 364

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

366 super(read_group_resp,self)._update(args,kwargs) 367 keys=kwargs.keys() 368 for key in keys: 369 if key in self.__fields: 370 setattr(self, key, kwargs[key]) 371 del kwargs[key] 372 # Were any unrecognized kwargs passed in? 373 if __debug__: 374 self._complainaboutunusedargs(read_group_resp,kwargs) 375 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

376 # Make all P fields that haven't already been constructed 377 378

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

380 'Writes this packet to the supplied buffer' 381 self._bufferstartoffset=buf.getcurrentoffset() 382 self.__field_command.writetobuffer(buf) 383 self.__field_index.writetobuffer(buf) 384 self.__field_name.writetobuffer(buf) 385 self.__field_ringtone.writetobuffer(buf) 386 self.__field_dunno.writetobuffer(buf) 387 self._bufferendoffset=buf.getcurrentoffset() 388 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

389 390

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

392 'Reads this packet from the supplied buffer' 393 self._bufferstartoffset=buf.getcurrentoffset() 394 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 395 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': ord(' '), 'default': '+MPGR:' }) 396 self.__field_command.readfrombuffer(buf) 397 self.__field_index=CSVINT() 398 self.__field_index.readfrombuffer(buf) 399 self.__field_name=CSVSTRING() 400 self.__field_name.readfrombuffer(buf) 401 self.__field_ringtone=CSVINT() 402 self.__field_ringtone.readfrombuffer(buf) 403 self.__field_dunno=DATA() 404 self.__field_dunno.readfrombuffer(buf) 405 self._bufferendoffset=buf.getcurrentoffset()

406 407

408 - def __getfield_command(self):

409 return self.__field_command.getvalue()

410

411 - def __setfield_command(self, value):

412 if isinstance(value,CSVSTRING): 413 self.__field_command=value 414 else: 415 self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': ord(' '), 'default': '+MPGR:' })

416

417 - def __delfield_command(self): del self.__field_command

418 419 command=property(__getfield_command, __setfield_command, __delfield_command, None) 420

421 - def __getfield_index(self):

422 return self.__field_index.getvalue()

423

424 - def __setfield_index(self, value):

425 if isinstance(value,CSVINT): 426 self.__field_index=value 427 else: 428 self.__field_index=CSVINT(value,)

429

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

431 432 index=property(__getfield_index, __setfield_index, __delfield_index, None) 433

434 - def __getfield_name(self):

435 return self.__field_name.getvalue()

436

437 - def __setfield_name(self, value):

438 if isinstance(value,CSVSTRING): 439 self.__field_name=value 440 else: 441 self.__field_name=CSVSTRING(value,)

442

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

444 445 name=property(__getfield_name, __setfield_name, __delfield_name, None) 446

447 - def __getfield_ringtone(self):

448 return self.__field_ringtone.getvalue()

449

450 - def __setfield_ringtone(self, value):

451 if isinstance(value,CSVINT): 452 self.__field_ringtone=value 453 else: 454 self.__field_ringtone=CSVINT(value,)

455

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

457 458 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 459

460 - def __getfield_dunno(self):

461 return self.__field_dunno.getvalue()

462

463 - def __setfield_dunno(self, value):

464 if isinstance(value,DATA): 465 self.__field_dunno=value 466 else: 467 self.__field_dunno=DATA(value,)

468

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

470 471 dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None) 472

473 - def iscontainer(self):

474 return True

475

476 - def containerelements(self):

477 yield ('command', self.__field_command, None) 478 yield ('index', self.__field_index, None) 479 yield ('name', self.__field_name, None) 480 yield ('ringtone', self.__field_ringtone, None) 481 yield ('dunno', self.__field_dunno, None)

482 483 484 485

486 -class del_group_req(BaseProtogenClass):

487 __fields=['command', 'index'] 488

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

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

497 498

499 - def getfields(self):

500 return self.__fields

501 502

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

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

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

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

518 'Writes this packet to the supplied buffer' 519 self._bufferstartoffset=buf.getcurrentoffset() 520 try: self.__field_command 521 except: 522 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MPGW=' }) 523 self.__field_command.writetobuffer(buf) 524 self.__field_index.writetobuffer(buf) 525 self._bufferendoffset=buf.getcurrentoffset() 526 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

527 528

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

530 'Reads this packet from the supplied buffer' 531 self._bufferstartoffset=buf.getcurrentoffset() 532 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 533 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MPGW=' }) 534 self.__field_command.readfrombuffer(buf) 535 self.__field_index=CSVINT(**{ 'terminator': None }) 536 self.__field_index.readfrombuffer(buf) 537 self._bufferendoffset=buf.getcurrentoffset()

538 539

540 - def __getfield_command(self):

541 try: self.__field_command 542 except: 543 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MPGW=' }) 544 return self.__field_command.getvalue()

545

546 - def __setfield_command(self, value):

547 if isinstance(value,CSVSTRING): 548 self.__field_command=value 549 else: 550 self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None, 'default': '+MPGW=' })

551

552 - def __delfield_command(self): del self.__field_command

553 554 command=property(__getfield_command, __setfield_command, __delfield_command, None) 555

556 - def __getfield_index(self):

557 return self.__field_index.getvalue()

558

559 - def __setfield_index(self, value):

560 if isinstance(value,CSVINT): 561 self.__field_index=value 562 else: 563 self.__field_index=CSVINT(value,**{ 'terminator': None })

564

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

566 567 index=property(__getfield_index, __setfield_index, __delfield_index, None) 568

569 - def iscontainer(self):

570 return True

571

572 - def containerelements(self):

573 yield ('command', self.__field_command, None) 574 yield ('index', self.__field_index, None)

575 576 577 578

579 -class write_group_req(BaseProtogenClass):

580 __fields=['command', 'index', 'name', 'ringtone'] 581

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

583 dict={} 584 # What was supplied to this function 585 dict.update(kwargs) 586 # Parent constructor 587 super(write_group_req,self).__init__(**dict) 588 if self.__class__ is write_group_req: 589 self._update(args,dict)

590 591

592 - def getfields(self):

593 return self.__fields

594 595

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

597 super(write_group_req,self)._update(args,kwargs) 598 keys=kwargs.keys() 599 for key in keys: 600 if key in self.__fields: 601 setattr(self, key, kwargs[key]) 602 del kwargs[key] 603 # Were any unrecognized kwargs passed in? 604 if __debug__: 605 self._complainaboutunusedargs(write_group_req,kwargs) 606 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

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

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

611 'Writes this packet to the supplied buffer' 612 self._bufferstartoffset=buf.getcurrentoffset() 613 try: self.__field_command 614 except: 615 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MPGW=' }) 616 self.__field_command.writetobuffer(buf) 617 self.__field_index.writetobuffer(buf) 618 self.__field_name.writetobuffer(buf) 619 try: self.__field_ringtone 620 except: 621 self.__field_ringtone=CSVINT(**{ 'terminator': None, 'default': 255 }) 622 self.__field_ringtone.writetobuffer(buf) 623 self._bufferendoffset=buf.getcurrentoffset() 624 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

625 626

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

628 'Reads this packet from the supplied buffer' 629 self._bufferstartoffset=buf.getcurrentoffset() 630 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 631 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MPGW=' }) 632 self.__field_command.readfrombuffer(buf) 633 self.__field_index=CSVINT() 634 self.__field_index.readfrombuffer(buf) 635 self.__field_name=CSVSTRING(**{ 'maxsizeinbytes': PB_GROUP_NAME_LEN, 'raiseontruncate': False }) 636 self.__field_name.readfrombuffer(buf) 637 self.__field_ringtone=CSVINT(**{ 'terminator': None, 'default': 255 }) 638 self.__field_ringtone.readfrombuffer(buf) 639 self._bufferendoffset=buf.getcurrentoffset()

640 641

642 - def __getfield_command(self):

643 try: self.__field_command 644 except: 645 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MPGW=' }) 646 return self.__field_command.getvalue()

647

648 - def __setfield_command(self, value):

649 if isinstance(value,CSVSTRING): 650 self.__field_command=value 651 else: 652 self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None, 'default': '+MPGW=' })

653

654 - def __delfield_command(self): del self.__field_command

655 656 command=property(__getfield_command, __setfield_command, __delfield_command, None) 657

658 - def __getfield_index(self):

659 return self.__field_index.getvalue()

660

661 - def __setfield_index(self, value):

662 if isinstance(value,CSVINT): 663 self.__field_index=value 664 else: 665 self.__field_index=CSVINT(value,)

666

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

668 669 index=property(__getfield_index, __setfield_index, __delfield_index, None) 670

671 - def __getfield_name(self):

672 return self.__field_name.getvalue()

673

674 - def __setfield_name(self, value):

675 if isinstance(value,CSVSTRING): 676 self.__field_name=value 677 else: 678 self.__field_name=CSVSTRING(value,**{ 'maxsizeinbytes': PB_GROUP_NAME_LEN, 'raiseontruncate': False })

679

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

681 682 name=property(__getfield_name, __setfield_name, __delfield_name, None) 683

684 - def __getfield_ringtone(self):

685 try: self.__field_ringtone 686 except: 687 self.__field_ringtone=CSVINT(**{ 'terminator': None, 'default': 255 }) 688 return self.__field_ringtone.getvalue()

689

690 - def __setfield_ringtone(self, value):

691 if isinstance(value,CSVINT): 692 self.__field_ringtone=value 693 else: 694 self.__field_ringtone=CSVINT(value,**{ 'terminator': None, 'default': 255 })

695

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

697 698 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 699

700 - def iscontainer(self):

701 return True

702

703 - def containerelements(self):

704 yield ('command', self.__field_command, None) 705 yield ('index', self.__field_index, None) 706 yield ('name', self.__field_name, None) 707 yield ('ringtone', self.__field_ringtone, None)

708 709 710 711

712 -class ringtone_index_entry(BaseProtogenClass):

713 __fields=['read_mode', 'name', 'name', 'index', 'ringtone_type', 'dunno'] 714

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

716 dict={} 717 # What was supplied to this function 718 dict.update(kwargs) 719 # Parent constructor 720 super(ringtone_index_entry,self).__init__(**dict) 721 if self.__class__ is ringtone_index_entry: 722 self._update(args,dict)

723 724

725 - def getfields(self):

726 return self.__fields

727 728

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

730 super(ringtone_index_entry,self)._update(args,kwargs) 731 keys=kwargs.keys() 732 for key in keys: 733 if key in self.__fields: 734 setattr(self, key, kwargs[key]) 735 del kwargs[key] 736 # Were any unrecognized kwargs passed in? 737 if __debug__: 738 self._complainaboutunusedargs(ringtone_index_entry,kwargs) 739 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 740 # Make all P fields that haven't already been constructed 741 try: self.__field_read_mode 742 except: 743 self.__field_read_mode=BOOL(**{ 'default': True })

744 745

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

747 'Writes this packet to the supplied buffer' 748 self._bufferstartoffset=buf.getcurrentoffset() 749 if self.read_mode: 750 self.__field_name.writetobuffer(buf) 751 if not self.read_mode: 752 self.__field_name.writetobuffer(buf) 753 self.__field_index.writetobuffer(buf) 754 self.__field_ringtone_type.writetobuffer(buf) 755 try: self.__field_dunno 756 except: 757 self.__field_dunno=DATA(**{'sizeinbytes': 6, 'default': '' }) 758 self.__field_dunno.writetobuffer(buf) 759 self._bufferendoffset=buf.getcurrentoffset() 760 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

761 762

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

764 'Reads this packet from the supplied buffer' 765 self._bufferstartoffset=buf.getcurrentoffset() 766 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 767 if self.read_mode: 768 self.__field_name=DATA(**{'sizeinbytes': 508, 'pad': None }) 769 self.__field_name.readfrombuffer(buf) 770 if not self.read_mode: 771 self.__field_name=DATA(**{'sizeinbytes': 508}) 772 self.__field_name.readfrombuffer(buf) 773 self.__field_index=UINT(**{'sizeinbytes': 1}) 774 self.__field_index.readfrombuffer(buf) 775 self.__field_ringtone_type=UINT(**{'sizeinbytes': 1}) 776 self.__field_ringtone_type.readfrombuffer(buf) 777 self.__field_dunno=DATA(**{'sizeinbytes': 6, 'default': '' }) 778 self.__field_dunno.readfrombuffer(buf) 779 self._bufferendoffset=buf.getcurrentoffset()

780 781

782 - def __getfield_read_mode(self):

783 try: self.__field_read_mode 784 except: 785 self.__field_read_mode=BOOL(**{ 'default': True }) 786 return self.__field_read_mode.getvalue()

787

788 - def __setfield_read_mode(self, value):

789 if isinstance(value,BOOL): 790 self.__field_read_mode=value 791 else: 792 self.__field_read_mode=BOOL(value,**{ 'default': True })

793

794 - def __delfield_read_mode(self): del self.__field_read_mode

795 796 read_mode=property(__getfield_read_mode, __setfield_read_mode, __delfield_read_mode, None) 797

798 - def __getfield_name(self):

799 return self.__field_name.getvalue()

800

801 - def __setfield_name(self, value):

802 if isinstance(value,DATA): 803 self.__field_name=value 804 else: 805 self.__field_name=DATA(value,**{'sizeinbytes': 508, 'pad': None })

806

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

808 809 name=property(__getfield_name, __setfield_name, __delfield_name, None) 810

811 - def __getfield_name(self):

812 return self.__field_name.getvalue()

813

814 - def __setfield_name(self, value):

815 if isinstance(value,DATA): 816 self.__field_name=value 817 else: 818 self.__field_name=DATA(value,**{'sizeinbytes': 508})

819

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

821 822 name=property(__getfield_name, __setfield_name, __delfield_name, None) 823

824 - def __getfield_index(self):

825 return self.__field_index.getvalue()

826

827 - def __setfield_index(self, value):

828 if isinstance(value,UINT): 829 self.__field_index=value 830 else: 831 self.__field_index=UINT(value,**{'sizeinbytes': 1})

832

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

834 835 index=property(__getfield_index, __setfield_index, __delfield_index, None) 836

837 - def __getfield_ringtone_type(self):

838 return self.__field_ringtone_type.getvalue()

839

840 - def __setfield_ringtone_type(self, value):

841 if isinstance(value,UINT): 842 self.__field_ringtone_type=value 843 else: 844 self.__field_ringtone_type=UINT(value,**{'sizeinbytes': 1})

845

846 - def __delfield_ringtone_type(self): del self.__field_ringtone_type

847 848 ringtone_type=property(__getfield_ringtone_type, __setfield_ringtone_type, __delfield_ringtone_type, None) 849

850 - def __getfield_dunno(self):

851 try: self.__field_dunno 852 except: 853 self.__field_dunno=DATA(**{'sizeinbytes': 6, 'default': '' }) 854 return self.__field_dunno.getvalue()

855

856 - def __setfield_dunno(self, value):

857 if isinstance(value,DATA): 858 self.__field_dunno=value 859 else: 860 self.__field_dunno=DATA(value,**{'sizeinbytes': 6, 'default': '' })

861

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

863 864 dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None) 865

866 - def iscontainer(self):

867 return True

868

869 - def containerelements(self):

870 yield ('read_mode', self.__field_read_mode, None) 871 if self.read_mode: 872 yield ('name', self.__field_name, None) 873 if not self.read_mode: 874 yield ('name', self.__field_name, None) 875 yield ('index', self.__field_index, None) 876 yield ('ringtone_type', self.__field_ringtone_type, None) 877 yield ('dunno', self.__field_dunno, None)

878 879 880 881

882 -class ringtone_index_file(BaseProtogenClass):

883 __fields=['items'] 884

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

886 dict={} 887 # What was supplied to this function 888 dict.update(kwargs) 889 # Parent constructor 890 super(ringtone_index_file,self).__init__(**dict) 891 if self.__class__ is ringtone_index_file: 892 self._update(args,dict)

893 894

895 - def getfields(self):

896 return self.__fields

897 898

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

900 super(ringtone_index_file,self)._update(args,kwargs) 901 keys=kwargs.keys() 902 for key in keys: 903 if key in self.__fields: 904 setattr(self, key, kwargs[key]) 905 del kwargs[key] 906 # Were any unrecognized kwargs passed in? 907 if __debug__: 908 self._complainaboutunusedargs(ringtone_index_file,kwargs) 909 if len(args): 910 dict2={ 'elementclass': ringtone_index_entry, 'createdefault': True} 911 dict2.update(kwargs) 912 kwargs=dict2 913 self.__field_items=LIST(*args,**dict2)

914 # Make all P fields that haven't already been constructed 915 916

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

918 'Writes this packet to the supplied buffer' 919 self._bufferstartoffset=buf.getcurrentoffset() 920 try: self.__field_items 921 except: 922 self.__field_items=LIST(**{ 'elementclass': ringtone_index_entry, 'createdefault': True}) 923 self.__field_items.writetobuffer(buf) 924 self._bufferendoffset=buf.getcurrentoffset() 925 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

926 927

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

929 'Reads this packet from the supplied buffer' 930 self._bufferstartoffset=buf.getcurrentoffset() 931 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 932 self.__field_items=LIST(**{ 'elementclass': ringtone_index_entry, 'createdefault': True}) 933 self.__field_items.readfrombuffer(buf) 934 self._bufferendoffset=buf.getcurrentoffset()

935 936

937 - def __getfield_items(self):

938 try: self.__field_items 939 except: 940 self.__field_items=LIST(**{ 'elementclass': ringtone_index_entry, 'createdefault': True}) 941 return self.__field_items.getvalue()

942

943 - def __setfield_items(self, value):

944 if isinstance(value,LIST): 945 self.__field_items=value 946 else: 947 self.__field_items=LIST(value,**{ 'elementclass': ringtone_index_entry, 'createdefault': True})

948

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

950 951 items=property(__getfield_items, __setfield_items, __delfield_items, None) 952

953 - def iscontainer(self):

954 return True

955

956 - def containerelements(self):

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

958 959 960 961

962 -class calendar_lock_req(BaseProtogenClass):

963 __fields=['command', 'lock'] 964

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

966 dict={} 967 # What was supplied to this function 968 dict.update(kwargs) 969 # Parent constructor 970 super(calendar_lock_req,self).__init__(**dict) 971 if self.__class__ is calendar_lock_req: 972 self._update(args,dict)

973 974

975 - def getfields(self):

976 return self.__fields

977 978

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

980 super(calendar_lock_req,self)._update(args,kwargs) 981 keys=kwargs.keys() 982 for key in keys: 983 if key in self.__fields: 984 setattr(self, key, kwargs[key]) 985 del kwargs[key] 986 # Were any unrecognized kwargs passed in? 987 if __debug__: 988 self._complainaboutunusedargs(calendar_lock_req,kwargs) 989 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

990 # Make all P fields that haven't already been constructed 991 992

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

994 'Writes this packet to the supplied buffer' 995 self._bufferstartoffset=buf.getcurrentoffset() 996 try: self.__field_command 997 except: 998 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MDBL=' }) 999 self.__field_command.writetobuffer(buf) 1000 self.__field_lock.writetobuffer(buf) 1001 self._bufferendoffset=buf.getcurrentoffset() 1002 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1003 1004

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

1006 'Reads this packet from the supplied buffer' 1007 self._bufferstartoffset=buf.getcurrentoffset() 1008 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1009 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MDBL=' }) 1010 self.__field_command.readfrombuffer(buf) 1011 self.__field_lock=CSVINT(**{ 'terminator': None }) 1012 self.__field_lock.readfrombuffer(buf) 1013 self._bufferendoffset=buf.getcurrentoffset()

1014 1015

1016 - def __getfield_command(self):

1017 try: self.__field_command 1018 except: 1019 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MDBL=' }) 1020 return self.__field_command.getvalue()

1021

1022 - def __setfield_command(self, value):

1023 if isinstance(value,CSVSTRING): 1024 self.__field_command=value 1025 else: 1026 self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None, 'default': '+MDBL=' })

1027

1028 - def __delfield_command(self): del self.__field_command

1029 1030 command=property(__getfield_command, __setfield_command, __delfield_command, None) 1031

1032 - def __getfield_lock(self):

1033 return self.__field_lock.getvalue()

1034

1035 - def __setfield_lock(self, value):

1036 if isinstance(value,CSVINT): 1037 self.__field_lock=value 1038 else: 1039 self.__field_lock=CSVINT(value,**{ 'terminator': None })

1040

1041 - def __delfield_lock(self): del self.__field_lock

1042 1043 lock=property(__getfield_lock, __setfield_lock, __delfield_lock, None) 1044

1045 - def iscontainer(self):

1046 return True

1047

1048 - def containerelements(self):

1049 yield ('command', self.__field_command, None) 1050 yield ('lock', self.__field_lock, None)

1051 1052 1053 1054

1055 -class calendar_read_req(BaseProtogenClass):

1056 __fields=['command', 'start_index', 'end_index'] 1057

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

1059 dict={} 1060 # What was supplied to this function 1061 dict.update(kwargs) 1062 # Parent constructor 1063 super(calendar_read_req,self).__init__(**dict) 1064 if self.__class__ is calendar_read_req: 1065 self._update(args,dict)

1066 1067

1068 - def getfields(self):

1069 return self.__fields

1070 1071

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

1073 super(calendar_read_req,self)._update(args,kwargs) 1074 keys=kwargs.keys() 1075 for key in keys: 1076 if key in self.__fields: 1077 setattr(self, key, kwargs[key]) 1078 del kwargs[key] 1079 # Were any unrecognized kwargs passed in? 1080 if __debug__: 1081 self._complainaboutunusedargs(calendar_read_req,kwargs) 1082 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

1083 # Make all P fields that haven't already been constructed 1084 1085

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

1087 'Writes this packet to the supplied buffer' 1088 self._bufferstartoffset=buf.getcurrentoffset() 1089 try: self.__field_command 1090 except: 1091 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MDBR=' }) 1092 self.__field_command.writetobuffer(buf) 1093 try: self.__field_start_index 1094 except: 1095 self.__field_start_index=CSVINT(**{ 'default': 0 }) 1096 self.__field_start_index.writetobuffer(buf) 1097 try: self.__field_end_index 1098 except: 1099 self.__field_end_index=CSVINT(**{ 'terminator': None, 'default': CAL_MAX_ENTRY }) 1100 self.__field_end_index.writetobuffer(buf) 1101 self._bufferendoffset=buf.getcurrentoffset() 1102 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1103 1104

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

1106 'Reads this packet from the supplied buffer' 1107 self._bufferstartoffset=buf.getcurrentoffset() 1108 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1109 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MDBR=' }) 1110 self.__field_command.readfrombuffer(buf) 1111 self.__field_start_index=CSVINT(**{ 'default': 0 }) 1112 self.__field_start_index.readfrombuffer(buf) 1113 self.__field_end_index=CSVINT(**{ 'terminator': None, 'default': CAL_MAX_ENTRY }) 1114 self.__field_end_index.readfrombuffer(buf) 1115 self._bufferendoffset=buf.getcurrentoffset()

1116 1117

1118 - def __getfield_command(self):

1119 try: self.__field_command 1120 except: 1121 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MDBR=' }) 1122 return self.__field_command.getvalue()

1123

1124 - def __setfield_command(self, value):

1125 if isinstance(value,CSVSTRING): 1126 self.__field_command=value 1127 else: 1128 self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None, 'default': '+MDBR=' })

1129

1130 - def __delfield_command(self): del self.__field_command

1131 1132 command=property(__getfield_command, __setfield_command, __delfield_command, None) 1133

1134 - def __getfield_start_index(self):

1135 try: self.__field_start_index 1136 except: 1137 self.__field_start_index=CSVINT(**{ 'default': 0 }) 1138 return self.__field_start_index.getvalue()

1139

1140 - def __setfield_start_index(self, value):

1141 if isinstance(value,CSVINT): 1142 self.__field_start_index=value 1143 else: 1144 self.__field_start_index=CSVINT(value,**{ 'default': 0 })

1145

1146 - def __delfield_start_index(self): del self.__field_start_index

1147 1148 start_index=property(__getfield_start_index, __setfield_start_index, __delfield_start_index, None) 1149

1150 - def __getfield_end_index(self):

1151 try: self.__field_end_index 1152 except: 1153 self.__field_end_index=CSVINT(**{ 'terminator': None, 'default': CAL_MAX_ENTRY }) 1154 return self.__field_end_index.getvalue()

1155

1156 - def __setfield_end_index(self, value):

1157 if isinstance(value,CSVINT): 1158 self.__field_end_index=value 1159 else: 1160 self.__field_end_index=CSVINT(value,**{ 'terminator': None, 'default': CAL_MAX_ENTRY })

1161

1162 - def __delfield_end_index(self): del self.__field_end_index

1163 1164 end_index=property(__getfield_end_index, __setfield_end_index, __delfield_end_index, None) 1165

1166 - def iscontainer(self):

1167 return True

1168

1169 - def containerelements(self):

1170 yield ('command', self.__field_command, None) 1171 yield ('start_index', self.__field_start_index, None) 1172 yield ('end_index', self.__field_end_index, None)

1173 1174 1175 1176

1177 -class calendar_req_resp(BaseProtogenClass):

1178 __fields=['command', 'index', 'title', 'alarm_timed', 'alarm_enabled', 'start_time', 'start_date', 'duration', 'alarm_time', 'alarm_date', 'repeat_type', 'ex_event', 'ex_event_flag'] 1179

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

1181 dict={} 1182 # What was supplied to this function 1183 dict.update(kwargs) 1184 # Parent constructor 1185 super(calendar_req_resp,self).__init__(**dict) 1186 if self.__class__ is calendar_req_resp: 1187 self._update(args,dict)

1188 1189

1190 - def getfields(self):

1191 return self.__fields

1192 1193

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

1195 super(calendar_req_resp,self)._update(args,kwargs) 1196 keys=kwargs.keys() 1197 for key in keys: 1198 if key in self.__fields: 1199 setattr(self, key, kwargs[key]) 1200 del kwargs[key] 1201 # Were any unrecognized kwargs passed in? 1202 if __debug__: 1203 self._complainaboutunusedargs(calendar_req_resp,kwargs) 1204 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

1205 # Make all P fields that haven't already been constructed 1206 1207

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

1209 'Writes this packet to the supplied buffer' 1210 self._bufferstartoffset=buf.getcurrentoffset() 1211 self.__field_command.writetobuffer(buf) 1212 self.__field_index.writetobuffer(buf) 1213 if self.command=='+MDBR:': 1214 self.__field_title.writetobuffer(buf) 1215 self.__field_alarm_timed.writetobuffer(buf) 1216 self.__field_alarm_enabled.writetobuffer(buf) 1217 self.__field_start_time.writetobuffer(buf) 1218 self.__field_start_date.writetobuffer(buf) 1219 self.__field_duration.writetobuffer(buf) 1220 self.__field_alarm_time.writetobuffer(buf) 1221 self.__field_alarm_date.writetobuffer(buf) 1222 self.__field_repeat_type.writetobuffer(buf) 1223 if self.command=='+MDBRE:': 1224 self.__field_ex_event.writetobuffer(buf) 1225 self.__field_ex_event_flag.writetobuffer(buf) 1226 self._bufferendoffset=buf.getcurrentoffset() 1227 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1228 1229

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

1231 'Reads this packet from the supplied buffer' 1232 self._bufferstartoffset=buf.getcurrentoffset() 1233 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1234 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': ord(' '), 'default': '+MDBR:' }) 1235 self.__field_command.readfrombuffer(buf) 1236 self.__field_index=CSVINT() 1237 self.__field_index.readfrombuffer(buf) 1238 if self.command=='+MDBR:': 1239 self.__field_title=CSVSTRING() 1240 self.__field_title.readfrombuffer(buf) 1241 self.__field_alarm_timed=CSVINT() 1242 self.__field_alarm_timed.readfrombuffer(buf) 1243 self.__field_alarm_enabled=CSVINT() 1244 self.__field_alarm_enabled.readfrombuffer(buf) 1245 self.__field_start_time=CAL_TIME() 1246 self.__field_start_time.readfrombuffer(buf) 1247 self.__field_start_date=CAL_DATE() 1248 self.__field_start_date.readfrombuffer(buf) 1249 self.__field_duration=CSVINT() 1250 self.__field_duration.readfrombuffer(buf) 1251 self.__field_alarm_time=CAL_TIME() 1252 self.__field_alarm_time.readfrombuffer(buf) 1253 self.__field_alarm_date=CAL_DATE() 1254 self.__field_alarm_date.readfrombuffer(buf) 1255 self.__field_repeat_type=CSVINT(**{ 'terminator': None }) 1256 self.__field_repeat_type.readfrombuffer(buf) 1257 if self.command=='+MDBRE:': 1258 self.__field_ex_event=CSVINT() 1259 self.__field_ex_event.readfrombuffer(buf) 1260 self.__field_ex_event_flag=CSVINT(**{ 'terminator': None }) 1261 self.__field_ex_event_flag.readfrombuffer(buf) 1262 self._bufferendoffset=buf.getcurrentoffset()

1263 1264

1265 - def __getfield_command(self):

1266 return self.__field_command.getvalue()

1267

1268 - def __setfield_command(self, value):

1269 if isinstance(value,CSVSTRING): 1270 self.__field_command=value 1271 else: 1272 self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': ord(' '), 'default': '+MDBR:' })

1273

1274 - def __delfield_command(self): del self.__field_command

1275 1276 command=property(__getfield_command, __setfield_command, __delfield_command, None) 1277

1278 - def __getfield_index(self):

1279 return self.__field_index.getvalue()

1280

1281 - def __setfield_index(self, value):

1282 if isinstance(value,CSVINT): 1283 self.__field_index=value 1284 else: 1285 self.__field_index=CSVINT(value,)

1286

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

1288 1289 index=property(__getfield_index, __setfield_index, __delfield_index, None) 1290

1291 - def __getfield_title(self):

1292 return self.__field_title.getvalue()

1293

1294 - def __setfield_title(self, value):

1295 if isinstance(value,CSVSTRING): 1296 self.__field_title=value 1297 else: 1298 self.__field_title=CSVSTRING(value,)

1299

1300 - def __delfield_title(self): del self.__field_title

1301 1302 title=property(__getfield_title, __setfield_title, __delfield_title, None) 1303

1304 - def __getfield_alarm_timed(self):

1305 return self.__field_alarm_timed.getvalue()

1306

1307 - def __setfield_alarm_timed(self, value):

1308 if isinstance(value,CSVINT): 1309 self.__field_alarm_timed=value 1310 else: 1311 self.__field_alarm_timed=CSVINT(value,)

1312

1313 - def __delfield_alarm_timed(self): del self.__field_alarm_timed

1314 1315 alarm_timed=property(__getfield_alarm_timed, __setfield_alarm_timed, __delfield_alarm_timed, None) 1316

1317 - def __getfield_alarm_enabled(self):

1318 return self.__field_alarm_enabled.getvalue()

1319

1320 - def __setfield_alarm_enabled(self, value):

1321 if isinstance(value,CSVINT): 1322 self.__field_alarm_enabled=value 1323 else: 1324 self.__field_alarm_enabled=CSVINT(value,)

1325

1326 - def __delfield_alarm_enabled(self): del self.__field_alarm_enabled

1327 1328 alarm_enabled=property(__getfield_alarm_enabled, __setfield_alarm_enabled, __delfield_alarm_enabled, None) 1329

1330 - def __getfield_start_time(self):

1331 return self.__field_start_time.getvalue()

1332

1333 - def __setfield_start_time(self, value):

1334 if isinstance(value,CAL_TIME): 1335 self.__field_start_time=value 1336 else: 1337 self.__field_start_time=CAL_TIME(value,)

1338

1339 - def __delfield_start_time(self): del self.__field_start_time

1340 1341 start_time=property(__getfield_start_time, __setfield_start_time, __delfield_start_time, None) 1342

1343 - def __getfield_start_date(self):

1344 return self.__field_start_date.getvalue()

1345

1346 - def __setfield_start_date(self, value):

1347 if isinstance(value,CAL_DATE): 1348 self.__field_start_date=value 1349 else: 1350 self.__field_start_date=CAL_DATE(value,)

1351

1352 - def __delfield_start_date(self): del self.__field_start_date

1353 1354 start_date=property(__getfield_start_date, __setfield_start_date, __delfield_start_date, None) 1355

1356 - def __getfield_duration(self):

1357 return self.__field_duration.getvalue()

1358

1359 - def __setfield_duration(self, value):

1360 if isinstance(value,CSVINT): 1361 self.__field_duration=value 1362 else: 1363 self.__field_duration=CSVINT(value,)

1364

1365 - def __delfield_duration(self): del self.__field_duration

1366 1367 duration=property(__getfield_duration, __setfield_duration, __delfield_duration, None) 1368

1369 - def __getfield_alarm_time(self):

1370 return self.__field_alarm_time.getvalue()

1371

1372 - def __setfield_alarm_time(self, value):

1373 if isinstance(value,CAL_TIME): 1374 self.__field_alarm_time=value 1375 else: 1376 self.__field_alarm_time=CAL_TIME(value,)

1377

1378 - def __delfield_alarm_time(self): del self.__field_alarm_time

1379 1380 alarm_time=property(__getfield_alarm_time, __setfield_alarm_time, __delfield_alarm_time, None) 1381

1382 - def __getfield_alarm_date(self):

1383 return self.__field_alarm_date.getvalue()

1384

1385 - def __setfield_alarm_date(self, value):

1386 if isinstance(value,CAL_DATE): 1387 self.__field_alarm_date=value 1388 else: 1389 self.__field_alarm_date=CAL_DATE(value,)

1390

1391 - def __delfield_alarm_date(self): del self.__field_alarm_date

1392 1393 alarm_date=property(__getfield_alarm_date, __setfield_alarm_date, __delfield_alarm_date, None) 1394

1395 - def __getfield_repeat_type(self):

1396 return self.__field_repeat_type.getvalue()

1397

1398 - def __setfield_repeat_type(self, value):

1399 if isinstance(value,CSVINT): 1400 self.__field_repeat_type=value 1401 else: 1402 self.__field_repeat_type=CSVINT(value,**{ 'terminator': None })

1403

1404 - def __delfield_repeat_type(self): del self.__field_repeat_type

1405 1406 repeat_type=property(__getfield_repeat_type, __setfield_repeat_type, __delfield_repeat_type, None) 1407

1408 - def __getfield_ex_event(self):

1409 return self.__field_ex_event.getvalue()

1410

1411 - def __setfield_ex_event(self, value):

1412 if isinstance(value,CSVINT): 1413 self.__field_ex_event=value 1414 else: 1415 self.__field_ex_event=CSVINT(value,)

1416

1417 - def __delfield_ex_event(self): del self.__field_ex_event

1418 1419 ex_event=property(__getfield_ex_event, __setfield_ex_event, __delfield_ex_event, None) 1420

1421 - def __getfield_ex_event_flag(self):

1422 return self.__field_ex_event_flag.getvalue()

1423

1424 - def __setfield_ex_event_flag(self, value):

1425 if isinstance(value,CSVINT): 1426 self.__field_ex_event_flag=value 1427 else: 1428 self.__field_ex_event_flag=CSVINT(value,**{ 'terminator': None })

1429

1430 - def __delfield_ex_event_flag(self): del self.__field_ex_event_flag

1431 1432 ex_event_flag=property(__getfield_ex_event_flag, __setfield_ex_event_flag, __delfield_ex_event_flag, None) 1433

1434 - def iscontainer(self):

1435 return True

1436

1437 - def containerelements(self):

1438 yield ('command', self.__field_command, None) 1439 yield ('index', self.__field_index, None) 1440 if self.command=='+MDBR:': 1441 yield ('title', self.__field_title, None) 1442 yield ('alarm_timed', self.__field_alarm_timed, None) 1443 yield ('alarm_enabled', self.__field_alarm_enabled, None) 1444 yield ('start_time', self.__field_start_time, None) 1445 yield ('start_date', self.__field_start_date, None) 1446 yield ('duration', self.__field_duration, None) 1447 yield ('alarm_time', self.__field_alarm_time, None) 1448 yield ('alarm_date', self.__field_alarm_date, None) 1449 yield ('repeat_type', self.__field_repeat_type, None) 1450 if self.command=='+MDBRE:': 1451 yield ('ex_event', self.__field_ex_event, None) 1452 yield ('ex_event_flag', self.__field_ex_event_flag, None)

1453 1454 1455 1456

1457 -class calendar_write_req(BaseProtogenClass):

1458 __fields=['command', 'index', 'title', 'alarm_timed', 'alarm_enabled', 'start_time', 'start_date', 'duration', 'alarm_time', 'alarm_date', 'repeat_type'] 1459

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

1461 dict={} 1462 # What was supplied to this function 1463 dict.update(kwargs) 1464 # Parent constructor 1465 super(calendar_write_req,self).__init__(**dict) 1466 if self.__class__ is calendar_write_req: 1467 self._update(args,dict)

1468 1469

1470 - def getfields(self):

1471 return self.__fields

1472 1473

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

1475 super(calendar_write_req,self)._update(args,kwargs) 1476 keys=kwargs.keys() 1477 for key in keys: 1478 if key in self.__fields: 1479 setattr(self, key, kwargs[key]) 1480 del kwargs[key] 1481 # Were any unrecognized kwargs passed in? 1482 if __debug__: 1483 self._complainaboutunusedargs(calendar_write_req,kwargs) 1484 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

1485 # Make all P fields that haven't already been constructed 1486 1487

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

1489 'Writes this packet to the supplied buffer' 1490 self._bufferstartoffset=buf.getcurrentoffset() 1491 try: self.__field_command 1492 except: 1493 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MDBW=' }) 1494 self.__field_command.writetobuffer(buf) 1495 self.__field_index.writetobuffer(buf) 1496 self.__field_title.writetobuffer(buf) 1497 try: self.__field_alarm_timed 1498 except: 1499 self.__field_alarm_timed=CSVINT(**{ 'default': 0 }) 1500 self.__field_alarm_timed.writetobuffer(buf) 1501 try: self.__field_alarm_enabled 1502 except: 1503 self.__field_alarm_enabled=CSVINT(**{ 'default': 0 }) 1504 self.__field_alarm_enabled.writetobuffer(buf) 1505 self.__field_start_time.writetobuffer(buf) 1506 self.__field_start_date.writetobuffer(buf) 1507 self.__field_duration.writetobuffer(buf) 1508 self.__field_alarm_time.writetobuffer(buf) 1509 self.__field_alarm_date.writetobuffer(buf) 1510 try: self.__field_repeat_type 1511 except: 1512 self.__field_repeat_type=CSVINT(**{ 'terminator': None, 'default': 0 }) 1513 self.__field_repeat_type.writetobuffer(buf) 1514 self._bufferendoffset=buf.getcurrentoffset() 1515 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1516 1517

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

1519 'Reads this packet from the supplied buffer' 1520 self._bufferstartoffset=buf.getcurrentoffset() 1521 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1522 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MDBW=' }) 1523 self.__field_command.readfrombuffer(buf) 1524 self.__field_index=CSVINT() 1525 self.__field_index.readfrombuffer(buf) 1526 self.__field_title=CSVSTRING(**{'maxsizeinbytes': CAL_TITLE_LEN }) 1527 self.__field_title.readfrombuffer(buf) 1528 self.__field_alarm_timed=CSVINT(**{ 'default': 0 }) 1529 self.__field_alarm_timed.readfrombuffer(buf) 1530 self.__field_alarm_enabled=CSVINT(**{ 'default': 0 }) 1531 self.__field_alarm_enabled.readfrombuffer(buf) 1532 self.__field_start_time=CAL_TIME() 1533 self.__field_start_time.readfrombuffer(buf) 1534 self.__field_start_date=CAL_DATE() 1535 self.__field_start_date.readfrombuffer(buf) 1536 self.__field_duration=CSVINT() 1537 self.__field_duration.readfrombuffer(buf) 1538 self.__field_alarm_time=CAL_TIME() 1539 self.__field_alarm_time.readfrombuffer(buf) 1540 self.__field_alarm_date=CAL_DATE() 1541 self.__field_alarm_date.readfrombuffer(buf) 1542 self.__field_repeat_type=CSVINT(**{ 'terminator': None, 'default': 0 }) 1543 self.__field_repeat_type.readfrombuffer(buf) 1544 self._bufferendoffset=buf.getcurrentoffset()

1545 1546

1547 - def __getfield_command(self):

1548 try: self.__field_command 1549 except: 1550 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MDBW=' }) 1551 return self.__field_command.getvalue()

1552

1553 - def __setfield_command(self, value):

1554 if isinstance(value,CSVSTRING): 1555 self.__field_command=value 1556 else: 1557 self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None, 'default': '+MDBW=' })

1558

1559 - def __delfield_command(self): del self.__field_command

1560 1561 command=property(__getfield_command, __setfield_command, __delfield_command, None) 1562

1563 - def __getfield_index(self):

1564 return self.__field_index.getvalue()

1565

1566 - def __setfield_index(self, value):

1567 if isinstance(value,CSVINT): 1568 self.__field_index=value 1569 else: 1570 self.__field_index=CSVINT(value,)

1571

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

1573 1574 index=property(__getfield_index, __setfield_index, __delfield_index, None) 1575

1576 - def __getfield_title(self):

1577 return self.__field_title.getvalue()

1578

1579 - def __setfield_title(self, value):

1580 if isinstance(value,CSVSTRING): 1581 self.__field_title=value 1582 else: 1583 self.__field_title=CSVSTRING(value,**{'maxsizeinbytes': CAL_TITLE_LEN })

1584

1585 - def __delfield_title(self): del self.__field_title

1586 1587 title=property(__getfield_title, __setfield_title, __delfield_title, None) 1588

1589 - def __getfield_alarm_timed(self):

1590 try: self.__field_alarm_timed 1591 except: 1592 self.__field_alarm_timed=CSVINT(**{ 'default': 0 }) 1593 return self.__field_alarm_timed.getvalue()

1594

1595 - def __setfield_alarm_timed(self, value):

1596 if isinstance(value,CSVINT): 1597 self.__field_alarm_timed=value 1598 else: 1599 self.__field_alarm_timed=CSVINT(value,**{ 'default': 0 })

1600

1601 - def __delfield_alarm_timed(self): del self.__field_alarm_timed

1602 1603 alarm_timed=property(__getfield_alarm_timed, __setfield_alarm_timed, __delfield_alarm_timed, None) 1604

1605 - def __getfield_alarm_enabled(self):

1606 try: self.__field_alarm_enabled 1607 except: 1608 self.__field_alarm_enabled=CSVINT(**{ 'default': 0 }) 1609 return self.__field_alarm_enabled.getvalue()

1610

1611 - def __setfield_alarm_enabled(self, value):

1612 if isinstance(value,CSVINT): 1613 self.__field_alarm_enabled=value 1614 else: 1615 self.__field_alarm_enabled=CSVINT(value,**{ 'default': 0 })

1616

1617 - def __delfield_alarm_enabled(self): del self.__field_alarm_enabled

1618 1619 alarm_enabled=property(__getfield_alarm_enabled, __setfield_alarm_enabled, __delfield_alarm_enabled, None) 1620

1621 - def __getfield_start_time(self):

1622 return self.__field_start_time.getvalue()

1623

1624 - def __setfield_start_time(self, value):

1625 if isinstance(value,CAL_TIME): 1626 self.__field_start_time=value 1627 else: 1628 self.__field_start_time=CAL_TIME(value,)

1629

1630 - def __delfield_start_time(self): del self.__field_start_time

1631 1632 start_time=property(__getfield_start_time, __setfield_start_time, __delfield_start_time, None) 1633

1634 - def __getfield_start_date(self):

1635 return self.__field_start_date.getvalue()

1636

1637 - def __setfield_start_date(self, value):

1638 if isinstance(value,CAL_DATE): 1639 self.__field_start_date=value 1640 else: 1641 self.__field_start_date=CAL_DATE(value,)

1642

1643 - def __delfield_start_date(self): del self.__field_start_date

1644 1645 start_date=property(__getfield_start_date, __setfield_start_date, __delfield_start_date, None) 1646

1647 - def __getfield_duration(self):

1648 return self.__field_duration.getvalue()

1649

1650 - def __setfield_duration(self, value):

1651 if isinstance(value,CSVINT): 1652 self.__field_duration=value 1653 else: 1654 self.__field_duration=CSVINT(value,)

1655

1656 - def __delfield_duration(self): del self.__field_duration

1657 1658 duration=property(__getfield_duration, __setfield_duration, __delfield_duration, None) 1659

1660 - def __getfield_alarm_time(self):

1661 return self.__field_alarm_time.getvalue()

1662

1663 - def __setfield_alarm_time(self, value):

1664 if isinstance(value,CAL_TIME): 1665 self.__field_alarm_time=value 1666 else: 1667 self.__field_alarm_time=CAL_TIME(value,)

1668

1669 - def __delfield_alarm_time(self): del self.__field_alarm_time

1670 1671 alarm_time=property(__getfield_alarm_time, __setfield_alarm_time, __delfield_alarm_time, None) 1672

1673 - def __getfield_alarm_date(self):

1674 return self.__field_alarm_date.getvalue()

1675

1676 - def __setfield_alarm_date(self, value):

1677 if isinstance(value,CAL_DATE): 1678 self.__field_alarm_date=value 1679 else: 1680 self.__field_alarm_date=CAL_DATE(value,)

1681

1682 - def __delfield_alarm_date(self): del self.__field_alarm_date

1683 1684 alarm_date=property(__getfield_alarm_date, __setfield_alarm_date, __delfield_alarm_date, None) 1685

1686 - def __getfield_repeat_type(self):

1687 try: self.__field_repeat_type 1688 except: 1689 self.__field_repeat_type=CSVINT(**{ 'terminator': None, 'default': 0 }) 1690 return self.__field_repeat_type.getvalue()

1691

1692 - def __setfield_repeat_type(self, value):

1693 if isinstance(value,CSVINT): 1694 self.__field_repeat_type=value 1695 else: 1696 self.__field_repeat_type=CSVINT(value,**{ 'terminator': None, 'default': 0 })

1697

1698 - def __delfield_repeat_type(self): del self.__field_repeat_type

1699 1700 repeat_type=property(__getfield_repeat_type, __setfield_repeat_type, __delfield_repeat_type, None) 1701

1702 - def iscontainer(self):

1703 return True

1704

1705 - def containerelements(self):

1706 yield ('command', self.__field_command, None) 1707 yield ('index', self.__field_index, None) 1708 yield ('title', self.__field_title, None) 1709 yield ('alarm_timed', self.__field_alarm_timed, None) 1710 yield ('alarm_enabled', self.__field_alarm_enabled, None) 1711 yield ('start_time', self.__field_start_time, None) 1712 yield ('start_date', self.__field_start_date, None) 1713 yield ('duration', self.__field_duration, None) 1714 yield ('alarm_time', self.__field_alarm_time, None) 1715 yield ('alarm_date', self.__field_alarm_date, None) 1716 yield ('repeat_type', self.__field_repeat_type, None)

1717 1718 1719 1720

1721 -class calendar_write_ex_req(BaseProtogenClass):

1722 __fields=['command', 'index', 'nth_event', 'ex_event_flag'] 1723

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

1725 dict={} 1726 # What was supplied to this function 1727 dict.update(kwargs) 1728 # Parent constructor 1729 super(calendar_write_ex_req,self).__init__(**dict) 1730 if self.__class__ is calendar_write_ex_req: 1731 self._update(args,dict)

1732 1733

1734 - def getfields(self):

1735 return self.__fields

1736 1737

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

1739 super(calendar_write_ex_req,self)._update(args,kwargs) 1740 keys=kwargs.keys() 1741 for key in keys: 1742 if key in self.__fields: 1743 setattr(self, key, kwargs[key]) 1744 del kwargs[key] 1745 # Were any unrecognized kwargs passed in? 1746 if __debug__: 1747 self._complainaboutunusedargs(calendar_write_ex_req,kwargs) 1748 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

1749 # Make all P fields that haven't already been constructed 1750 1751

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

1753 'Writes this packet to the supplied buffer' 1754 self._bufferstartoffset=buf.getcurrentoffset() 1755 try: self.__field_command 1756 except: 1757 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MDBWE=' }) 1758 self.__field_command.writetobuffer(buf) 1759 self.__field_index.writetobuffer(buf) 1760 self.__field_nth_event.writetobuffer(buf) 1761 try: self.__field_ex_event_flag 1762 except: 1763 self.__field_ex_event_flag=CSVINT(**{ 'terminator': None, 'default': 1 }) 1764 self.__field_ex_event_flag.writetobuffer(buf) 1765 self._bufferendoffset=buf.getcurrentoffset() 1766 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1767 1768

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

1770 'Reads this packet from the supplied buffer' 1771 self._bufferstartoffset=buf.getcurrentoffset() 1772 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1773 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MDBWE=' }) 1774 self.__field_command.readfrombuffer(buf) 1775 self.__field_index=CSVINT() 1776 self.__field_index.readfrombuffer(buf) 1777 self.__field_nth_event=CSVINT() 1778 self.__field_nth_event.readfrombuffer(buf) 1779 self.__field_ex_event_flag=CSVINT(**{ 'terminator': None, 'default': 1 }) 1780 self.__field_ex_event_flag.readfrombuffer(buf) 1781 self._bufferendoffset=buf.getcurrentoffset()

1782 1783

1784 - def __getfield_command(self):

1785 try: self.__field_command 1786 except: 1787 self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None, 'default': '+MDBWE=' }) 1788 return self.__field_command.getvalue()

1789

1790 - def __setfield_command(self, value):

1791 if isinstance(value,CSVSTRING): 1792 self.__field_command=value 1793 else: 1794 self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None, 'default': '+MDBWE=' })

1795

1796 - def __delfield_command(self): del self.__field_command

1797 1798 command=property(__getfield_command, __setfield_command, __delfield_command, None) 1799

1800 - def __getfield_index(self):

1801 return self.__field_index.getvalue()

1802

1803 - def __setfield_index(self, value):

1804 if isinstance(value,CSVINT): 1805 self.__field_index=value 1806 else: 1807 self.__field_index=CSVINT(value,)

1808

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

1810 1811 index=property(__getfield_index, __setfield_index, __delfield_index, None) 1812

1813 - def __getfield_nth_event(self):

1814 return self.__field_nth_event.getvalue()

1815

1816 - def __setfield_nth_event(self, value):

1817 if isinstance(value,CSVINT): 1818 self.__field_nth_event=value 1819 else: 1820 self.__field_nth_event=CSVINT(value,)

1821

1822 - def __delfield_nth_event(self): del self.__field_nth_event

1823 1824 nth_event=property(__getfield_nth_event, __setfield_nth_event, __delfield_nth_event, None) 1825

1826 - def __getfield_ex_event_flag(self):

1827 try: self.__field_ex_event_flag 1828 except: 1829 self.__field_ex_event_flag=CSVINT(**{ 'terminator': None, 'default': 1 }) 1830 return self.__field_ex_event_flag.getvalue()

1831

1832 - def __setfield_ex_event_flag(self, value):

1833 if isinstance(value,CSVINT): 1834 self.__field_ex_event_flag=value 1835 else: 1836 self.__field_ex_event_flag=CSVINT(value,**{ 'terminator': None, 'default': 1 })

1837

1838 - def __delfield_ex_event_flag(self): del self.__field_ex_event_flag

1839 1840 ex_event_flag=property(__getfield_ex_event_flag, __setfield_ex_event_flag, __delfield_ex_event_flag, None) 1841

1842 - def iscontainer(self):

1843 return True

1844

1845 - def containerelements(self):

1846 yield ('command', self.__field_command, None) 1847 yield ('index', self.__field_index, None) 1848 yield ('nth_event', self.__field_nth_event, None) 1849 yield ('ex_event_flag', self.__field_ex_event_flag, None)

1850

Source Code for Module phones.p_motov710