Source Code for Module phones.p_moto

   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   
   9  # We use LSB for all integer like fields 
  10  UINT=UINTlsb 
  11  BOOL=BOOLlsb 
  12   
  13  # charset constant 
  14  CHARSET_8859_1="8859-1" 
  15  CHARSET_8859_A="8859-A" 
  16  CHARSET_8859_C="8859-C" 
  17  CHARSET_8859_H="8859-H" 
  18  CHARSET_ASCII="ASCII" 
  19  CHARSET_GSM="GSM" 
  20  CHARSET_KSC5601="KSC5601" 
  21  CHARSET_UCS2="UCS2" 
  22  CHARSET_UTF8="UTF8" 
  23   
  24  # phone mode constant 
  25  MODE_MODEM=0 
  26  MODE_PHONEBOOK=2 
  27  MODE_OBEX=22 
  28   
  29  # phonebook constant 
  30  PB_DIALED='DC' 
  31  PB_MISSED='MC' 
  32  PB_MAIN='AD' 
  33  PB_INCOMING='RC' 
  34  PB_QUICKDIAL='QD' 
  35   
  36  LOCAL_TYPE_LOCAL=129 
  37  LOCAL_TYPE_INTERNATIONAL=145 
  38  LOCAL_TYPE_UNKNOWN=128 
  39   
  40  NUMBER_TYPE_WORK=0 
  41  NUMBER_TYPE_HOME=1 
  42  NUMBER_TYPE_MAIN=2 
  43  NUMBER_TYPE_MOBILE=3 
  44  NUMBER_TYPE_FAX=4 
  45  NUMBER_TYPE_PAGER=5 
  46  NUMBER_TYPE_EMAIL=6 
  47  NUMBER_TYPE_MAILING_LIST=7 
  48  NUMBER_TYPE_MOBILE2=8 
  49  NUMBER_TYPE_EMAIL2=9 
  50  NUMBER_TYPE=frozenset([NUMBER_TYPE_WORK, NUMBER_TYPE_HOME, NUMBER_TYPE_MAIN, 
  51                         NUMBER_TYPE_MOBILE, NUMBER_TYPE_FAX, NUMBER_TYPE_PAGER, 
  52                         NUMBER_TYPE_MOBILE2]) 
  53  EMAIL_TYPE=frozenset([NUMBER_TYPE_EMAIL, NUMBER_TYPE_EMAIL2]) 
  54  NUMBER_TYPE_NAME={ 
  55      NUMBER_TYPE_WORK: 'office', 
  56      NUMBER_TYPE_HOME: 'home', 
  57      NUMBER_TYPE_MAIN: 'main', 
  58      NUMBER_TYPE_MOBILE: 'cell', 
  59      NUMBER_TYPE_FAX: 'fax', 
  60      NUMBER_TYPE_PAGER: 'pager', 
  61      NUMBER_TYPE_MOBILE2: 'cell', 
  62      } 
  63  NUMBER_TYPE_CODE={ 
  64      'office': NUMBER_TYPE_WORK, 
  65      'home': NUMBER_TYPE_HOME, 
  66      'main': NUMBER_TYPE_MAIN, 
  67      'cell': NUMBER_TYPE_MOBILE, 
  68      'fax': NUMBER_TYPE_FAX, 
  69      'pager': NUMBER_TYPE_PAGER } 
  70   
  71  PB_MAX_NUMBER_LEN=32 
  72  PB_MAX_NAME_LEN=24 
  73  PB_MAX_EMAIL_LEN=48 
  74   
  75  PB_TOTAL_ENTRIES=500 
  76  PB_RANGE=xrange(1,PB_TOTAL_ENTRIES+1) 
  77  PB_TOTAL_MISSED_CALLS=60 
  78  PB_TOTAL_DIALED_CALLS=60 
  79  PB_TOTAL_RECEIVED_CALLS=60 
  80   
  81  PB_TOTAL_GROUP=30 
  82  PB_GROUP_RANGE=xrange(1, PB_TOTAL_GROUP+1) 
  83  PB_GROUP_NAME_LEN=24 
  84   
  85  RT_BUILTIN=0x0C 
  86  RT_CUSTOM=0x0D 
  87  RT_INDEX_FILE='/MyToneDB.db' 
  88   
  89  # SMS Stuff 
  90  SMS_INBOX="IM" 
  91  SMS_OUTBOX="OM" 
  92  SMS_INFO="BM" 
  93  SMS_DRAFTS="DM" 
  94  SMS_COMBINE="MT" 
  95   
  96  SMS_REC_UNREAD="REC UNREAD" 
  97  SMS_REC_READ="REC READ" 
  98  SMS_STO_UNSENT="STO UNSENT" 
  99  SMS_STO_SENT="STO SENT" 
 100  SMS_ALL="ALL" 
 101  SMS_HEADER_ONLY="HEADER ONLY" 
 102   
 103  SMS_INDEX_RANGE=xrange(1, 353) 
 104   
 105 -class esnrequest(BaseProtogenClass): 
 106      __fields=['command'] 
 107   
 108 -    def __init__(self, *args, **kwargs): 
 109          dict={} 
 110          # What was supplied to this function 
 111          dict.update(kwargs) 
 112          # Parent constructor 
 113          super(esnrequest,self).__init__(**dict) 
 114          if self.__class__ is esnrequest: 
 115              self._update(args,dict) 
 116   
 117   
 118 -    def getfields(self): 
 119          return self.__fields 
 120   
 121   
 122 -    def _update(self, args, kwargs): 
 123          super(esnrequest,self)._update(args,kwargs) 
 124          keys=kwargs.keys() 
 125          for key in keys: 
 126              if key in self.__fields: 
 127                  setattr(self, key, kwargs[key]) 
 128                  del kwargs[key] 
 129          # Were any unrecognized kwargs passed in? 
 130          if __debug__: 
 131              self._complainaboutunusedargs(esnrequest,kwargs) 
 132          if len(args): 
 133              dict2={ 'quotechar': None, 'terminator': None,                  'default': '+CGSN' } 
 134              dict2.update(kwargs) 
 135              kwargs=dict2 
 136              self.__field_command=CSVSTRING(*args,**dict2) 
 137          # Make all P fields that haven't already been constructed 
 138   
 139   
 140 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 141          'Writes this packet to the supplied buffer' 
 142          self._bufferstartoffset=buf.getcurrentoffset() 
 143          try: self.__field_command 
 144          except: 
 145              self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+CGSN' }) 
 146          self.__field_command.writetobuffer(buf) 
 147          self._bufferendoffset=buf.getcurrentoffset() 
 148          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 149   
 150   
 151 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 152          'Reads this packet from the supplied buffer' 
 153          self._bufferstartoffset=buf.getcurrentoffset() 
 154          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 155          self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+CGSN' }) 
 156          self.__field_command.readfrombuffer(buf) 
 157          self._bufferendoffset=buf.getcurrentoffset() 
 158   
 159   
 160 -    def __getfield_command(self): 
 161          try: self.__field_command 
 162          except: 
 163              self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+CGSN' }) 
 164          return self.__field_command.getvalue() 
 165   
 166 -    def __setfield_command(self, value): 
 167          if isinstance(value,CSVSTRING): 
 168              self.__field_command=value 
 169          else: 
 170              self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None,                  'default': '+CGSN' }) 
 171   
 172 -    def __delfield_command(self): del self.__field_command 
 173   
 174      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
 175   
 176 -    def iscontainer(self): 
 177          return True 
 178   
 179 -    def containerelements(self): 
 180          yield ('command', self.__field_command, None) 
 181   
 182   
 183   
 184   
 185 -class esnresponse(BaseProtogenClass): 
 186      __fields=['command', 'esnlabel', 'esn'] 
 187   
 188 -    def __init__(self, *args, **kwargs): 
 189          dict={} 
 190          # What was supplied to this function 
 191          dict.update(kwargs) 
 192          # Parent constructor 
 193          super(esnresponse,self).__init__(**dict) 
 194          if self.__class__ is esnresponse: 
 195              self._update(args,dict) 
 196   
 197   
 198 -    def getfields(self): 
 199          return self.__fields 
 200   
 201   
 202 -    def _update(self, args, kwargs): 
 203          super(esnresponse,self)._update(args,kwargs) 
 204          keys=kwargs.keys() 
 205          for key in keys: 
 206              if key in self.__fields: 
 207                  setattr(self, key, kwargs[key]) 
 208                  del kwargs[key] 
 209          # Were any unrecognized kwargs passed in? 
 210          if __debug__: 
 211              self._complainaboutunusedargs(esnresponse,kwargs) 
 212          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 213          # Make all P fields that haven't already been constructed 
 214   
 215   
 216 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 217          'Writes this packet to the supplied buffer' 
 218          self._bufferstartoffset=buf.getcurrentoffset() 
 219          self.__field_command.writetobuffer(buf) 
 220          self.__field_esnlabel.writetobuffer(buf) 
 221          self.__field_esn.writetobuffer(buf) 
 222          self._bufferendoffset=buf.getcurrentoffset() 
 223          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 224   
 225   
 226 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 227          'Reads this packet from the supplied buffer' 
 228          self._bufferstartoffset=buf.getcurrentoffset() 
 229          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 230          self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': ord(' '),                  'default': '+CGSN:' }) 
 231          self.__field_command.readfrombuffer(buf) 
 232          self.__field_esnlabel=DATA(**{'sizeinbytes': 3}) 
 233          self.__field_esnlabel.readfrombuffer(buf) 
 234          self.__field_esn=CSVSTRING(**{ 'quotechar': None, 'terminator': None }) 
 235          self.__field_esn.readfrombuffer(buf) 
 236          self._bufferendoffset=buf.getcurrentoffset() 
 237   
 238   
 239 -    def __getfield_command(self): 
 240          return self.__field_command.getvalue() 
 241   
 242 -    def __setfield_command(self, value): 
 243          if isinstance(value,CSVSTRING): 
 244              self.__field_command=value 
 245          else: 
 246              self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': ord(' '),                  'default': '+CGSN:' }) 
 247   
 248 -    def __delfield_command(self): del self.__field_command 
 249   
 250      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
 251   
 252 -    def __getfield_esnlabel(self): 
 253          return self.__field_esnlabel.getvalue() 
 254   
 255 -    def __setfield_esnlabel(self, value): 
 256          if isinstance(value,DATA): 
 257              self.__field_esnlabel=value 
 258          else: 
 259              self.__field_esnlabel=DATA(value,**{'sizeinbytes': 3}) 
 260   
 261 -    def __delfield_esnlabel(self): del self.__field_esnlabel 
 262   
 263      esnlabel=property(__getfield_esnlabel, __setfield_esnlabel, __delfield_esnlabel, None) 
 264   
 265 -    def __getfield_esn(self): 
 266          return self.__field_esn.getvalue() 
 267   
 268 -    def __setfield_esn(self, value): 
 269          if isinstance(value,CSVSTRING): 
 270              self.__field_esn=value 
 271          else: 
 272              self.__field_esn=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None }) 
 273   
 274 -    def __delfield_esn(self): del self.__field_esn 
 275   
 276      esn=property(__getfield_esn, __setfield_esn, __delfield_esn, None) 
 277   
 278 -    def iscontainer(self): 
 279          return True 
 280   
 281 -    def containerelements(self): 
 282          yield ('command', self.__field_command, None) 
 283          yield ('esnlabel', self.__field_esnlabel, None) 
 284          yield ('esn', self.__field_esn, None) 
 285   
 286   
 287   
 288   
 289 -class string_resp(BaseProtogenClass): 
 290      __fields=['command', 'value'] 
 291   
 292 -    def __init__(self, *args, **kwargs): 
 293          dict={} 
 294          # What was supplied to this function 
 295          dict.update(kwargs) 
 296          # Parent constructor 
 297          super(string_resp,self).__init__(**dict) 
 298          if self.__class__ is string_resp: 
 299              self._update(args,dict) 
 300   
 301   
 302 -    def getfields(self): 
 303          return self.__fields 
 304   
 305   
 306 -    def _update(self, args, kwargs): 
 307          super(string_resp,self)._update(args,kwargs) 
 308          keys=kwargs.keys() 
 309          for key in keys: 
 310              if key in self.__fields: 
 311                  setattr(self, key, kwargs[key]) 
 312                  del kwargs[key] 
 313          # Were any unrecognized kwargs passed in? 
 314          if __debug__: 
 315              self._complainaboutunusedargs(string_resp,kwargs) 
 316          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 317          # Make all P fields that haven't already been constructed 
 318   
 319   
 320 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 321          'Writes this packet to the supplied buffer' 
 322          self._bufferstartoffset=buf.getcurrentoffset() 
 323          self.__field_command.writetobuffer(buf) 
 324          self.__field_value.writetobuffer(buf) 
 325          self._bufferendoffset=buf.getcurrentoffset() 
 326          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 327   
 328   
 329 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 330          'Reads this packet from the supplied buffer' 
 331          self._bufferstartoffset=buf.getcurrentoffset() 
 332          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 333          self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': ord(' ') }) 
 334          self.__field_command.readfrombuffer(buf) 
 335          self.__field_value=CSVSTRING(**{ 'quotechar': None,                  'terminator': None }) 
 336          self.__field_value.readfrombuffer(buf) 
 337          self._bufferendoffset=buf.getcurrentoffset() 
 338   
 339   
 340 -    def __getfield_command(self): 
 341          return self.__field_command.getvalue() 
 342   
 343 -    def __setfield_command(self, value): 
 344          if isinstance(value,CSVSTRING): 
 345              self.__field_command=value 
 346          else: 
 347              self.__field_command=CSVSTRING(value,**{ 'quotechar': None,                  'terminator': ord(' ') }) 
 348   
 349 -    def __delfield_command(self): del self.__field_command 
 350   
 351      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
 352   
 353 -    def __getfield_value(self): 
 354          return self.__field_value.getvalue() 
 355   
 356 -    def __setfield_value(self, value): 
 357          if isinstance(value,CSVSTRING): 
 358              self.__field_value=value 
 359          else: 
 360              self.__field_value=CSVSTRING(value,**{ 'quotechar': None,                  'terminator': None }) 
 361   
 362 -    def __delfield_value(self): del self.__field_value 
 363   
 364      value=property(__getfield_value, __setfield_value, __delfield_value, None) 
 365   
 366 -    def iscontainer(self): 
 367          return True 
 368   
 369 -    def containerelements(self): 
 370          yield ('command', self.__field_command, None) 
 371          yield ('value', self.__field_value, None) 
 372   
 373   
 374   
 375   
 376 -class manufacturer_req(BaseProtogenClass): 
 377      __fields=['command'] 
 378   
 379 -    def __init__(self, *args, **kwargs): 
 380          dict={} 
 381          # What was supplied to this function 
 382          dict.update(kwargs) 
 383          # Parent constructor 
 384          super(manufacturer_req,self).__init__(**dict) 
 385          if self.__class__ is manufacturer_req: 
 386              self._update(args,dict) 
 387   
 388   
 389 -    def getfields(self): 
 390          return self.__fields 
 391   
 392   
 393 -    def _update(self, args, kwargs): 
 394          super(manufacturer_req,self)._update(args,kwargs) 
 395          keys=kwargs.keys() 
 396          for key in keys: 
 397              if key in self.__fields: 
 398                  setattr(self, key, kwargs[key]) 
 399                  del kwargs[key] 
 400          # Were any unrecognized kwargs passed in? 
 401          if __debug__: 
 402              self._complainaboutunusedargs(manufacturer_req,kwargs) 
 403          if len(args): 
 404              dict2={ 'quotechar': None, 'terminator': None,                  'default': '+GMI' } 
 405              dict2.update(kwargs) 
 406              kwargs=dict2 
 407              self.__field_command=CSVSTRING(*args,**dict2) 
 408          # Make all P fields that haven't already been constructed 
 409   
 410   
 411 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 412          'Writes this packet to the supplied buffer' 
 413          self._bufferstartoffset=buf.getcurrentoffset() 
 414          try: self.__field_command 
 415          except: 
 416              self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+GMI' }) 
 417          self.__field_command.writetobuffer(buf) 
 418          self._bufferendoffset=buf.getcurrentoffset() 
 419          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 420   
 421   
 422 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 423          'Reads this packet from the supplied buffer' 
 424          self._bufferstartoffset=buf.getcurrentoffset() 
 425          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 426          self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+GMI' }) 
 427          self.__field_command.readfrombuffer(buf) 
 428          self._bufferendoffset=buf.getcurrentoffset() 
 429   
 430   
 431 -    def __getfield_command(self): 
 432          try: self.__field_command 
 433          except: 
 434              self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+GMI' }) 
 435          return self.__field_command.getvalue() 
 436   
 437 -    def __setfield_command(self, value): 
 438          if isinstance(value,CSVSTRING): 
 439              self.__field_command=value 
 440          else: 
 441              self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None,                  'default': '+GMI' }) 
 442   
 443 -    def __delfield_command(self): del self.__field_command 
 444   
 445      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
 446   
 447 -    def iscontainer(self): 
 448          return True 
 449   
 450 -    def containerelements(self): 
 451          yield ('command', self.__field_command, None) 
 452   
 453   
 454   
 455   
 456 -class model_req(BaseProtogenClass): 
 457      __fields=['command'] 
 458   
 459 -    def __init__(self, *args, **kwargs): 
 460          dict={} 
 461          # What was supplied to this function 
 462          dict.update(kwargs) 
 463          # Parent constructor 
 464          super(model_req,self).__init__(**dict) 
 465          if self.__class__ is model_req: 
 466              self._update(args,dict) 
 467   
 468   
 469 -    def getfields(self): 
 470          return self.__fields 
 471   
 472   
 473 -    def _update(self, args, kwargs): 
 474          super(model_req,self)._update(args,kwargs) 
 475          keys=kwargs.keys() 
 476          for key in keys: 
 477              if key in self.__fields: 
 478                  setattr(self, key, kwargs[key]) 
 479                  del kwargs[key] 
 480          # Were any unrecognized kwargs passed in? 
 481          if __debug__: 
 482              self._complainaboutunusedargs(model_req,kwargs) 
 483          if len(args): 
 484              dict2={ 'quotechar': None, 'terminator': None,                  'default': '+GMM' } 
 485              dict2.update(kwargs) 
 486              kwargs=dict2 
 487              self.__field_command=CSVSTRING(*args,**dict2) 
 488          # Make all P fields that haven't already been constructed 
 489   
 490   
 491 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 492          'Writes this packet to the supplied buffer' 
 493          self._bufferstartoffset=buf.getcurrentoffset() 
 494          try: self.__field_command 
 495          except: 
 496              self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+GMM' }) 
 497          self.__field_command.writetobuffer(buf) 
 498          self._bufferendoffset=buf.getcurrentoffset() 
 499          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 500   
 501   
 502 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 503          'Reads this packet from the supplied buffer' 
 504          self._bufferstartoffset=buf.getcurrentoffset() 
 505          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 506          self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+GMM' }) 
 507          self.__field_command.readfrombuffer(buf) 
 508          self._bufferendoffset=buf.getcurrentoffset() 
 509   
 510   
 511 -    def __getfield_command(self): 
 512          try: self.__field_command 
 513          except: 
 514              self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+GMM' }) 
 515          return self.__field_command.getvalue() 
 516   
 517 -    def __setfield_command(self, value): 
 518          if isinstance(value,CSVSTRING): 
 519              self.__field_command=value 
 520          else: 
 521              self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None,                  'default': '+GMM' }) 
 522   
 523 -    def __delfield_command(self): del self.__field_command 
 524   
 525      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
 526   
 527 -    def iscontainer(self): 
 528          return True 
 529   
 530 -    def containerelements(self): 
 531          yield ('command', self.__field_command, None) 
 532   
 533   
 534   
 535   
 536 -class number_req(BaseProtogenClass): 
 537      __fields=['command'] 
 538   
 539 -    def __init__(self, *args, **kwargs): 
 540          dict={} 
 541          # What was supplied to this function 
 542          dict.update(kwargs) 
 543          # Parent constructor 
 544          super(number_req,self).__init__(**dict) 
 545          if self.__class__ is number_req: 
 546              self._update(args,dict) 
 547   
 548   
 549 -    def getfields(self): 
 550          return self.__fields 
 551   
 552   
 553 -    def _update(self, args, kwargs): 
 554          super(number_req,self)._update(args,kwargs) 
 555          keys=kwargs.keys() 
 556          for key in keys: 
 557              if key in self.__fields: 
 558                  setattr(self, key, kwargs[key]) 
 559                  del kwargs[key] 
 560          # Were any unrecognized kwargs passed in? 
 561          if __debug__: 
 562              self._complainaboutunusedargs(number_req,kwargs) 
 563          if len(args): 
 564              dict2={ 'quotechar': None, 'terminator': None,                  'default': '+CNUM' } 
 565              dict2.update(kwargs) 
 566              kwargs=dict2 
 567              self.__field_command=CSVSTRING(*args,**dict2) 
 568          # Make all P fields that haven't already been constructed 
 569   
 570   
 571 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 572          'Writes this packet to the supplied buffer' 
 573          self._bufferstartoffset=buf.getcurrentoffset() 
 574          try: self.__field_command 
 575          except: 
 576              self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+CNUM' }) 
 577          self.__field_command.writetobuffer(buf) 
 578          self._bufferendoffset=buf.getcurrentoffset() 
 579          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 580   
 581   
 582 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 583          'Reads this packet from the supplied buffer' 
 584          self._bufferstartoffset=buf.getcurrentoffset() 
 585          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 586          self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+CNUM' }) 
 587          self.__field_command.readfrombuffer(buf) 
 588          self._bufferendoffset=buf.getcurrentoffset() 
 589   
 590   
 591 -    def __getfield_command(self): 
 592          try: self.__field_command 
 593          except: 
 594              self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+CNUM' }) 
 595          return self.__field_command.getvalue() 
 596   
 597 -    def __setfield_command(self, value): 
 598          if isinstance(value,CSVSTRING): 
 599              self.__field_command=value 
 600          else: 
 601              self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None,                  'default': '+CNUM' }) 
 602   
 603 -    def __delfield_command(self): del self.__field_command 
 604   
 605      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
 606   
 607 -    def iscontainer(self): 
 608          return True 
 609   
 610 -    def containerelements(self): 
 611          yield ('command', self.__field_command, None) 
 612   
 613   
 614   
 615   
 616 -class firmware_req(BaseProtogenClass): 
 617      __fields=['command'] 
 618   
 619 -    def __init__(self, *args, **kwargs): 
 620          dict={} 
 621          # What was supplied to this function 
 622          dict.update(kwargs) 
 623          # Parent constructor 
 624          super(firmware_req,self).__init__(**dict) 
 625          if self.__class__ is firmware_req: 
 626              self._update(args,dict) 
 627   
 628   
 629 -    def getfields(self): 
 630          return self.__fields 
 631   
 632   
 633 -    def _update(self, args, kwargs): 
 634          super(firmware_req,self)._update(args,kwargs) 
 635          keys=kwargs.keys() 
 636          for key in keys: 
 637              if key in self.__fields: 
 638                  setattr(self, key, kwargs[key]) 
 639                  del kwargs[key] 
 640          # Were any unrecognized kwargs passed in? 
 641          if __debug__: 
 642              self._complainaboutunusedargs(firmware_req,kwargs) 
 643          if len(args): 
 644              dict2={ 'quotechar': None, 'terminator': None,                  'default': '+GMR' } 
 645              dict2.update(kwargs) 
 646              kwargs=dict2 
 647              self.__field_command=CSVSTRING(*args,**dict2) 
 648          # Make all P fields that haven't already been constructed 
 649   
 650   
 651 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 652          'Writes this packet to the supplied buffer' 
 653          self._bufferstartoffset=buf.getcurrentoffset() 
 654          try: self.__field_command 
 655          except: 
 656              self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+GMR' }) 
 657          self.__field_command.writetobuffer(buf) 
 658          self._bufferendoffset=buf.getcurrentoffset() 
 659          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 660   
 661   
 662 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 663          'Reads this packet from the supplied buffer' 
 664          self._bufferstartoffset=buf.getcurrentoffset() 
 665          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 666          self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+GMR' }) 
 667          self.__field_command.readfrombuffer(buf) 
 668          self._bufferendoffset=buf.getcurrentoffset() 
 669   
 670   
 671 -    def __getfield_command(self): 
 672          try: self.__field_command 
 673          except: 
 674              self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+GMR' }) 
 675          return self.__field_command.getvalue() 
 676   
 677 -    def __setfield_command(self, value): 
 678          if isinstance(value,CSVSTRING): 
 679              self.__field_command=value 
 680          else: 
 681              self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None,                  'default': '+GMR' }) 
 682   
 683 -    def __delfield_command(self): del self.__field_command 
 684   
 685      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
 686   
 687 -    def iscontainer(self): 
 688          return True 
 689   
 690 -    def containerelements(self): 
 691          yield ('command', self.__field_command, None) 
 692   
 693   
 694   
 695   
 696 -class signal_req(BaseProtogenClass): 
 697      __fields=['command'] 
 698   
 699 -    def __init__(self, *args, **kwargs): 
 700          dict={} 
 701          # What was supplied to this function 
 702          dict.update(kwargs) 
 703          # Parent constructor 
 704          super(signal_req,self).__init__(**dict) 
 705          if self.__class__ is signal_req: 
 706              self._update(args,dict) 
 707   
 708   
 709 -    def getfields(self): 
 710          return self.__fields 
 711   
 712   
 713 -    def _update(self, args, kwargs): 
 714          super(signal_req,self)._update(args,kwargs) 
 715          keys=kwargs.keys() 
 716          for key in keys: 
 717              if key in self.__fields: 
 718                  setattr(self, key, kwargs[key]) 
 719                  del kwargs[key] 
 720          # Were any unrecognized kwargs passed in? 
 721          if __debug__: 
 722              self._complainaboutunusedargs(signal_req,kwargs) 
 723          if len(args): 
 724              dict2={ 'quotechar': None, 'terminator': None,                  'default': '+CSQ?' } 
 725              dict2.update(kwargs) 
 726              kwargs=dict2 
 727              self.__field_command=CSVSTRING(*args,**dict2) 
 728          # Make all P fields that haven't already been constructed 
 729   
 730   
 731 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 732          'Writes this packet to the supplied buffer' 
 733          self._bufferstartoffset=buf.getcurrentoffset() 
 734          try: self.__field_command 
 735          except: 
 736              self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+CSQ?' }) 
 737          self.__field_command.writetobuffer(buf) 
 738          self._bufferendoffset=buf.getcurrentoffset() 
 739          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 740   
 741   
 742 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 743          'Reads this packet from the supplied buffer' 
 744          self._bufferstartoffset=buf.getcurrentoffset() 
 745          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 746          self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+CSQ?' }) 
 747          self.__field_command.readfrombuffer(buf) 
 748          self._bufferendoffset=buf.getcurrentoffset() 
 749   
 750   
 751 -    def __getfield_command(self): 
 752          try: self.__field_command 
 753          except: 
 754              self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+CSQ?' }) 
 755          return self.__field_command.getvalue() 
 756   
 757 -    def __setfield_command(self, value): 
 758          if isinstance(value,CSVSTRING): 
 759              self.__field_command=value 
 760          else: 
 761              self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None,                  'default': '+CSQ?' }) 
 762   
 763 -    def __delfield_command(self): del self.__field_command 
 764   
 765      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
 766   
 767 -    def iscontainer(self): 
 768          return True 
 769   
 770 -    def containerelements(self): 
 771          yield ('command', self.__field_command, None) 
 772   
 773   
 774   
 775   
 776 -class signal_resp(BaseProtogenClass): 
 777      __fields=['command', 'rssi', 'ber'] 
 778   
 779 -    def __init__(self, *args, **kwargs): 
 780          dict={} 
 781          # What was supplied to this function 
 782          dict.update(kwargs) 
 783          # Parent constructor 
 784          super(signal_resp,self).__init__(**dict) 
 785          if self.__class__ is signal_resp: 
 786              self._update(args,dict) 
 787   
 788   
 789 -    def getfields(self): 
 790          return self.__fields 
 791   
 792   
 793 -    def _update(self, args, kwargs): 
 794          super(signal_resp,self)._update(args,kwargs) 
 795          keys=kwargs.keys() 
 796          for key in keys: 
 797              if key in self.__fields: 
 798                  setattr(self, key, kwargs[key]) 
 799                  del kwargs[key] 
 800          # Were any unrecognized kwargs passed in? 
 801          if __debug__: 
 802              self._complainaboutunusedargs(signal_resp,kwargs) 
 803          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 804          # Make all P fields that haven't already been constructed 
 805   
 806   
 807 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 808          'Writes this packet to the supplied buffer' 
 809          self._bufferstartoffset=buf.getcurrentoffset() 
 810          self.__field_command.writetobuffer(buf) 
 811          self.__field_rssi.writetobuffer(buf) 
 812          self.__field_ber.writetobuffer(buf) 
 813          self._bufferendoffset=buf.getcurrentoffset() 
 814          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 815   
 816   
 817 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 818          'Reads this packet from the supplied buffer' 
 819          self._bufferstartoffset=buf.getcurrentoffset() 
 820          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 821          self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': ord(' ') }) 
 822          self.__field_command.readfrombuffer(buf) 
 823          self.__field_rssi=CSVINT() 
 824          self.__field_rssi.readfrombuffer(buf) 
 825          self.__field_ber=CSVINT(**{ 'terminator': None }) 
 826          self.__field_ber.readfrombuffer(buf) 
 827          self._bufferendoffset=buf.getcurrentoffset() 
 828   
 829   
 830 -    def __getfield_command(self): 
 831          return self.__field_command.getvalue() 
 832   
 833 -    def __setfield_command(self, value): 
 834          if isinstance(value,CSVSTRING): 
 835              self.__field_command=value 
 836          else: 
 837              self.__field_command=CSVSTRING(value,**{ 'quotechar': None,                  'terminator': ord(' ') }) 
 838   
 839 -    def __delfield_command(self): del self.__field_command 
 840   
 841      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
 842   
 843 -    def __getfield_rssi(self): 
 844          return self.__field_rssi.getvalue() 
 845   
 846 -    def __setfield_rssi(self, value): 
 847          if isinstance(value,CSVINT): 
 848              self.__field_rssi=value 
 849          else: 
 850              self.__field_rssi=CSVINT(value,) 
 851   
 852 -    def __delfield_rssi(self): del self.__field_rssi 
 853   
 854      rssi=property(__getfield_rssi, __setfield_rssi, __delfield_rssi, None) 
 855   
 856 -    def __getfield_ber(self): 
 857          return self.__field_ber.getvalue() 
 858   
 859 -    def __setfield_ber(self, value): 
 860          if isinstance(value,CSVINT): 
 861              self.__field_ber=value 
 862          else: 
 863              self.__field_ber=CSVINT(value,**{ 'terminator': None }) 
 864   
 865 -    def __delfield_ber(self): del self.__field_ber 
 866   
 867      ber=property(__getfield_ber, __setfield_ber, __delfield_ber, None) 
 868   
 869 -    def iscontainer(self): 
 870          return True 
 871   
 872 -    def containerelements(self): 
 873          yield ('command', self.__field_command, None) 
 874          yield ('rssi', self.__field_rssi, None) 
 875          yield ('ber', self.__field_ber, None) 
 876   
 877   
 878   
 879   
 880 -class battery_req(BaseProtogenClass): 
 881      __fields=['command'] 
 882   
 883 -    def __init__(self, *args, **kwargs): 
 884          dict={} 
 885          # What was supplied to this function 
 886          dict.update(kwargs) 
 887          # Parent constructor 
 888          super(battery_req,self).__init__(**dict) 
 889          if self.__class__ is battery_req: 
 890              self._update(args,dict) 
 891   
 892   
 893 -    def getfields(self): 
 894          return self.__fields 
 895   
 896   
 897 -    def _update(self, args, kwargs): 
 898          super(battery_req,self)._update(args,kwargs) 
 899          keys=kwargs.keys() 
 900          for key in keys: 
 901              if key in self.__fields: 
 902                  setattr(self, key, kwargs[key]) 
 903                  del kwargs[key] 
 904          # Were any unrecognized kwargs passed in? 
 905          if __debug__: 
 906              self._complainaboutunusedargs(battery_req,kwargs) 
 907          if len(args): 
 908              dict2={ 'quotechar': None, 'terminator': None,                  'default': '+CBC' } 
 909              dict2.update(kwargs) 
 910              kwargs=dict2 
 911              self.__field_command=CSVSTRING(*args,**dict2) 
 912          # Make all P fields that haven't already been constructed 
 913   
 914   
 915 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 916          'Writes this packet to the supplied buffer' 
 917          self._bufferstartoffset=buf.getcurrentoffset() 
 918          try: self.__field_command 
 919          except: 
 920              self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+CBC' }) 
 921          self.__field_command.writetobuffer(buf) 
 922          self._bufferendoffset=buf.getcurrentoffset() 
 923          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 924   
 925   
 926 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 927          'Reads this packet from the supplied buffer' 
 928          self._bufferstartoffset=buf.getcurrentoffset() 
 929          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 930          self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+CBC' }) 
 931          self.__field_command.readfrombuffer(buf) 
 932          self._bufferendoffset=buf.getcurrentoffset() 
 933   
 934   
 935 -    def __getfield_command(self): 
 936          try: self.__field_command 
 937          except: 
 938              self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+CBC' }) 
 939          return self.__field_command.getvalue() 
 940   
 941 -    def __setfield_command(self, value): 
 942          if isinstance(value,CSVSTRING): 
 943              self.__field_command=value 
 944          else: 
 945              self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None,                  'default': '+CBC' }) 
 946   
 947 -    def __delfield_command(self): del self.__field_command 
 948   
 949      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
 950   
 951 -    def iscontainer(self): 
 952          return True 
 953   
 954 -    def containerelements(self): 
 955          yield ('command', self.__field_command, None) 
 956   
 957   
 958   
 959   
 960 -class battery_resp(BaseProtogenClass): 
 961      __fields=['command', 'status', 'level'] 
 962   
 963 -    def __init__(self, *args, **kwargs): 
 964          dict={} 
 965          # What was supplied to this function 
 966          dict.update(kwargs) 
 967          # Parent constructor 
 968          super(battery_resp,self).__init__(**dict) 
 969          if self.__class__ is battery_resp: 
 970              self._update(args,dict) 
 971   
 972   
 973 -    def getfields(self): 
 974          return self.__fields 
 975   
 976   
 977 -    def _update(self, args, kwargs): 
 978          super(battery_resp,self)._update(args,kwargs) 
 979          keys=kwargs.keys() 
 980          for key in keys: 
 981              if key in self.__fields: 
 982                  setattr(self, key, kwargs[key]) 
 983                  del kwargs[key] 
 984          # Were any unrecognized kwargs passed in? 
 985          if __debug__: 
 986              self._complainaboutunusedargs(battery_resp,kwargs) 
 987          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 988          # Make all P fields that haven't already been constructed 
 989   
 990   
 991 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 992          'Writes this packet to the supplied buffer' 
 993          self._bufferstartoffset=buf.getcurrentoffset() 
 994          self.__field_command.writetobuffer(buf) 
 995          self.__field_status.writetobuffer(buf) 
 996          self.__field_level.writetobuffer(buf) 
 997          self._bufferendoffset=buf.getcurrentoffset() 
 998          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 999   
1000   
1001 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1002          'Reads this packet from the supplied buffer' 
1003          self._bufferstartoffset=buf.getcurrentoffset() 
1004          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1005          self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': ord(' ') }) 
1006          self.__field_command.readfrombuffer(buf) 
1007          self.__field_status=CSVINT() 
1008          self.__field_status.readfrombuffer(buf) 
1009          self.__field_level=CSVINT(**{ 'terminator': None }) 
1010          self.__field_level.readfrombuffer(buf) 
1011          self._bufferendoffset=buf.getcurrentoffset() 
1012   
1013   
1014 -    def __getfield_command(self): 
1015          return self.__field_command.getvalue() 
1016   
1017 -    def __setfield_command(self, value): 
1018          if isinstance(value,CSVSTRING): 
1019              self.__field_command=value 
1020          else: 
1021              self.__field_command=CSVSTRING(value,**{ 'quotechar': None,                  'terminator': ord(' ') }) 
1022   
1023 -    def __delfield_command(self): del self.__field_command 
1024   
1025      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
1026   
1027 -    def __getfield_status(self): 
1028          return self.__field_status.getvalue() 
1029   
1030 -    def __setfield_status(self, value): 
1031          if isinstance(value,CSVINT): 
1032              self.__field_status=value 
1033          else: 
1034              self.__field_status=CSVINT(value,) 
1035   
1036 -    def __delfield_status(self): del self.__field_status 
1037   
1038      status=property(__getfield_status, __setfield_status, __delfield_status, None) 
1039   
1040 -    def __getfield_level(self): 
1041          return self.__field_level.getvalue() 
1042   
1043 -    def __setfield_level(self, value): 
1044          if isinstance(value,CSVINT): 
1045              self.__field_level=value 
1046          else: 
1047              self.__field_level=CSVINT(value,**{ 'terminator': None }) 
1048   
1049 -    def __delfield_level(self): del self.__field_level 
1050   
1051      level=property(__getfield_level, __setfield_level, __delfield_level, None) 
1052   
1053 -    def iscontainer(self): 
1054          return True 
1055   
1056 -    def containerelements(self): 
1057          yield ('command', self.__field_command, None) 
1058          yield ('status', self.__field_status, None) 
1059          yield ('level', self.__field_level, None) 
1060   
1061   
1062   
1063   
1064 -class modereq(BaseProtogenClass): 
1065      __fields=['command'] 
1066   
1067 -    def __init__(self, *args, **kwargs): 
1068          dict={} 
1069          # What was supplied to this function 
1070          dict.update(kwargs) 
1071          # Parent constructor 
1072          super(modereq,self).__init__(**dict) 
1073          if self.__class__ is modereq: 
1074              self._update(args,dict) 
1075   
1076   
1077 -    def getfields(self): 
1078          return self.__fields 
1079   
1080   
1081 -    def _update(self, args, kwargs): 
1082          super(modereq,self)._update(args,kwargs) 
1083          keys=kwargs.keys() 
1084          for key in keys: 
1085              if key in self.__fields: 
1086                  setattr(self, key, kwargs[key]) 
1087                  del kwargs[key] 
1088          # Were any unrecognized kwargs passed in? 
1089          if __debug__: 
1090              self._complainaboutunusedargs(modereq,kwargs) 
1091          if len(args): 
1092              dict2={ 'quotechar': None,                  'terminator': None, 'default': '+MODE?' } 
1093              dict2.update(kwargs) 
1094              kwargs=dict2 
1095              self.__field_command=CSVSTRING(*args,**dict2) 
1096          # Make all P fields that haven't already been constructed 
1097   
1098   
1099 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1100          'Writes this packet to the supplied buffer' 
1101          self._bufferstartoffset=buf.getcurrentoffset() 
1102          try: self.__field_command 
1103          except: 
1104              self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': None, 'default': '+MODE?' }) 
1105          self.__field_command.writetobuffer(buf) 
1106          self._bufferendoffset=buf.getcurrentoffset() 
1107          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1108   
1109   
1110 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1111          'Reads this packet from the supplied buffer' 
1112          self._bufferstartoffset=buf.getcurrentoffset() 
1113          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1114          self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': None, 'default': '+MODE?' }) 
1115          self.__field_command.readfrombuffer(buf) 
1116          self._bufferendoffset=buf.getcurrentoffset() 
1117   
1118   
1119 -    def __getfield_command(self): 
1120          try: self.__field_command 
1121          except: 
1122              self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': None, 'default': '+MODE?' }) 
1123          return self.__field_command.getvalue() 
1124   
1125 -    def __setfield_command(self, value): 
1126          if isinstance(value,CSVSTRING): 
1127              self.__field_command=value 
1128          else: 
1129              self.__field_command=CSVSTRING(value,**{ 'quotechar': None,                  'terminator': None, 'default': '+MODE?' }) 
1130   
1131 -    def __delfield_command(self): del self.__field_command 
1132   
1133      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
1134   
1135 -    def iscontainer(self): 
1136          return True 
1137   
1138 -    def containerelements(self): 
1139          yield ('command', self.__field_command, None) 
1140   
1141   
1142   
1143   
1144 -class moderesp(BaseProtogenClass): 
1145      __fields=['command', 'mode'] 
1146   
1147 -    def __init__(self, *args, **kwargs): 
1148          dict={} 
1149          # What was supplied to this function 
1150          dict.update(kwargs) 
1151          # Parent constructor 
1152          super(moderesp,self).__init__(**dict) 
1153          if self.__class__ is moderesp: 
1154              self._update(args,dict) 
1155   
1156   
1157 -    def getfields(self): 
1158          return self.__fields 
1159   
1160   
1161 -    def _update(self, args, kwargs): 
1162          super(moderesp,self)._update(args,kwargs) 
1163          keys=kwargs.keys() 
1164          for key in keys: 
1165              if key in self.__fields: 
1166                  setattr(self, key, kwargs[key]) 
1167                  del kwargs[key] 
1168          # Were any unrecognized kwargs passed in? 
1169          if __debug__: 
1170              self._complainaboutunusedargs(moderesp,kwargs) 
1171          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1172          # Make all P fields that haven't already been constructed 
1173   
1174   
1175 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1176          'Writes this packet to the supplied buffer' 
1177          self._bufferstartoffset=buf.getcurrentoffset() 
1178          self.__field_command.writetobuffer(buf) 
1179          self.__field_mode.writetobuffer(buf) 
1180          self._bufferendoffset=buf.getcurrentoffset() 
1181          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1182   
1183   
1184 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1185          'Reads this packet from the supplied buffer' 
1186          self._bufferstartoffset=buf.getcurrentoffset() 
1187          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1188          self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': ord(' '),                  'default': '+MODE:' }) 
1189          self.__field_command.readfrombuffer(buf) 
1190          self.__field_mode=CSVINT(**{ 'terminator': None }) 
1191          self.__field_mode.readfrombuffer(buf) 
1192          self._bufferendoffset=buf.getcurrentoffset() 
1193   
1194   
1195 -    def __getfield_command(self): 
1196          return self.__field_command.getvalue() 
1197   
1198 -    def __setfield_command(self, value): 
1199          if isinstance(value,CSVSTRING): 
1200              self.__field_command=value 
1201          else: 
1202              self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': ord(' '),                  'default': '+MODE:' }) 
1203   
1204 -    def __delfield_command(self): del self.__field_command 
1205   
1206      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
1207   
1208 -    def __getfield_mode(self): 
1209          return self.__field_mode.getvalue() 
1210   
1211 -    def __setfield_mode(self, value): 
1212          if isinstance(value,CSVINT): 
1213              self.__field_mode=value 
1214          else: 
1215              self.__field_mode=CSVINT(value,**{ 'terminator': None }) 
1216   
1217 -    def __delfield_mode(self): del self.__field_mode 
1218   
1219      mode=property(__getfield_mode, __setfield_mode, __delfield_mode, None) 
1220   
1221 -    def iscontainer(self): 
1222          return True 
1223   
1224 -    def containerelements(self): 
1225          yield ('command', self.__field_command, None) 
1226          yield ('mode', self.__field_mode, None) 
1227   
1228   
1229   
1230   
1231 -class modeset(BaseProtogenClass): 
1232      __fields=['command', 'mode'] 
1233   
1234 -    def __init__(self, *args, **kwargs): 
1235          dict={} 
1236          # What was supplied to this function 
1237          dict.update(kwargs) 
1238          # Parent constructor 
1239          super(modeset,self).__init__(**dict) 
1240          if self.__class__ is modeset: 
1241              self._update(args,dict) 
1242   
1243   
1244 -    def getfields(self): 
1245          return self.__fields 
1246   
1247   
1248 -    def _update(self, args, kwargs): 
1249          super(modeset,self)._update(args,kwargs) 
1250          keys=kwargs.keys() 
1251          for key in keys: 
1252              if key in self.__fields: 
1253                  setattr(self, key, kwargs[key]) 
1254                  del kwargs[key] 
1255          # Were any unrecognized kwargs passed in? 
1256          if __debug__: 
1257              self._complainaboutunusedargs(modeset,kwargs) 
1258          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1259          # Make all P fields that haven't already been constructed 
1260   
1261   
1262 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1263          'Writes this packet to the supplied buffer' 
1264          self._bufferstartoffset=buf.getcurrentoffset() 
1265          try: self.__field_command 
1266          except: 
1267              self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': None, 'default': '+MODE=' }) 
1268          self.__field_command.writetobuffer(buf) 
1269          try: self.__field_mode 
1270          except: 
1271              self.__field_mode=CSVINT(**{ 'terminator': None, 'default': 0 }) 
1272          self.__field_mode.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_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': None, 'default': '+MODE=' }) 
1282          self.__field_command.readfrombuffer(buf) 
1283          self.__field_mode=CSVINT(**{ 'terminator': None, 'default': 0 }) 
1284          self.__field_mode.readfrombuffer(buf) 
1285          self._bufferendoffset=buf.getcurrentoffset() 
1286   
1287   
1288 -    def __getfield_command(self): 
1289          try: self.__field_command 
1290          except: 
1291              self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': None, 'default': '+MODE=' }) 
1292          return self.__field_command.getvalue() 
1293   
1294 -    def __setfield_command(self, value): 
1295          if isinstance(value,CSVSTRING): 
1296              self.__field_command=value 
1297          else: 
1298              self.__field_command=CSVSTRING(value,**{ 'quotechar': None,                  'terminator': None, 'default': '+MODE=' }) 
1299   
1300 -    def __delfield_command(self): del self.__field_command 
1301   
1302      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
1303   
1304 -    def __getfield_mode(self): 
1305          try: self.__field_mode 
1306          except: 
1307              self.__field_mode=CSVINT(**{ 'terminator': None, 'default': 0 }) 
1308          return self.__field_mode.getvalue() 
1309   
1310 -    def __setfield_mode(self, value): 
1311          if isinstance(value,CSVINT): 
1312              self.__field_mode=value 
1313          else: 
1314              self.__field_mode=CSVINT(value,**{ 'terminator': None, 'default': 0 }) 
1315   
1316 -    def __delfield_mode(self): del self.__field_mode 
1317   
1318      mode=property(__getfield_mode, __setfield_mode, __delfield_mode, None) 
1319   
1320 -    def iscontainer(self): 
1321          return True 
1322   
1323 -    def containerelements(self): 
1324          yield ('command', self.__field_command, None) 
1325          yield ('mode', self.__field_mode, None) 
1326   
1327   
1328   
1329   
1330 -class charset_set_req(BaseProtogenClass): 
1331      __fields=['command', 'charset'] 
1332   
1333 -    def __init__(self, *args, **kwargs): 
1334          dict={} 
1335          # What was supplied to this function 
1336          dict.update(kwargs) 
1337          # Parent constructor 
1338          super(charset_set_req,self).__init__(**dict) 
1339          if self.__class__ is charset_set_req: 
1340              self._update(args,dict) 
1341   
1342   
1343 -    def getfields(self): 
1344          return self.__fields 
1345   
1346   
1347 -    def _update(self, args, kwargs): 
1348          super(charset_set_req,self)._update(args,kwargs) 
1349          keys=kwargs.keys() 
1350          for key in keys: 
1351              if key in self.__fields: 
1352                  setattr(self, key, kwargs[key]) 
1353                  del kwargs[key] 
1354          # Were any unrecognized kwargs passed in? 
1355          if __debug__: 
1356              self._complainaboutunusedargs(charset_set_req,kwargs) 
1357          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1358          # Make all P fields that haven't already been constructed 
1359   
1360   
1361 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1362          'Writes this packet to the supplied buffer' 
1363          self._bufferstartoffset=buf.getcurrentoffset() 
1364          try: self.__field_command 
1365          except: 
1366              self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': None, 'default': '+CSCS=' }) 
1367          self.__field_command.writetobuffer(buf) 
1368          try: self.__field_charset 
1369          except: 
1370              self.__field_charset=CSVSTRING(**{ 'terminator': None }) 
1371          self.__field_charset.writetobuffer(buf) 
1372          self._bufferendoffset=buf.getcurrentoffset() 
1373          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1374   
1375   
1376 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1377          'Reads this packet from the supplied buffer' 
1378          self._bufferstartoffset=buf.getcurrentoffset() 
1379          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1380          self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': None, 'default': '+CSCS=' }) 
1381          self.__field_command.readfrombuffer(buf) 
1382          self.__field_charset=CSVSTRING(**{ 'terminator': None }) 
1383          self.__field_charset.readfrombuffer(buf) 
1384          self._bufferendoffset=buf.getcurrentoffset() 
1385   
1386   
1387 -    def __getfield_command(self): 
1388          try: self.__field_command 
1389          except: 
1390              self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': None, 'default': '+CSCS=' }) 
1391          return self.__field_command.getvalue() 
1392   
1393 -    def __setfield_command(self, value): 
1394          if isinstance(value,CSVSTRING): 
1395              self.__field_command=value 
1396          else: 
1397              self.__field_command=CSVSTRING(value,**{ 'quotechar': None,                  'terminator': None, 'default': '+CSCS=' }) 
1398   
1399 -    def __delfield_command(self): del self.__field_command 
1400   
1401      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
1402   
1403 -    def __getfield_charset(self): 
1404          try: self.__field_charset 
1405          except: 
1406              self.__field_charset=CSVSTRING(**{ 'terminator': None }) 
1407          return self.__field_charset.getvalue() 
1408   
1409 -    def __setfield_charset(self, value): 
1410          if isinstance(value,CSVSTRING): 
1411              self.__field_charset=value 
1412          else: 
1413              self.__field_charset=CSVSTRING(value,**{ 'terminator': None }) 
1414   
1415 -    def __delfield_charset(self): del self.__field_charset 
1416   
1417      charset=property(__getfield_charset, __setfield_charset, __delfield_charset, None) 
1418   
1419 -    def iscontainer(self): 
1420          return True 
1421   
1422 -    def containerelements(self): 
1423          yield ('command', self.__field_command, None) 
1424          yield ('charset', self.__field_charset, None) 
1425   
1426   
1427   
1428   
1429 -class featurereq(BaseProtogenClass): 
1430      __fields=['command'] 
1431   
1432 -    def __init__(self, *args, **kwargs): 
1433          dict={} 
1434          # What was supplied to this function 
1435          dict.update(kwargs) 
1436          # Parent constructor 
1437          super(featurereq,self).__init__(**dict) 
1438          if self.__class__ is featurereq: 
1439              self._update(args,dict) 
1440   
1441   
1442 -    def getfields(self): 
1443          return self.__fields 
1444   
1445   
1446 -    def _update(self, args, kwargs): 
1447          super(featurereq,self)._update(args,kwargs) 
1448          keys=kwargs.keys() 
1449          for key in keys: 
1450              if key in self.__fields: 
1451                  setattr(self, key, kwargs[key]) 
1452                  del kwargs[key] 
1453          # Were any unrecognized kwargs passed in? 
1454          if __debug__: 
1455              self._complainaboutunusedargs(featurereq,kwargs) 
1456          if len(args): 
1457              dict2={ 'quotechar': None,                  'terminator': None, 'default': '+MAID?' } 
1458              dict2.update(kwargs) 
1459              kwargs=dict2 
1460              self.__field_command=CSVSTRING(*args,**dict2) 
1461          # Make all P fields that haven't already been constructed 
1462   
1463   
1464 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1465          'Writes this packet to the supplied buffer' 
1466          self._bufferstartoffset=buf.getcurrentoffset() 
1467          try: self.__field_command 
1468          except: 
1469              self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': None, 'default': '+MAID?' }) 
1470          self.__field_command.writetobuffer(buf) 
1471          self._bufferendoffset=buf.getcurrentoffset() 
1472          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1473   
1474   
1475 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1476          'Reads this packet from the supplied buffer' 
1477          self._bufferstartoffset=buf.getcurrentoffset() 
1478          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1479          self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': None, 'default': '+MAID?' }) 
1480          self.__field_command.readfrombuffer(buf) 
1481          self._bufferendoffset=buf.getcurrentoffset() 
1482   
1483   
1484 -    def __getfield_command(self): 
1485          try: self.__field_command 
1486          except: 
1487              self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': None, 'default': '+MAID?' }) 
1488          return self.__field_command.getvalue() 
1489   
1490 -    def __setfield_command(self, value): 
1491          if isinstance(value,CSVSTRING): 
1492              self.__field_command=value 
1493          else: 
1494              self.__field_command=CSVSTRING(value,**{ 'quotechar': None,                  'terminator': None, 'default': '+MAID?' }) 
1495   
1496 -    def __delfield_command(self): del self.__field_command 
1497   
1498      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
1499   
1500 -    def iscontainer(self): 
1501          return True 
1502   
1503 -    def containerelements(self): 
1504          yield ('command', self.__field_command, None) 
1505   
1506   
1507   
1508   
1509 -class featureresp(BaseProtogenClass): 
1510      __fields=['command', 'has_phonebook', 'has_datebook', 'has_sms', 'has_mo_sms', 'has_email', 'has_multi_phonebooks', 'has_sim', 'has_shared_phonebook', 'has_multi_dest_addr', 'has_ringtone_id', 'has_voicetag', 'dunno'] 
1511   
1512 -    def __init__(self, *args, **kwargs): 
1513          dict={} 
1514          # What was supplied to this function 
1515          dict.update(kwargs) 
1516          # Parent constructor 
1517          super(featureresp,self).__init__(**dict) 
1518          if self.__class__ is featureresp: 
1519              self._update(args,dict) 
1520   
1521   
1522 -    def getfields(self): 
1523          return self.__fields 
1524   
1525   
1526 -    def _update(self, args, kwargs): 
1527          super(featureresp,self)._update(args,kwargs) 
1528          keys=kwargs.keys() 
1529          for key in keys: 
1530              if key in self.__fields: 
1531                  setattr(self, key, kwargs[key]) 
1532                  del kwargs[key] 
1533          # Were any unrecognized kwargs passed in? 
1534          if __debug__: 
1535              self._complainaboutunusedargs(featureresp,kwargs) 
1536          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1537          # Make all P fields that haven't already been constructed 
1538   
1539   
1540 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1541          'Writes this packet to the supplied buffer' 
1542          self._bufferstartoffset=buf.getcurrentoffset() 
1543          self.__field_command.writetobuffer(buf) 
1544          self.__field_has_phonebook.writetobuffer(buf) 
1545          self.__field_has_datebook.writetobuffer(buf) 
1546          self.__field_has_sms.writetobuffer(buf) 
1547          self.__field_has_mo_sms.writetobuffer(buf) 
1548          self.__field_has_email.writetobuffer(buf) 
1549          self.__field_has_multi_phonebooks.writetobuffer(buf) 
1550          self.__field_has_sim.writetobuffer(buf) 
1551          self.__field_has_shared_phonebook.writetobuffer(buf) 
1552          self.__field_has_multi_dest_addr.writetobuffer(buf) 
1553          self.__field_has_ringtone_id.writetobuffer(buf) 
1554          self.__field_has_voicetag.writetobuffer(buf) 
1555          try: self.__field_dunno 
1556          except: 
1557              self.__field_dunno=CSVSTRING(**{ 'quotechar': None,                  'terminator': None }) 
1558          self.__field_dunno.writetobuffer(buf) 
1559          self._bufferendoffset=buf.getcurrentoffset() 
1560          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1561   
1562   
1563 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1564          'Reads this packet from the supplied buffer' 
1565          self._bufferstartoffset=buf.getcurrentoffset() 
1566          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1567          self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': ord(' '),                  'default': '+MAID:' }) 
1568          self.__field_command.readfrombuffer(buf) 
1569          self.__field_has_phonebook=CSVINT() 
1570          self.__field_has_phonebook.readfrombuffer(buf) 
1571          self.__field_has_datebook=CSVINT() 
1572          self.__field_has_datebook.readfrombuffer(buf) 
1573          self.__field_has_sms=CSVINT() 
1574          self.__field_has_sms.readfrombuffer(buf) 
1575          self.__field_has_mo_sms=CSVINT() 
1576          self.__field_has_mo_sms.readfrombuffer(buf) 
1577          self.__field_has_email=CSVINT() 
1578          self.__field_has_email.readfrombuffer(buf) 
1579          self.__field_has_multi_phonebooks=CSVINT() 
1580          self.__field_has_multi_phonebooks.readfrombuffer(buf) 
1581          self.__field_has_sim=CSVINT() 
1582          self.__field_has_sim.readfrombuffer(buf) 
1583          self.__field_has_shared_phonebook=CSVINT() 
1584          self.__field_has_shared_phonebook.readfrombuffer(buf) 
1585          self.__field_has_multi_dest_addr=CSVINT() 
1586          self.__field_has_multi_dest_addr.readfrombuffer(buf) 
1587          self.__field_has_ringtone_id=CSVINT() 
1588          self.__field_has_ringtone_id.readfrombuffer(buf) 
1589          self.__field_has_voicetag=CSVINT() 
1590          self.__field_has_voicetag.readfrombuffer(buf) 
1591          self.__field_dunno=CSVSTRING(**{ 'quotechar': None,                  'terminator': None }) 
1592          self.__field_dunno.readfrombuffer(buf) 
1593          self._bufferendoffset=buf.getcurrentoffset() 
1594   
1595   
1596 -    def __getfield_command(self): 
1597          return self.__field_command.getvalue() 
1598   
1599 -    def __setfield_command(self, value): 
1600          if isinstance(value,CSVSTRING): 
1601              self.__field_command=value 
1602          else: 
1603              self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': ord(' '),                  'default': '+MAID:' }) 
1604   
1605 -    def __delfield_command(self): del self.__field_command 
1606   
1607      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
1608   
1609 -    def __getfield_has_phonebook(self): 
1610          return self.__field_has_phonebook.getvalue() 
1611   
1612 -    def __setfield_has_phonebook(self, value): 
1613          if isinstance(value,CSVINT): 
1614              self.__field_has_phonebook=value 
1615          else: 
1616              self.__field_has_phonebook=CSVINT(value,) 
1617   
1618 -    def __delfield_has_phonebook(self): del self.__field_has_phonebook 
1619   
1620      has_phonebook=property(__getfield_has_phonebook, __setfield_has_phonebook, __delfield_has_phonebook, None) 
1621   
1622 -    def __getfield_has_datebook(self): 
1623          return self.__field_has_datebook.getvalue() 
1624   
1625 -    def __setfield_has_datebook(self, value): 
1626          if isinstance(value,CSVINT): 
1627              self.__field_has_datebook=value 
1628          else: 
1629              self.__field_has_datebook=CSVINT(value,) 
1630   
1631 -    def __delfield_has_datebook(self): del self.__field_has_datebook 
1632   
1633      has_datebook=property(__getfield_has_datebook, __setfield_has_datebook, __delfield_has_datebook, None) 
1634   
1635 -    def __getfield_has_sms(self): 
1636          return self.__field_has_sms.getvalue() 
1637   
1638 -    def __setfield_has_sms(self, value): 
1639          if isinstance(value,CSVINT): 
1640              self.__field_has_sms=value 
1641          else: 
1642              self.__field_has_sms=CSVINT(value,) 
1643   
1644 -    def __delfield_has_sms(self): del self.__field_has_sms 
1645   
1646      has_sms=property(__getfield_has_sms, __setfield_has_sms, __delfield_has_sms, None) 
1647   
1648 -    def __getfield_has_mo_sms(self): 
1649          return self.__field_has_mo_sms.getvalue() 
1650   
1651 -    def __setfield_has_mo_sms(self, value): 
1652          if isinstance(value,CSVINT): 
1653              self.__field_has_mo_sms=value 
1654          else: 
1655              self.__field_has_mo_sms=CSVINT(value,) 
1656   
1657 -    def __delfield_has_mo_sms(self): del self.__field_has_mo_sms 
1658   
1659      has_mo_sms=property(__getfield_has_mo_sms, __setfield_has_mo_sms, __delfield_has_mo_sms, None) 
1660   
1661 -    def __getfield_has_email(self): 
1662          return self.__field_has_email.getvalue() 
1663   
1664 -    def __setfield_has_email(self, value): 
1665          if isinstance(value,CSVINT): 
1666              self.__field_has_email=value 
1667          else: 
1668              self.__field_has_email=CSVINT(value,) 
1669   
1670 -    def __delfield_has_email(self): del self.__field_has_email 
1671   
1672      has_email=property(__getfield_has_email, __setfield_has_email, __delfield_has_email, None) 
1673   
1674 -    def __getfield_has_multi_phonebooks(self): 
1675          return self.__field_has_multi_phonebooks.getvalue() 
1676   
1677 -    def __setfield_has_multi_phonebooks(self, value): 
1678          if isinstance(value,CSVINT): 
1679              self.__field_has_multi_phonebooks=value 
1680          else: 
1681              self.__field_has_multi_phonebooks=CSVINT(value,) 
1682   
1683 -    def __delfield_has_multi_phonebooks(self): del self.__field_has_multi_phonebooks 
1684   
1685      has_multi_phonebooks=property(__getfield_has_multi_phonebooks, __setfield_has_multi_phonebooks, __delfield_has_multi_phonebooks, None) 
1686   
1687 -    def __getfield_has_sim(self): 
1688          return self.__field_has_sim.getvalue() 
1689   
1690 -    def __setfield_has_sim(self, value): 
1691          if isinstance(value,CSVINT): 
1692              self.__field_has_sim=value 
1693          else: 
1694              self.__field_has_sim=CSVINT(value,) 
1695   
1696 -    def __delfield_has_sim(self): del self.__field_has_sim 
1697   
1698      has_sim=property(__getfield_has_sim, __setfield_has_sim, __delfield_has_sim, None) 
1699   
1700 -    def __getfield_has_shared_phonebook(self): 
1701          return self.__field_has_shared_phonebook.getvalue() 
1702   
1703 -    def __setfield_has_shared_phonebook(self, value): 
1704          if isinstance(value,CSVINT): 
1705              self.__field_has_shared_phonebook=value 
1706          else: 
1707              self.__field_has_shared_phonebook=CSVINT(value,) 
1708   
1709 -    def __delfield_has_shared_phonebook(self): del self.__field_has_shared_phonebook 
1710   
1711      has_shared_phonebook=property(__getfield_has_shared_phonebook, __setfield_has_shared_phonebook, __delfield_has_shared_phonebook, None) 
1712   
1713 -    def __getfield_has_multi_dest_addr(self): 
1714          return self.__field_has_multi_dest_addr.getvalue() 
1715   
1716 -    def __setfield_has_multi_dest_addr(self, value): 
1717          if isinstance(value,CSVINT): 
1718              self.__field_has_multi_dest_addr=value 
1719          else: 
1720              self.__field_has_multi_dest_addr=CSVINT(value,) 
1721   
1722 -    def __delfield_has_multi_dest_addr(self): del self.__field_has_multi_dest_addr 
1723   
1724      has_multi_dest_addr=property(__getfield_has_multi_dest_addr, __setfield_has_multi_dest_addr, __delfield_has_multi_dest_addr, None) 
1725   
1726 -    def __getfield_has_ringtone_id(self): 
1727          return self.__field_has_ringtone_id.getvalue() 
1728   
1729 -    def __setfield_has_ringtone_id(self, value): 
1730          if isinstance(value,CSVINT): 
1731              self.__field_has_ringtone_id=value 
1732          else: 
1733              self.__field_has_ringtone_id=CSVINT(value,) 
1734   
1735 -    def __delfield_has_ringtone_id(self): del self.__field_has_ringtone_id 
1736   
1737      has_ringtone_id=property(__getfield_has_ringtone_id, __setfield_has_ringtone_id, __delfield_has_ringtone_id, None) 
1738   
1739 -    def __getfield_has_voicetag(self): 
1740          return self.__field_has_voicetag.getvalue() 
1741   
1742 -    def __setfield_has_voicetag(self, value): 
1743          if isinstance(value,CSVINT): 
1744              self.__field_has_voicetag=value 
1745          else: 
1746              self.__field_has_voicetag=CSVINT(value,) 
1747   
1748 -    def __delfield_has_voicetag(self): del self.__field_has_voicetag 
1749   
1750      has_voicetag=property(__getfield_has_voicetag, __setfield_has_voicetag, __delfield_has_voicetag, None) 
1751   
1752 -    def __getfield_dunno(self): 
1753          try: self.__field_dunno 
1754          except: 
1755              self.__field_dunno=CSVSTRING(**{ 'quotechar': None,                  'terminator': None }) 
1756          return self.__field_dunno.getvalue() 
1757   
1758 -    def __setfield_dunno(self, value): 
1759          if isinstance(value,CSVSTRING): 
1760              self.__field_dunno=value 
1761          else: 
1762              self.__field_dunno=CSVSTRING(value,**{ 'quotechar': None,                  'terminator': None }) 
1763   
1764 -    def __delfield_dunno(self): del self.__field_dunno 
1765   
1766      dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None) 
1767   
1768 -    def iscontainer(self): 
1769          return True 
1770   
1771 -    def containerelements(self): 
1772          yield ('command', self.__field_command, None) 
1773          yield ('has_phonebook', self.__field_has_phonebook, None) 
1774          yield ('has_datebook', self.__field_has_datebook, None) 
1775          yield ('has_sms', self.__field_has_sms, None) 
1776          yield ('has_mo_sms', self.__field_has_mo_sms, None) 
1777          yield ('has_email', self.__field_has_email, None) 
1778          yield ('has_multi_phonebooks', self.__field_has_multi_phonebooks, None) 
1779          yield ('has_sim', self.__field_has_sim, None) 
1780          yield ('has_shared_phonebook', self.__field_has_shared_phonebook, None) 
1781          yield ('has_multi_dest_addr', self.__field_has_multi_dest_addr, None) 
1782          yield ('has_ringtone_id', self.__field_has_ringtone_id, None) 
1783          yield ('has_voicetag', self.__field_has_voicetag, None) 
1784          yield ('dunno', self.__field_dunno, None) 
1785   
1786   
1787   
1788   
1789 -class select_phonebook_req(BaseProtogenClass): 
1790      __fields=['command', 'pb_type'] 
1791   
1792 -    def __init__(self, *args, **kwargs): 
1793          dict={} 
1794          # What was supplied to this function 
1795          dict.update(kwargs) 
1796          # Parent constructor 
1797          super(select_phonebook_req,self).__init__(**dict) 
1798          if self.__class__ is select_phonebook_req: 
1799              self._update(args,dict) 
1800   
1801   
1802 -    def getfields(self): 
1803          return self.__fields 
1804   
1805   
1806 -    def _update(self, args, kwargs): 
1807          super(select_phonebook_req,self)._update(args,kwargs) 
1808          keys=kwargs.keys() 
1809          for key in keys: 
1810              if key in self.__fields: 
1811                  setattr(self, key, kwargs[key]) 
1812                  del kwargs[key] 
1813          # Were any unrecognized kwargs passed in? 
1814          if __debug__: 
1815              self._complainaboutunusedargs(select_phonebook_req,kwargs) 
1816          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1817          # Make all P fields that haven't already been constructed 
1818   
1819   
1820 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1821          'Writes this packet to the supplied buffer' 
1822          self._bufferstartoffset=buf.getcurrentoffset() 
1823          try: self.__field_command 
1824          except: 
1825              self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': None, 'default': '+CPBS=' }) 
1826          self.__field_command.writetobuffer(buf) 
1827          try: self.__field_pb_type 
1828          except: 
1829              self.__field_pb_type=CSVSTRING(**{ 'terminator': None,                  'default': PB_MAIN }) 
1830          self.__field_pb_type.writetobuffer(buf) 
1831          self._bufferendoffset=buf.getcurrentoffset() 
1832          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1833   
1834   
1835 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1836          'Reads this packet from the supplied buffer' 
1837          self._bufferstartoffset=buf.getcurrentoffset() 
1838          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1839          self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': None, 'default': '+CPBS=' }) 
1840          self.__field_command.readfrombuffer(buf) 
1841          self.__field_pb_type=CSVSTRING(**{ 'terminator': None,                  'default': PB_MAIN }) 
1842          self.__field_pb_type.readfrombuffer(buf) 
1843          self._bufferendoffset=buf.getcurrentoffset() 
1844   
1845   
1846 -    def __getfield_command(self): 
1847          try: self.__field_command 
1848          except: 
1849              self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': None, 'default': '+CPBS=' }) 
1850          return self.__field_command.getvalue() 
1851   
1852 -    def __setfield_command(self, value): 
1853          if isinstance(value,CSVSTRING): 
1854              self.__field_command=value 
1855          else: 
1856              self.__field_command=CSVSTRING(value,**{ 'quotechar': None,                  'terminator': None, 'default': '+CPBS=' }) 
1857   
1858 -    def __delfield_command(self): del self.__field_command 
1859   
1860      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
1861   
1862 -    def __getfield_pb_type(self): 
1863          try: self.__field_pb_type 
1864          except: 
1865              self.__field_pb_type=CSVSTRING(**{ 'terminator': None,                  'default': PB_MAIN }) 
1866          return self.__field_pb_type.getvalue() 
1867   
1868 -    def __setfield_pb_type(self, value): 
1869          if isinstance(value,CSVSTRING): 
1870              self.__field_pb_type=value 
1871          else: 
1872              self.__field_pb_type=CSVSTRING(value,**{ 'terminator': None,                  'default': PB_MAIN }) 
1873   
1874 -    def __delfield_pb_type(self): del self.__field_pb_type 
1875   
1876      pb_type=property(__getfield_pb_type, __setfield_pb_type, __delfield_pb_type, None) 
1877   
1878 -    def iscontainer(self): 
1879          return True 
1880   
1881 -    def containerelements(self): 
1882          yield ('command', self.__field_command, None) 
1883          yield ('pb_type', self.__field_pb_type, None) 
1884   
1885   
1886   
1887   
1888 -class read_pb_simple_req(BaseProtogenClass): 
1889      __fields=['command', 'start_index', 'end_index'] 
1890   
1891 -    def __init__(self, *args, **kwargs): 
1892          dict={} 
1893          # What was supplied to this function 
1894          dict.update(kwargs) 
1895          # Parent constructor 
1896          super(read_pb_simple_req,self).__init__(**dict) 
1897          if self.__class__ is read_pb_simple_req: 
1898              self._update(args,dict) 
1899   
1900   
1901 -    def getfields(self): 
1902          return self.__fields 
1903   
1904   
1905 -    def _update(self, args, kwargs): 
1906          super(read_pb_simple_req,self)._update(args,kwargs) 
1907          keys=kwargs.keys() 
1908          for key in keys: 
1909              if key in self.__fields: 
1910                  setattr(self, key, kwargs[key]) 
1911                  del kwargs[key] 
1912          # Were any unrecognized kwargs passed in? 
1913          if __debug__: 
1914              self._complainaboutunusedargs(read_pb_simple_req,kwargs) 
1915          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1916          # Make all P fields that haven't already been constructed 
1917   
1918   
1919 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1920          'Writes this packet to the supplied buffer' 
1921          self._bufferstartoffset=buf.getcurrentoffset() 
1922          try: self.__field_command 
1923          except: 
1924              self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': None, 'default': '+CPBR=' }) 
1925          self.__field_command.writetobuffer(buf) 
1926          try: self.__field_start_index 
1927          except: 
1928              self.__field_start_index=CSVINT(**{ 'default': 1 }) 
1929          self.__field_start_index.writetobuffer(buf) 
1930          try: self.__field_end_index 
1931          except: 
1932              self.__field_end_index=CSVINT(**{ 'terminator': None,               'default': self.start_index }) 
1933          self.__field_end_index.writetobuffer(buf) 
1934          self._bufferendoffset=buf.getcurrentoffset() 
1935          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1936   
1937   
1938 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1939          'Reads this packet from the supplied buffer' 
1940          self._bufferstartoffset=buf.getcurrentoffset() 
1941          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1942          self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': None, 'default': '+CPBR=' }) 
1943          self.__field_command.readfrombuffer(buf) 
1944          self.__field_start_index=CSVINT(**{ 'default': 1 }) 
1945          self.__field_start_index.readfrombuffer(buf) 
1946          self.__field_end_index=CSVINT(**{ 'terminator': None,               'default': self.start_index }) 
1947          self.__field_end_index.readfrombuffer(buf) 
1948          self._bufferendoffset=buf.getcurrentoffset() 
1949   
1950   
1951 -    def __getfield_command(self): 
1952          try: self.__field_command 
1953          except: 
1954              self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': None, 'default': '+CPBR=' }) 
1955          return self.__field_command.getvalue() 
1956   
1957 -    def __setfield_command(self, value): 
1958          if isinstance(value,CSVSTRING): 
1959              self.__field_command=value 
1960          else: 
1961              self.__field_command=CSVSTRING(value,**{ 'quotechar': None,                  'terminator': None, 'default': '+CPBR=' }) 
1962   
1963 -    def __delfield_command(self): del self.__field_command 
1964   
1965      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
1966   
1967 -    def __getfield_start_index(self): 
1968          try: self.__field_start_index 
1969          except: 
1970              self.__field_start_index=CSVINT(**{ 'default': 1 }) 
1971          return self.__field_start_index.getvalue() 
1972   
1973 -    def __setfield_start_index(self, value): 
1974          if isinstance(value,CSVINT): 
1975              self.__field_start_index=value 
1976          else: 
1977              self.__field_start_index=CSVINT(value,**{ 'default': 1 }) 
1978   
1979 -    def __delfield_start_index(self): del self.__field_start_index 
1980   
1981      start_index=property(__getfield_start_index, __setfield_start_index, __delfield_start_index, None) 
1982   
1983 -    def __getfield_end_index(self): 
1984          try: self.__field_end_index 
1985          except: 
1986              self.__field_end_index=CSVINT(**{ 'terminator': None,               'default': self.start_index }) 
1987          return self.__field_end_index.getvalue() 
1988   
1989 -    def __setfield_end_index(self, value): 
1990          if isinstance(value,CSVINT): 
1991              self.__field_end_index=value 
1992          else: 
1993              self.__field_end_index=CSVINT(value,**{ 'terminator': None,               'default': self.start_index }) 
1994   
1995 -    def __delfield_end_index(self): del self.__field_end_index 
1996   
1997      end_index=property(__getfield_end_index, __setfield_end_index, __delfield_end_index, None) 
1998   
1999 -    def iscontainer(self): 
2000          return True 
2001   
2002 -    def containerelements(self): 
2003          yield ('command', self.__field_command, None) 
2004          yield ('start_index', self.__field_start_index, None) 
2005          yield ('end_index', self.__field_end_index, None) 
2006   
2007   
2008   
2009   
2010 -class read_pb_simple_resp(BaseProtogenClass): 
2011      __fields=['command', 'index', 'number', 'local_type', 'name'] 
2012   
2013 -    def __init__(self, *args, **kwargs): 
2014          dict={} 
2015          # What was supplied to this function 
2016          dict.update(kwargs) 
2017          # Parent constructor 
2018          super(read_pb_simple_resp,self).__init__(**dict) 
2019          if self.__class__ is read_pb_simple_resp: 
2020              self._update(args,dict) 
2021   
2022   
2023 -    def getfields(self): 
2024          return self.__fields 
2025   
2026   
2027 -    def _update(self, args, kwargs): 
2028          super(read_pb_simple_resp,self)._update(args,kwargs) 
2029          keys=kwargs.keys() 
2030          for key in keys: 
2031              if key in self.__fields: 
2032                  setattr(self, key, kwargs[key]) 
2033                  del kwargs[key] 
2034          # Were any unrecognized kwargs passed in? 
2035          if __debug__: 
2036              self._complainaboutunusedargs(read_pb_simple_resp,kwargs) 
2037          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2038          # Make all P fields that haven't already been constructed 
2039   
2040   
2041 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2042          'Writes this packet to the supplied buffer' 
2043          self._bufferstartoffset=buf.getcurrentoffset() 
2044          try: self.__field_command 
2045          except: 
2046              self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': ord(' '),                  'default': '+CPBR:' }) 
2047          self.__field_command.writetobuffer(buf) 
2048          self.__field_index.writetobuffer(buf) 
2049          self.__field_number.writetobuffer(buf) 
2050          self.__field_local_type.writetobuffer(buf) 
2051          self.__field_name.writetobuffer(buf) 
2052          self._bufferendoffset=buf.getcurrentoffset() 
2053          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2054   
2055   
2056 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2057          'Reads this packet from the supplied buffer' 
2058          self._bufferstartoffset=buf.getcurrentoffset() 
2059          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2060          self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': ord(' '),                  'default': '+CPBR:' }) 
2061          self.__field_command.readfrombuffer(buf) 
2062          self.__field_index=CSVINT() 
2063          self.__field_index.readfrombuffer(buf) 
2064          self.__field_number=CSVSTRING() 
2065          self.__field_number.readfrombuffer(buf) 
2066          self.__field_local_type=CSVINT() 
2067          self.__field_local_type.readfrombuffer(buf) 
2068          self.__field_name=CSVSTRING(**{ 'terminator': None }) 
2069          self.__field_name.readfrombuffer(buf) 
2070          self._bufferendoffset=buf.getcurrentoffset() 
2071   
2072   
2073 -    def __getfield_command(self): 
2074          try: self.__field_command 
2075          except: 
2076              self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': ord(' '),                  'default': '+CPBR:' }) 
2077          return self.__field_command.getvalue() 
2078   
2079 -    def __setfield_command(self, value): 
2080          if isinstance(value,CSVSTRING): 
2081              self.__field_command=value 
2082          else: 
2083              self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': ord(' '),                  'default': '+CPBR:' }) 
2084   
2085 -    def __delfield_command(self): del self.__field_command 
2086   
2087      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
2088   
2089 -    def __getfield_index(self): 
2090          return self.__field_index.getvalue() 
2091   
2092 -    def __setfield_index(self, value): 
2093          if isinstance(value,CSVINT): 
2094              self.__field_index=value 
2095          else: 
2096              self.__field_index=CSVINT(value,) 
2097   
2098 -    def __delfield_index(self): del self.__field_index 
2099   
2100      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
2101   
2102 -    def __getfield_number(self): 
2103          return self.__field_number.getvalue() 
2104   
2105 -    def __setfield_number(self, value): 
2106          if isinstance(value,CSVSTRING): 
2107              self.__field_number=value 
2108          else: 
2109              self.__field_number=CSVSTRING(value,) 
2110   
2111 -    def __delfield_number(self): del self.__field_number 
2112   
2113      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
2114   
2115 -    def __getfield_local_type(self): 
2116          return self.__field_local_type.getvalue() 
2117   
2118 -    def __setfield_local_type(self, value): 
2119          if isinstance(value,CSVINT): 
2120              self.__field_local_type=value 
2121          else: 
2122              self.__field_local_type=CSVINT(value,) 
2123   
2124 -    def __delfield_local_type(self): del self.__field_local_type 
2125   
2126      local_type=property(__getfield_local_type, __setfield_local_type, __delfield_local_type, None) 
2127   
2128 -    def __getfield_name(self): 
2129          return self.__field_name.getvalue() 
2130   
2131 -    def __setfield_name(self, value): 
2132          if isinstance(value,CSVSTRING): 
2133              self.__field_name=value 
2134          else: 
2135              self.__field_name=CSVSTRING(value,**{ 'terminator': None }) 
2136   
2137 -    def __delfield_name(self): del self.__field_name 
2138   
2139      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
2140   
2141 -    def iscontainer(self): 
2142          return True 
2143   
2144 -    def containerelements(self): 
2145          yield ('command', self.__field_command, None) 
2146          yield ('index', self.__field_index, None) 
2147          yield ('number', self.__field_number, None) 
2148          yield ('local_type', self.__field_local_type, None) 
2149          yield ('name', self.__field_name, None) 
2150   
2151   
2152   
2153   
2154 -class read_pb_req(BaseProtogenClass): 
2155      __fields=['command', 'start_index', 'end_index'] 
2156   
2157 -    def __init__(self, *args, **kwargs): 
2158          dict={} 
2159          # What was supplied to this function 
2160          dict.update(kwargs) 
2161          # Parent constructor 
2162          super(read_pb_req,self).__init__(**dict) 
2163          if self.__class__ is read_pb_req: 
2164              self._update(args,dict) 
2165   
2166   
2167 -    def getfields(self): 
2168          return self.__fields 
2169   
2170   
2171 -    def _update(self, args, kwargs): 
2172          super(read_pb_req,self)._update(args,kwargs) 
2173          keys=kwargs.keys() 
2174          for key in keys: 
2175              if key in self.__fields: 
2176                  setattr(self, key, kwargs[key]) 
2177                  del kwargs[key] 
2178          # Were any unrecognized kwargs passed in? 
2179          if __debug__: 
2180              self._complainaboutunusedargs(read_pb_req,kwargs) 
2181          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2182          # Make all P fields that haven't already been constructed 
2183   
2184   
2185 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2186          'Writes this packet to the supplied buffer' 
2187          self._bufferstartoffset=buf.getcurrentoffset() 
2188          try: self.__field_command 
2189          except: 
2190              self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': None, 'default': '+MPBR=' }) 
2191          self.__field_command.writetobuffer(buf) 
2192          try: self.__field_start_index 
2193          except: 
2194              self.__field_start_index=CSVINT(**{ 'default': 1 }) 
2195          self.__field_start_index.writetobuffer(buf) 
2196          try: self.__field_end_index 
2197          except: 
2198              self.__field_end_index=CSVINT(**{ 'terminator': None,               'default': self.start_index }) 
2199          self.__field_end_index.writetobuffer(buf) 
2200          self._bufferendoffset=buf.getcurrentoffset() 
2201          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2202   
2203   
2204 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2205          'Reads this packet from the supplied buffer' 
2206          self._bufferstartoffset=buf.getcurrentoffset() 
2207          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2208          self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': None, 'default': '+MPBR=' }) 
2209          self.__field_command.readfrombuffer(buf) 
2210          self.__field_start_index=CSVINT(**{ 'default': 1 }) 
2211          self.__field_start_index.readfrombuffer(buf) 
2212          self.__field_end_index=CSVINT(**{ 'terminator': None,               'default': self.start_index }) 
2213          self.__field_end_index.readfrombuffer(buf) 
2214          self._bufferendoffset=buf.getcurrentoffset() 
2215   
2216   
2217 -    def __getfield_command(self): 
2218          try: self.__field_command 
2219          except: 
2220              self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': None, 'default': '+MPBR=' }) 
2221          return self.__field_command.getvalue() 
2222   
2223 -    def __setfield_command(self, value): 
2224          if isinstance(value,CSVSTRING): 
2225              self.__field_command=value 
2226          else: 
2227              self.__field_command=CSVSTRING(value,**{ 'quotechar': None,                  'terminator': None, 'default': '+MPBR=' }) 
2228   
2229 -    def __delfield_command(self): del self.__field_command 
2230   
2231      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
2232   
2233 -    def __getfield_start_index(self): 
2234          try: self.__field_start_index 
2235          except: 
2236              self.__field_start_index=CSVINT(**{ 'default': 1 }) 
2237          return self.__field_start_index.getvalue() 
2238   
2239 -    def __setfield_start_index(self, value): 
2240          if isinstance(value,CSVINT): 
2241              self.__field_start_index=value 
2242          else: 
2243              self.__field_start_index=CSVINT(value,**{ 'default': 1 }) 
2244   
2245 -    def __delfield_start_index(self): del self.__field_start_index 
2246   
2247      start_index=property(__getfield_start_index, __setfield_start_index, __delfield_start_index, None) 
2248   
2249 -    def __getfield_end_index(self): 
2250          try: self.__field_end_index 
2251          except: 
2252              self.__field_end_index=CSVINT(**{ 'terminator': None,               'default': self.start_index }) 
2253          return self.__field_end_index.getvalue() 
2254   
2255 -    def __setfield_end_index(self, value): 
2256          if isinstance(value,CSVINT): 
2257              self.__field_end_index=value 
2258          else: 
2259              self.__field_end_index=CSVINT(value,**{ 'terminator': None,               'default': self.start_index }) 
2260   
2261 -    def __delfield_end_index(self): del self.__field_end_index 
2262   
2263      end_index=property(__getfield_end_index, __setfield_end_index, __delfield_end_index, None) 
2264   
2265 -    def iscontainer(self): 
2266          return True 
2267   
2268 -    def containerelements(self): 
2269          yield ('command', self.__field_command, None) 
2270          yield ('start_index', self.__field_start_index, None) 
2271          yield ('end_index', self.__field_end_index, None) 
2272   
2273   
2274   
2275   
2276 -class read_pb_resp(BaseProtogenClass): 
2277      __fields=['command', 'index', 'number', 'local_type', 'name', 'number_type', 'voice_tag', 'ringtone', 'backlight', 'is_primary', 'group', 'icon', 'first_last_enabled', 'subfield_index', 'picture_name', 'dunno'] 
2278   
2279 -    def __init__(self, *args, **kwargs): 
2280          dict={} 
2281          # What was supplied to this function 
2282          dict.update(kwargs) 
2283          # Parent constructor 
2284          super(read_pb_resp,self).__init__(**dict) 
2285          if self.__class__ is read_pb_resp: 
2286              self._update(args,dict) 
2287   
2288   
2289 -    def getfields(self): 
2290          return self.__fields 
2291   
2292   
2293 -    def _update(self, args, kwargs): 
2294          super(read_pb_resp,self)._update(args,kwargs) 
2295          keys=kwargs.keys() 
2296          for key in keys: 
2297              if key in self.__fields: 
2298                  setattr(self, key, kwargs[key]) 
2299                  del kwargs[key] 
2300          # Were any unrecognized kwargs passed in? 
2301          if __debug__: 
2302              self._complainaboutunusedargs(read_pb_resp,kwargs) 
2303          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2304          # Make all P fields that haven't already been constructed 
2305   
2306   
2307 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2308          'Writes this packet to the supplied buffer' 
2309          self._bufferstartoffset=buf.getcurrentoffset() 
2310          self.__field_command.writetobuffer(buf) 
2311          self.__field_index.writetobuffer(buf) 
2312          self.__field_number.writetobuffer(buf) 
2313          self.__field_local_type.writetobuffer(buf) 
2314          self.__field_name.writetobuffer(buf) 
2315          self.__field_number_type.writetobuffer(buf) 
2316          self.__field_voice_tag.writetobuffer(buf) 
2317          self.__field_ringtone.writetobuffer(buf) 
2318          self.__field_backlight.writetobuffer(buf) 
2319          self.__field_is_primary.writetobuffer(buf) 
2320          self.__field_group.writetobuffer(buf) 
2321          self.__field_icon.writetobuffer(buf) 
2322          self.__field_first_last_enabled.writetobuffer(buf) 
2323          self.__field_subfield_index.writetobuffer(buf) 
2324          self.__field_picture_name.writetobuffer(buf) 
2325          self.__field_dunno.writetobuffer(buf) 
2326          self._bufferendoffset=buf.getcurrentoffset() 
2327          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2328   
2329   
2330 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2331          'Reads this packet from the supplied buffer' 
2332          self._bufferstartoffset=buf.getcurrentoffset() 
2333          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2334          self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': ord(' '),                  'default': '+MPBR:' }) 
2335          self.__field_command.readfrombuffer(buf) 
2336          self.__field_index=CSVINT() 
2337          self.__field_index.readfrombuffer(buf) 
2338          self.__field_number=CSVSTRING() 
2339          self.__field_number.readfrombuffer(buf) 
2340          self.__field_local_type=CSVINT() 
2341          self.__field_local_type.readfrombuffer(buf) 
2342          self.__field_name=CSVSTRING() 
2343          self.__field_name.readfrombuffer(buf) 
2344          self.__field_number_type=CSVINT() 
2345          self.__field_number_type.readfrombuffer(buf) 
2346          self.__field_voice_tag=CSVINT() 
2347          self.__field_voice_tag.readfrombuffer(buf) 
2348          self.__field_ringtone=CSVINT() 
2349          self.__field_ringtone.readfrombuffer(buf) 
2350          self.__field_backlight=CSVINT() 
2351          self.__field_backlight.readfrombuffer(buf) 
2352          self.__field_is_primary=CSVINT() 
2353          self.__field_is_primary.readfrombuffer(buf) 
2354          self.__field_group=CSVINT() 
2355          self.__field_group.readfrombuffer(buf) 
2356          self.__field_icon=CSVINT() 
2357          self.__field_icon.readfrombuffer(buf) 
2358          self.__field_first_last_enabled=CSVINT() 
2359          self.__field_first_last_enabled.readfrombuffer(buf) 
2360          self.__field_subfield_index=CSVINT() 
2361          self.__field_subfield_index.readfrombuffer(buf) 
2362          self.__field_picture_name=CSVSTRING() 
2363          self.__field_picture_name.readfrombuffer(buf) 
2364          self.__field_dunno=CSVSTRING(**{ 'quotechar': None, 'terminator': None }) 
2365          self.__field_dunno.readfrombuffer(buf) 
2366          self._bufferendoffset=buf.getcurrentoffset() 
2367   
2368   
2369 -    def __getfield_command(self): 
2370          return self.__field_command.getvalue() 
2371   
2372 -    def __setfield_command(self, value): 
2373          if isinstance(value,CSVSTRING): 
2374              self.__field_command=value 
2375          else: 
2376              self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': ord(' '),                  'default': '+MPBR:' }) 
2377   
2378 -    def __delfield_command(self): del self.__field_command 
2379   
2380      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
2381   
2382 -    def __getfield_index(self): 
2383          return self.__field_index.getvalue() 
2384   
2385 -    def __setfield_index(self, value): 
2386          if isinstance(value,CSVINT): 
2387              self.__field_index=value 
2388          else: 
2389              self.__field_index=CSVINT(value,) 
2390   
2391 -    def __delfield_index(self): del self.__field_index 
2392   
2393      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
2394   
2395 -    def __getfield_number(self): 
2396          return self.__field_number.getvalue() 
2397   
2398 -    def __setfield_number(self, value): 
2399          if isinstance(value,CSVSTRING): 
2400              self.__field_number=value 
2401          else: 
2402              self.__field_number=CSVSTRING(value,) 
2403   
2404 -    def __delfield_number(self): del self.__field_number 
2405   
2406      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
2407   
2408 -    def __getfield_local_type(self): 
2409          return self.__field_local_type.getvalue() 
2410   
2411 -    def __setfield_local_type(self, value): 
2412          if isinstance(value,CSVINT): 
2413              self.__field_local_type=value 
2414          else: 
2415              self.__field_local_type=CSVINT(value,) 
2416   
2417 -    def __delfield_local_type(self): del self.__field_local_type 
2418   
2419      local_type=property(__getfield_local_type, __setfield_local_type, __delfield_local_type, None) 
2420   
2421 -    def __getfield_name(self): 
2422          return self.__field_name.getvalue() 
2423   
2424 -    def __setfield_name(self, value): 
2425          if isinstance(value,CSVSTRING): 
2426              self.__field_name=value 
2427          else: 
2428              self.__field_name=CSVSTRING(value,) 
2429   
2430 -    def __delfield_name(self): del self.__field_name 
2431   
2432      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
2433   
2434 -    def __getfield_number_type(self): 
2435          return self.__field_number_type.getvalue() 
2436   
2437 -    def __setfield_number_type(self, value): 
2438          if isinstance(value,CSVINT): 
2439              self.__field_number_type=value 
2440          else: 
2441              self.__field_number_type=CSVINT(value,) 
2442   
2443 -    def __delfield_number_type(self): del self.__field_number_type 
2444   
2445      number_type=property(__getfield_number_type, __setfield_number_type, __delfield_number_type, None) 
2446   
2447 -    def __getfield_voice_tag(self): 
2448          return self.__field_voice_tag.getvalue() 
2449   
2450 -    def __setfield_voice_tag(self, value): 
2451          if isinstance(value,CSVINT): 
2452              self.__field_voice_tag=value 
2453          else: 
2454              self.__field_voice_tag=CSVINT(value,) 
2455   
2456 -    def __delfield_voice_tag(self): del self.__field_voice_tag 
2457   
2458      voice_tag=property(__getfield_voice_tag, __setfield_voice_tag, __delfield_voice_tag, None) 
2459   
2460 -    def __getfield_ringtone(self): 
2461          return self.__field_ringtone.getvalue() 
2462   
2463 -    def __setfield_ringtone(self, value): 
2464          if isinstance(value,CSVINT): 
2465              self.__field_ringtone=value 
2466          else: 
2467              self.__field_ringtone=CSVINT(value,) 
2468   
2469 -    def __delfield_ringtone(self): del self.__field_ringtone 
2470   
2471      ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 
2472   
2473 -    def __getfield_backlight(self): 
2474          return self.__field_backlight.getvalue() 
2475   
2476 -    def __setfield_backlight(self, value): 
2477          if isinstance(value,CSVINT): 
2478              self.__field_backlight=value 
2479          else: 
2480              self.__field_backlight=CSVINT(value,) 
2481   
2482 -    def __delfield_backlight(self): del self.__field_backlight 
2483   
2484      backlight=property(__getfield_backlight, __setfield_backlight, __delfield_backlight, None) 
2485   
2486 -    def __getfield_is_primary(self): 
2487          return self.__field_is_primary.getvalue() 
2488   
2489 -    def __setfield_is_primary(self, value): 
2490          if isinstance(value,CSVINT): 
2491              self.__field_is_primary=value 
2492          else: 
2493              self.__field_is_primary=CSVINT(value,) 
2494   
2495 -    def __delfield_is_primary(self): del self.__field_is_primary 
2496   
2497      is_primary=property(__getfield_is_primary, __setfield_is_primary, __delfield_is_primary, None) 
2498   
2499 -    def __getfield_group(self): 
2500          return self.__field_group.getvalue() 
2501   
2502 -    def __setfield_group(self, value): 
2503          if isinstance(value,CSVINT): 
2504              self.__field_group=value 
2505          else: 
2506              self.__field_group=CSVINT(value,) 
2507   
2508 -    def __delfield_group(self): del self.__field_group 
2509   
2510      group=property(__getfield_group, __setfield_group, __delfield_group, None) 
2511   
2512 -    def __getfield_icon(self): 
2513          return self.__field_icon.getvalue() 
2514   
2515 -    def __setfield_icon(self, value): 
2516          if isinstance(value,CSVINT): 
2517              self.__field_icon=value 
2518          else: 
2519              self.__field_icon=CSVINT(value,) 
2520   
2521 -    def __delfield_icon(self): del self.__field_icon 
2522   
2523      icon=property(__getfield_icon, __setfield_icon, __delfield_icon, None) 
2524   
2525 -    def __getfield_first_last_enabled(self): 
2526          return self.__field_first_last_enabled.getvalue() 
2527   
2528 -    def __setfield_first_last_enabled(self, value): 
2529          if isinstance(value,CSVINT): 
2530              self.__field_first_last_enabled=value 
2531          else: 
2532              self.__field_first_last_enabled=CSVINT(value,) 
2533   
2534 -    def __delfield_first_last_enabled(self): del self.__field_first_last_enabled 
2535   
2536      first_last_enabled=property(__getfield_first_last_enabled, __setfield_first_last_enabled, __delfield_first_last_enabled, None) 
2537   
2538 -    def __getfield_subfield_index(self): 
2539          return self.__field_subfield_index.getvalue() 
2540   
2541 -    def __setfield_subfield_index(self, value): 
2542          if isinstance(value,CSVINT): 
2543              self.__field_subfield_index=value 
2544          else: 
2545              self.__field_subfield_index=CSVINT(value,) 
2546   
2547 -    def __delfield_subfield_index(self): del self.__field_subfield_index 
2548   
2549      subfield_index=property(__getfield_subfield_index, __setfield_subfield_index, __delfield_subfield_index, None) 
2550   
2551 -    def __getfield_picture_name(self): 
2552          return self.__field_picture_name.getvalue() 
2553   
2554 -    def __setfield_picture_name(self, value): 
2555          if isinstance(value,CSVSTRING): 
2556              self.__field_picture_name=value 
2557          else: 
2558              self.__field_picture_name=CSVSTRING(value,) 
2559   
2560 -    def __delfield_picture_name(self): del self.__field_picture_name 
2561   
2562      picture_name=property(__getfield_picture_name, __setfield_picture_name, __delfield_picture_name, None) 
2563   
2564 -    def __getfield_dunno(self): 
2565          return self.__field_dunno.getvalue() 
2566   
2567 -    def __setfield_dunno(self, value): 
2568          if isinstance(value,CSVSTRING): 
2569              self.__field_dunno=value 
2570          else: 
2571              self.__field_dunno=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None }) 
2572   
2573 -    def __delfield_dunno(self): del self.__field_dunno 
2574   
2575      dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None) 
2576   
2577 -    def iscontainer(self): 
2578          return True 
2579   
2580 -    def containerelements(self): 
2581          yield ('command', self.__field_command, None) 
2582          yield ('index', self.__field_index, None) 
2583          yield ('number', self.__field_number, None) 
2584          yield ('local_type', self.__field_local_type, None) 
2585          yield ('name', self.__field_name, None) 
2586          yield ('number_type', self.__field_number_type, None) 
2587          yield ('voice_tag', self.__field_voice_tag, None) 
2588          yield ('ringtone', self.__field_ringtone, None) 
2589          yield ('backlight', self.__field_backlight, None) 
2590          yield ('is_primary', self.__field_is_primary, None) 
2591          yield ('group', self.__field_group, None) 
2592          yield ('icon', self.__field_icon, None) 
2593          yield ('first_last_enabled', self.__field_first_last_enabled, None) 
2594          yield ('subfield_index', self.__field_subfield_index, None) 
2595          yield ('picture_name', self.__field_picture_name, None) 
2596          yield ('dunno', self.__field_dunno, None) 
2597   
2598   
2599   
2600   
2601 -class write_pb_req(BaseProtogenClass): 
2602      __fields=['command', 'index', 'number', 'local_type', 'name', 'number_type', 'voice_tag', 'ringtone', 'backlight', 'is_primary', 'group', 'icon', 'first_last_enabled', 'subfield_index', 'picture_name'] 
2603   
2604 -    def __init__(self, *args, **kwargs): 
2605          dict={} 
2606          # What was supplied to this function 
2607          dict.update(kwargs) 
2608          # Parent constructor 
2609          super(write_pb_req,self).__init__(**dict) 
2610          if self.__class__ is write_pb_req: 
2611              self._update(args,dict) 
2612   
2613   
2614 -    def getfields(self): 
2615          return self.__fields 
2616   
2617   
2618 -    def _update(self, args, kwargs): 
2619          super(write_pb_req,self)._update(args,kwargs) 
2620          keys=kwargs.keys() 
2621          for key in keys: 
2622              if key in self.__fields: 
2623                  setattr(self, key, kwargs[key]) 
2624                  del kwargs[key] 
2625          # Were any unrecognized kwargs passed in? 
2626          if __debug__: 
2627              self._complainaboutunusedargs(write_pb_req,kwargs) 
2628          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2629          # Make all P fields that haven't already been constructed 
2630   
2631   
2632 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2633          'Writes this packet to the supplied buffer' 
2634          self._bufferstartoffset=buf.getcurrentoffset() 
2635          try: self.__field_command 
2636          except: 
2637              self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+MPBW=' }) 
2638          self.__field_command.writetobuffer(buf) 
2639          self.__field_index.writetobuffer(buf) 
2640          self.__field_number.writetobuffer(buf) 
2641          try: self.__field_local_type 
2642          except: 
2643              self.__field_local_type=CSVINT(**{ 'default': LOCAL_TYPE_LOCAL }) 
2644          self.__field_local_type.writetobuffer(buf) 
2645          self.__field_name.writetobuffer(buf) 
2646          self.__field_number_type.writetobuffer(buf) 
2647          try: self.__field_voice_tag 
2648          except: 
2649              self.__field_voice_tag=CSVINT(**{ 'default': 0 }) 
2650          self.__field_voice_tag.writetobuffer(buf) 
2651          try: self.__field_ringtone 
2652          except: 
2653              self.__field_ringtone=CSVINT(**{ 'default': 255 }) 
2654          self.__field_ringtone.writetobuffer(buf) 
2655          try: self.__field_backlight 
2656          except: 
2657              self.__field_backlight=CSVINT(**{ 'default': 0 }) 
2658          self.__field_backlight.writetobuffer(buf) 
2659          try: self.__field_is_primary 
2660          except: 
2661              self.__field_is_primary=CSVINT(**{ 'default': 0 }) 
2662          self.__field_is_primary.writetobuffer(buf) 
2663          try: self.__field_group 
2664          except: 
2665              self.__field_group=CSVINT(**{ 'default': 1 }) 
2666          self.__field_group.writetobuffer(buf) 
2667          try: self.__field_icon 
2668          except: 
2669              self.__field_icon=CSVINT(**{ 'default': 255 }) 
2670          self.__field_icon.writetobuffer(buf) 
2671          try: self.__field_first_last_enabled 
2672          except: 
2673              self.__field_first_last_enabled=CSVINT(**{ 'default': 255 }) 
2674          self.__field_first_last_enabled.writetobuffer(buf) 
2675          try: self.__field_subfield_index 
2676          except: 
2677              self.__field_subfield_index=CSVINT(**{ 'default': 0 }) 
2678          self.__field_subfield_index.writetobuffer(buf) 
2679          try: self.__field_picture_name 
2680          except: 
2681              self.__field_picture_name=CSVSTRING(**{ 'terminator': None,                  'default': "" }) 
2682          self.__field_picture_name.writetobuffer(buf) 
2683          self._bufferendoffset=buf.getcurrentoffset() 
2684          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2685   
2686   
2687 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2688          'Reads this packet from the supplied buffer' 
2689          self._bufferstartoffset=buf.getcurrentoffset() 
2690          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2691          self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+MPBW=' }) 
2692          self.__field_command.readfrombuffer(buf) 
2693          self.__field_index=CSVINT() 
2694          self.__field_index.readfrombuffer(buf) 
2695          self.__field_number=CSVSTRING(**{ 'maxsizeinbytes': PB_MAX_NUMBER_LEN,                  'raiseontruncate': False }) 
2696          self.__field_number.readfrombuffer(buf) 
2697          self.__field_local_type=CSVINT(**{ 'default': LOCAL_TYPE_LOCAL }) 
2698          self.__field_local_type.readfrombuffer(buf) 
2699          self.__field_name=CSVSTRING(**{ 'maxsizeinbytes': PB_MAX_NAME_LEN,                  'raiseontruncate': False }) 
2700          self.__field_name.readfrombuffer(buf) 
2701          self.__field_number_type=CSVINT() 
2702          self.__field_number_type.readfrombuffer(buf) 
2703          self.__field_voice_tag=CSVINT(**{ 'default': 0 }) 
2704          self.__field_voice_tag.readfrombuffer(buf) 
2705          self.__field_ringtone=CSVINT(**{ 'default': 255 }) 
2706          self.__field_ringtone.readfrombuffer(buf) 
2707          self.__field_backlight=CSVINT(**{ 'default': 0 }) 
2708          self.__field_backlight.readfrombuffer(buf) 
2709          self.__field_is_primary=CSVINT(**{ 'default': 0 }) 
2710          self.__field_is_primary.readfrombuffer(buf) 
2711          self.__field_group=CSVINT(**{ 'default': 1 }) 
2712          self.__field_group.readfrombuffer(buf) 
2713          self.__field_icon=CSVINT(**{ 'default': 255 }) 
2714          self.__field_icon.readfrombuffer(buf) 
2715          self.__field_first_last_enabled=CSVINT(**{ 'default': 255 }) 
2716          self.__field_first_last_enabled.readfrombuffer(buf) 
2717          self.__field_subfield_index=CSVINT(**{ 'default': 0 }) 
2718          self.__field_subfield_index.readfrombuffer(buf) 
2719          self.__field_picture_name=CSVSTRING(**{ 'terminator': None,                  'default': "" }) 
2720          self.__field_picture_name.readfrombuffer(buf) 
2721          self._bufferendoffset=buf.getcurrentoffset() 
2722   
2723   
2724 -    def __getfield_command(self): 
2725          try: self.__field_command 
2726          except: 
2727              self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+MPBW=' }) 
2728          return self.__field_command.getvalue() 
2729   
2730 -    def __setfield_command(self, value): 
2731          if isinstance(value,CSVSTRING): 
2732              self.__field_command=value 
2733          else: 
2734              self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None,                  'default': '+MPBW=' }) 
2735   
2736 -    def __delfield_command(self): del self.__field_command 
2737   
2738      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
2739   
2740 -    def __getfield_index(self): 
2741          return self.__field_index.getvalue() 
2742   
2743 -    def __setfield_index(self, value): 
2744          if isinstance(value,CSVINT): 
2745              self.__field_index=value 
2746          else: 
2747              self.__field_index=CSVINT(value,) 
2748   
2749 -    def __delfield_index(self): del self.__field_index 
2750   
2751      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
2752   
2753 -    def __getfield_number(self): 
2754          return self.__field_number.getvalue() 
2755   
2756 -    def __setfield_number(self, value): 
2757          if isinstance(value,CSVSTRING): 
2758              self.__field_number=value 
2759          else: 
2760              self.__field_number=CSVSTRING(value,**{ 'maxsizeinbytes': PB_MAX_NUMBER_LEN,                  'raiseontruncate': False }) 
2761   
2762 -    def __delfield_number(self): del self.__field_number 
2763   
2764      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
2765   
2766 -    def __getfield_local_type(self): 
2767          try: self.__field_local_type 
2768          except: 
2769              self.__field_local_type=CSVINT(**{ 'default': LOCAL_TYPE_LOCAL }) 
2770          return self.__field_local_type.getvalue() 
2771   
2772 -    def __setfield_local_type(self, value): 
2773          if isinstance(value,CSVINT): 
2774              self.__field_local_type=value 
2775          else: 
2776              self.__field_local_type=CSVINT(value,**{ 'default': LOCAL_TYPE_LOCAL }) 
2777   
2778 -    def __delfield_local_type(self): del self.__field_local_type 
2779   
2780      local_type=property(__getfield_local_type, __setfield_local_type, __delfield_local_type, None) 
2781   
2782 -    def __getfield_name(self): 
2783          return self.__field_name.getvalue() 
2784   
2785 -    def __setfield_name(self, value): 
2786          if isinstance(value,CSVSTRING): 
2787              self.__field_name=value 
2788          else: 
2789              self.__field_name=CSVSTRING(value,**{ 'maxsizeinbytes': PB_MAX_NAME_LEN,                  'raiseontruncate': False }) 
2790   
2791 -    def __delfield_name(self): del self.__field_name 
2792   
2793      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
2794   
2795 -    def __getfield_number_type(self): 
2796          return self.__field_number_type.getvalue() 
2797   
2798 -    def __setfield_number_type(self, value): 
2799          if isinstance(value,CSVINT): 
2800              self.__field_number_type=value 
2801          else: 
2802              self.__field_number_type=CSVINT(value,) 
2803   
2804 -    def __delfield_number_type(self): del self.__field_number_type 
2805   
2806      number_type=property(__getfield_number_type, __setfield_number_type, __delfield_number_type, None) 
2807   
2808 -    def __getfield_voice_tag(self): 
2809          try: self.__field_voice_tag 
2810          except: 
2811              self.__field_voice_tag=CSVINT(**{ 'default': 0 }) 
2812          return self.__field_voice_tag.getvalue() 
2813   
2814 -    def __setfield_voice_tag(self, value): 
2815          if isinstance(value,CSVINT): 
2816              self.__field_voice_tag=value 
2817          else: 
2818              self.__field_voice_tag=CSVINT(value,**{ 'default': 0 }) 
2819   
2820 -    def __delfield_voice_tag(self): del self.__field_voice_tag 
2821   
2822      voice_tag=property(__getfield_voice_tag, __setfield_voice_tag, __delfield_voice_tag, None) 
2823   
2824 -    def __getfield_ringtone(self): 
2825          try: self.__field_ringtone 
2826          except: 
2827              self.__field_ringtone=CSVINT(**{ 'default': 255 }) 
2828          return self.__field_ringtone.getvalue() 
2829   
2830 -    def __setfield_ringtone(self, value): 
2831          if isinstance(value,CSVINT): 
2832              self.__field_ringtone=value 
2833          else: 
2834              self.__field_ringtone=CSVINT(value,**{ 'default': 255 }) 
2835   
2836 -    def __delfield_ringtone(self): del self.__field_ringtone 
2837   
2838      ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 
2839   
2840 -    def __getfield_backlight(self): 
2841          try: self.__field_backlight 
2842          except: 
2843              self.__field_backlight=CSVINT(**{ 'default': 0 }) 
2844          return self.__field_backlight.getvalue() 
2845   
2846 -    def __setfield_backlight(self, value): 
2847          if isinstance(value,CSVINT): 
2848              self.__field_backlight=value 
2849          else: 
2850              self.__field_backlight=CSVINT(value,**{ 'default': 0 }) 
2851   
2852 -    def __delfield_backlight(self): del self.__field_backlight 
2853   
2854      backlight=property(__getfield_backlight, __setfield_backlight, __delfield_backlight, None) 
2855   
2856 -    def __getfield_is_primary(self): 
2857          try: self.__field_is_primary 
2858          except: 
2859              self.__field_is_primary=CSVINT(**{ 'default': 0 }) 
2860          return self.__field_is_primary.getvalue() 
2861   
2862 -    def __setfield_is_primary(self, value): 
2863          if isinstance(value,CSVINT): 
2864              self.__field_is_primary=value 
2865          else: 
2866              self.__field_is_primary=CSVINT(value,**{ 'default': 0 }) 
2867   
2868 -    def __delfield_is_primary(self): del self.__field_is_primary 
2869   
2870      is_primary=property(__getfield_is_primary, __setfield_is_primary, __delfield_is_primary, None) 
2871   
2872 -    def __getfield_group(self): 
2873          try: self.__field_group 
2874          except: 
2875              self.__field_group=CSVINT(**{ 'default': 1 }) 
2876          return self.__field_group.getvalue() 
2877   
2878 -    def __setfield_group(self, value): 
2879          if isinstance(value,CSVINT): 
2880              self.__field_group=value 
2881          else: 
2882              self.__field_group=CSVINT(value,**{ 'default': 1 }) 
2883   
2884 -    def __delfield_group(self): del self.__field_group 
2885   
2886      group=property(__getfield_group, __setfield_group, __delfield_group, None) 
2887   
2888 -    def __getfield_icon(self): 
2889          try: self.__field_icon 
2890          except: 
2891              self.__field_icon=CSVINT(**{ 'default': 255 }) 
2892          return self.__field_icon.getvalue() 
2893   
2894 -    def __setfield_icon(self, value): 
2895          if isinstance(value,CSVINT): 
2896              self.__field_icon=value 
2897          else: 
2898              self.__field_icon=CSVINT(value,**{ 'default': 255 }) 
2899   
2900 -    def __delfield_icon(self): del self.__field_icon 
2901   
2902      icon=property(__getfield_icon, __setfield_icon, __delfield_icon, None) 
2903   
2904 -    def __getfield_first_last_enabled(self): 
2905          try: self.__field_first_last_enabled 
2906          except: 
2907              self.__field_first_last_enabled=CSVINT(**{ 'default': 255 }) 
2908          return self.__field_first_last_enabled.getvalue() 
2909   
2910 -    def __setfield_first_last_enabled(self, value): 
2911          if isinstance(value,CSVINT): 
2912              self.__field_first_last_enabled=value 
2913          else: 
2914              self.__field_first_last_enabled=CSVINT(value,**{ 'default': 255 }) 
2915   
2916 -    def __delfield_first_last_enabled(self): del self.__field_first_last_enabled 
2917   
2918      first_last_enabled=property(__getfield_first_last_enabled, __setfield_first_last_enabled, __delfield_first_last_enabled, None) 
2919   
2920 -    def __getfield_subfield_index(self): 
2921          try: self.__field_subfield_index 
2922          except: 
2923              self.__field_subfield_index=CSVINT(**{ 'default': 0 }) 
2924          return self.__field_subfield_index.getvalue() 
2925   
2926 -    def __setfield_subfield_index(self, value): 
2927          if isinstance(value,CSVINT): 
2928              self.__field_subfield_index=value 
2929          else: 
2930              self.__field_subfield_index=CSVINT(value,**{ 'default': 0 }) 
2931   
2932 -    def __delfield_subfield_index(self): del self.__field_subfield_index 
2933   
2934      subfield_index=property(__getfield_subfield_index, __setfield_subfield_index, __delfield_subfield_index, None) 
2935   
2936 -    def __getfield_picture_name(self): 
2937          try: self.__field_picture_name 
2938          except: 
2939              self.__field_picture_name=CSVSTRING(**{ 'terminator': None,                  'default': "" }) 
2940          return self.__field_picture_name.getvalue() 
2941   
2942 -    def __setfield_picture_name(self, value): 
2943          if isinstance(value,CSVSTRING): 
2944              self.__field_picture_name=value 
2945          else: 
2946              self.__field_picture_name=CSVSTRING(value,**{ 'terminator': None,                  'default': "" }) 
2947   
2948 -    def __delfield_picture_name(self): del self.__field_picture_name 
2949   
2950      picture_name=property(__getfield_picture_name, __setfield_picture_name, __delfield_picture_name, None) 
2951   
2952 -    def iscontainer(self): 
2953          return True 
2954   
2955 -    def containerelements(self): 
2956          yield ('command', self.__field_command, None) 
2957          yield ('index', self.__field_index, None) 
2958          yield ('number', self.__field_number, None) 
2959          yield ('local_type', self.__field_local_type, None) 
2960          yield ('name', self.__field_name, None) 
2961          yield ('number_type', self.__field_number_type, None) 
2962          yield ('voice_tag', self.__field_voice_tag, None) 
2963          yield ('ringtone', self.__field_ringtone, None) 
2964          yield ('backlight', self.__field_backlight, None) 
2965          yield ('is_primary', self.__field_is_primary, None) 
2966          yield ('group', self.__field_group, None) 
2967          yield ('icon', self.__field_icon, None) 
2968          yield ('first_last_enabled', self.__field_first_last_enabled, None) 
2969          yield ('subfield_index', self.__field_subfield_index, None) 
2970          yield ('picture_name', self.__field_picture_name, None) 
2971   
2972   
2973   
2974   
2975 -class del_pb_req(BaseProtogenClass): 
2976      __fields=['command', 'index'] 
2977   
2978 -    def __init__(self, *args, **kwargs): 
2979          dict={} 
2980          # What was supplied to this function 
2981          dict.update(kwargs) 
2982          # Parent constructor 
2983          super(del_pb_req,self).__init__(**dict) 
2984          if self.__class__ is del_pb_req: 
2985              self._update(args,dict) 
2986   
2987   
2988 -    def getfields(self): 
2989          return self.__fields 
2990   
2991   
2992 -    def _update(self, args, kwargs): 
2993          super(del_pb_req,self)._update(args,kwargs) 
2994          keys=kwargs.keys() 
2995          for key in keys: 
2996              if key in self.__fields: 
2997                  setattr(self, key, kwargs[key]) 
2998                  del kwargs[key] 
2999          # Were any unrecognized kwargs passed in? 
3000          if __debug__: 
3001              self._complainaboutunusedargs(del_pb_req,kwargs) 
3002          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3003          # Make all P fields that haven't already been constructed 
3004   
3005   
3006 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3007          'Writes this packet to the supplied buffer' 
3008          self._bufferstartoffset=buf.getcurrentoffset() 
3009          try: self.__field_command 
3010          except: 
3011              self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+MPBW=' }) 
3012          self.__field_command.writetobuffer(buf) 
3013          self.__field_index.writetobuffer(buf) 
3014          self._bufferendoffset=buf.getcurrentoffset() 
3015          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3016   
3017   
3018 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3019          'Reads this packet from the supplied buffer' 
3020          self._bufferstartoffset=buf.getcurrentoffset() 
3021          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3022          self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+MPBW=' }) 
3023          self.__field_command.readfrombuffer(buf) 
3024          self.__field_index=CSVINT(**{ 'terminator': None }) 
3025          self.__field_index.readfrombuffer(buf) 
3026          self._bufferendoffset=buf.getcurrentoffset() 
3027   
3028   
3029 -    def __getfield_command(self): 
3030          try: self.__field_command 
3031          except: 
3032              self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+MPBW=' }) 
3033          return self.__field_command.getvalue() 
3034   
3035 -    def __setfield_command(self, value): 
3036          if isinstance(value,CSVSTRING): 
3037              self.__field_command=value 
3038          else: 
3039              self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None,                  'default': '+MPBW=' }) 
3040   
3041 -    def __delfield_command(self): del self.__field_command 
3042   
3043      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
3044   
3045 -    def __getfield_index(self): 
3046          return self.__field_index.getvalue() 
3047   
3048 -    def __setfield_index(self, value): 
3049          if isinstance(value,CSVINT): 
3050              self.__field_index=value 
3051          else: 
3052              self.__field_index=CSVINT(value,**{ 'terminator': None }) 
3053   
3054 -    def __delfield_index(self): del self.__field_index 
3055   
3056      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
3057   
3058 -    def iscontainer(self): 
3059          return True 
3060   
3061 -    def containerelements(self): 
3062          yield ('command', self.__field_command, None) 
3063          yield ('index', self.__field_index, None) 
3064   
3065   
3066   
3067   
3068 -class sms_sel_req(BaseProtogenClass): 
3069      __fields=['command', 'mem1', 'mem2', 'mem3'] 
3070   
3071 -    def __init__(self, *args, **kwargs): 
3072          dict={} 
3073          # What was supplied to this function 
3074          dict.update(kwargs) 
3075          # Parent constructor 
3076          super(sms_sel_req,self).__init__(**dict) 
3077          if self.__class__ is sms_sel_req: 
3078              self._update(args,dict) 
3079   
3080   
3081 -    def getfields(self): 
3082          return self.__fields 
3083   
3084   
3085 -    def _update(self, args, kwargs): 
3086          super(sms_sel_req,self)._update(args,kwargs) 
3087          keys=kwargs.keys() 
3088          for key in keys: 
3089              if key in self.__fields: 
3090                  setattr(self, key, kwargs[key]) 
3091                  del kwargs[key] 
3092          # Were any unrecognized kwargs passed in? 
3093          if __debug__: 
3094              self._complainaboutunusedargs(sms_sel_req,kwargs) 
3095          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3096          # Make all P fields that haven't already been constructed 
3097   
3098   
3099 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3100          'Writes this packet to the supplied buffer' 
3101          self._bufferstartoffset=buf.getcurrentoffset() 
3102          try: self.__field_command 
3103          except: 
3104              self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+CPMS=' }) 
3105          self.__field_command.writetobuffer(buf) 
3106          try: self.__field_mem1 
3107          except: 
3108              self.__field_mem1=CSVSTRING(**{ 'default': SMS_COMBINE }) 
3109          self.__field_mem1.writetobuffer(buf) 
3110          try: self.__field_mem2 
3111          except: 
3112              self.__field_mem2=CSVSTRING(**{ 'default': SMS_OUTBOX }) 
3113          self.__field_mem2.writetobuffer(buf) 
3114          try: self.__field_mem3 
3115          except: 
3116              self.__field_mem3=CSVSTRING(**{ 'terminator': None,                  'default': SMS_INBOX }) 
3117          self.__field_mem3.writetobuffer(buf) 
3118          self._bufferendoffset=buf.getcurrentoffset() 
3119          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3120   
3121   
3122 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3123          'Reads this packet from the supplied buffer' 
3124          self._bufferstartoffset=buf.getcurrentoffset() 
3125          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3126          self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+CPMS=' }) 
3127          self.__field_command.readfrombuffer(buf) 
3128          self.__field_mem1=CSVSTRING(**{ 'default': SMS_COMBINE }) 
3129          self.__field_mem1.readfrombuffer(buf) 
3130          self.__field_mem2=CSVSTRING(**{ 'default': SMS_OUTBOX }) 
3131          self.__field_mem2.readfrombuffer(buf) 
3132          self.__field_mem3=CSVSTRING(**{ 'terminator': None,                  'default': SMS_INBOX }) 
3133          self.__field_mem3.readfrombuffer(buf) 
3134          self._bufferendoffset=buf.getcurrentoffset() 
3135   
3136   
3137 -    def __getfield_command(self): 
3138          try: self.__field_command 
3139          except: 
3140              self.__field_command=CSVSTRING(**{ 'quotechar': None, 'terminator': None,                  'default': '+CPMS=' }) 
3141          return self.__field_command.getvalue() 
3142   
3143 -    def __setfield_command(self, value): 
3144          if isinstance(value,CSVSTRING): 
3145              self.__field_command=value 
3146          else: 
3147              self.__field_command=CSVSTRING(value,**{ 'quotechar': None, 'terminator': None,                  'default': '+CPMS=' }) 
3148   
3149 -    def __delfield_command(self): del self.__field_command 
3150   
3151      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
3152   
3153 -    def __getfield_mem1(self): 
3154          try: self.__field_mem1 
3155          except: 
3156              self.__field_mem1=CSVSTRING(**{ 'default': SMS_COMBINE }) 
3157          return self.__field_mem1.getvalue() 
3158   
3159 -    def __setfield_mem1(self, value): 
3160          if isinstance(value,CSVSTRING): 
3161              self.__field_mem1=value 
3162          else: 
3163              self.__field_mem1=CSVSTRING(value,**{ 'default': SMS_COMBINE }) 
3164   
3165 -    def __delfield_mem1(self): del self.__field_mem1 
3166   
3167      mem1=property(__getfield_mem1, __setfield_mem1, __delfield_mem1, None) 
3168   
3169 -    def __getfield_mem2(self): 
3170          try: self.__field_mem2 
3171          except: 
3172              self.__field_mem2=CSVSTRING(**{ 'default': SMS_OUTBOX }) 
3173          return self.__field_mem2.getvalue() 
3174   
3175 -    def __setfield_mem2(self, value): 
3176          if isinstance(value,CSVSTRING): 
3177              self.__field_mem2=value 
3178          else: 
3179              self.__field_mem2=CSVSTRING(value,**{ 'default': SMS_OUTBOX }) 
3180   
3181 -    def __delfield_mem2(self): del self.__field_mem2 
3182   
3183      mem2=property(__getfield_mem2, __setfield_mem2, __delfield_mem2, None) 
3184   
3185 -    def __getfield_mem3(self): 
3186          try: self.__field_mem3 
3187          except: 
3188              self.__field_mem3=CSVSTRING(**{ 'terminator': None,                  'default': SMS_INBOX }) 
3189          return self.__field_mem3.getvalue() 
3190   
3191 -    def __setfield_mem3(self, value): 
3192          if isinstance(value,CSVSTRING): 
3193              self.__field_mem3=value 
3194          else: 
3195              self.__field_mem3=CSVSTRING(value,**{ 'terminator': None,                  'default': SMS_INBOX }) 
3196   
3197 -    def __delfield_mem3(self): del self.__field_mem3 
3198   
3199      mem3=property(__getfield_mem3, __setfield_mem3, __delfield_mem3, None) 
3200   
3201 -    def iscontainer(self): 
3202          return True 
3203   
3204 -    def containerelements(self): 
3205          yield ('command', self.__field_command, None) 
3206          yield ('mem1', self.__field_mem1, None) 
3207          yield ('mem2', self.__field_mem2, None) 
3208          yield ('mem3', self.__field_mem3, None) 
3209   
3210   
3211   
3212   
3213 -class sms_m_read_resp(BaseProtogenClass): 
3214      __fields=['command', 'has_date', 'date_terminated', 'sms_type', 'sms_addr', 'sms_date', 'sms_date', 'sms_addr'] 
3215   
3216 -    def __init__(self, *args, **kwargs): 
3217          dict={} 
3218          # What was supplied to this function 
3219          dict.update(kwargs) 
3220          # Parent constructor 
3221          super(sms_m_read_resp,self).__init__(**dict) 
3222          if self.__class__ is sms_m_read_resp: 
3223              self._update(args,dict) 
3224   
3225   
3226 -    def getfields(self): 
3227          return self.__fields 
3228   
3229   
3230 -    def _update(self, args, kwargs): 
3231          super(sms_m_read_resp,self)._update(args,kwargs) 
3232          keys=kwargs.keys() 
3233          for key in keys: 
3234              if key in self.__fields: 
3235                  setattr(self, key, kwargs[key]) 
3236                  del kwargs[key] 
3237          # Were any unrecognized kwargs passed in? 
3238          if __debug__: 
3239              self._complainaboutunusedargs(sms_m_read_resp,kwargs) 
3240          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3241          # Make all P fields that haven't already been constructed 
3242          try: self.__field_has_date 
3243          except: 
3244              self.__field_has_date=BOOL(**{ 'default': True }) 
3245          try: self.__field_date_terminated 
3246          except: 
3247              self.__field_date_terminated=BOOL(**{ 'default': False }) 
3248   
3249   
3250 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3251          'Writes this packet to the supplied buffer' 
3252          self._bufferstartoffset=buf.getcurrentoffset() 
3253          self.__field_command.writetobuffer(buf) 
3254          self.__field_sms_type.writetobuffer(buf) 
3255          if self.has_date: 
3256              self.__field_sms_addr.writetobuffer(buf) 
3257              if self.date_terminated: 
3258                  self.__field_sms_date.writetobuffer(buf) 
3259              else: 
3260                  self.__field_sms_date.writetobuffer(buf) 
3261          else: 
3262              self.__field_sms_addr.writetobuffer(buf) 
3263          self._bufferendoffset=buf.getcurrentoffset() 
3264          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3265   
3266   
3267 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3268          'Reads this packet from the supplied buffer' 
3269          self._bufferstartoffset=buf.getcurrentoffset() 
3270          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3271          self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': ord(' '),                  'default': '+MMGR:' }) 
3272          self.__field_command.readfrombuffer(buf) 
3273          self.__field_sms_type=CSVSTRING() 
3274          self.__field_sms_type.readfrombuffer(buf) 
3275          if self.has_date: 
3276              self.__field_sms_addr=CSVSTRING(**{ 'quotechar': None }) 
3277              self.__field_sms_addr.readfrombuffer(buf) 
3278              if self.date_terminated: 
3279                  self.__field_sms_date=M_SMSDATETIME() 
3280                  self.__field_sms_date.readfrombuffer(buf) 
3281              else: 
3282                  self.__field_sms_date=M_SMSDATETIME(**{ 'quotechar': None,                              'terminator': None }) 
3283                  self.__field_sms_date.readfrombuffer(buf) 
3284          else: 
3285              self.__field_sms_addr=CSVSTRING(**{ 'terminator': None,                      'quotechar': None }) 
3286              self.__field_sms_addr.readfrombuffer(buf) 
3287          self._bufferendoffset=buf.getcurrentoffset() 
3288   
3289   
3290 -    def __getfield_command(self): 
3291          return self.__field_command.getvalue() 
3292   
3293 -    def __setfield_command(self, value): 
3294          if isinstance(value,CSVSTRING): 
3295              self.__field_command=value 
3296          else: 
3297              self.__field_command=CSVSTRING(value,**{ 'quotechar': None,                  'terminator': ord(' '),                  'default': '+MMGR:' }) 
3298   
3299 -    def __delfield_command(self): del self.__field_command 
3300   
3301      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
3302   
3303 -    def __getfield_has_date(self): 
3304          try: self.__field_has_date 
3305          except: 
3306              self.__field_has_date=BOOL(**{ 'default': True }) 
3307          return self.__field_has_date.getvalue() 
3308   
3309 -    def __setfield_has_date(self, value): 
3310          if isinstance(value,BOOL): 
3311              self.__field_has_date=value 
3312          else: 
3313              self.__field_has_date=BOOL(value,**{ 'default': True }) 
3314   
3315 -    def __delfield_has_date(self): del self.__field_has_date 
3316   
3317      has_date=property(__getfield_has_date, __setfield_has_date, __delfield_has_date, None) 
3318   
3319 -    def __getfield_date_terminated(self): 
3320          try: self.__field_date_terminated 
3321          except: 
3322              self.__field_date_terminated=BOOL(**{ 'default': False }) 
3323          return self.__field_date_terminated.getvalue() 
3324   
3325 -    def __setfield_date_terminated(self, value): 
3326          if isinstance(value,BOOL): 
3327              self.__field_date_terminated=value 
3328          else: 
3329              self.__field_date_terminated=BOOL(value,**{ 'default': False }) 
3330   
3331 -    def __delfield_date_terminated(self): del self.__field_date_terminated 
3332   
3333      date_terminated=property(__getfield_date_terminated, __setfield_date_terminated, __delfield_date_terminated, None) 
3334   
3335 -    def __getfield_sms_type(self): 
3336          return self.__field_sms_type.getvalue() 
3337   
3338 -    def __setfield_sms_type(self, value): 
3339          if isinstance(value,CSVSTRING): 
3340              self.__field_sms_type=value 
3341          else: 
3342              self.__field_sms_type=CSVSTRING(value,) 
3343   
3344 -    def __delfield_sms_type(self): del self.__field_sms_type 
3345   
3346      sms_type=property(__getfield_sms_type, __setfield_sms_type, __delfield_sms_type, None) 
3347   
3348 -    def __getfield_sms_addr(self): 
3349          return self.__field_sms_addr.getvalue() 
3350   
3351 -    def __setfield_sms_addr(self, value): 
3352          if isinstance(value,CSVSTRING): 
3353              self.__field_sms_addr=value 
3354          else: 
3355              self.__field_sms_addr=CSVSTRING(value,**{ 'quotechar': None }) 
3356   
3357 -    def __delfield_sms_addr(self): del self.__field_sms_addr 
3358   
3359      sms_addr=property(__getfield_sms_addr, __setfield_sms_addr, __delfield_sms_addr, None) 
3360   
3361 -    def __getfield_sms_date(self): 
3362          return self.__field_sms_date.getvalue() 
3363   
3364 -    def __setfield_sms_date(self, value): 
3365          if isinstance(value,M_SMSDATETIME): 
3366              self.__field_sms_date=value 
3367          else: 
3368              self.__field_sms_date=M_SMSDATETIME(value,) 
3369   
3370 -    def __delfield_sms_date(self): del self.__field_sms_date 
3371   
3372      sms_date=property(__getfield_sms_date, __setfield_sms_date, __delfield_sms_date, None) 
3373   
3374 -    def __getfield_sms_date(self): 
3375          return self.__field_sms_date.getvalue() 
3376   
3377 -    def __setfield_sms_date(self, value): 
3378          if isinstance(value,M_SMSDATETIME): 
3379              self.__field_sms_date=value 
3380          else: 
3381              self.__field_sms_date=M_SMSDATETIME(value,**{ 'quotechar': None,                              'terminator': None }) 
3382   
3383 -    def __delfield_sms_date(self): del self.__field_sms_date 
3384   
3385      sms_date=property(__getfield_sms_date, __setfield_sms_date, __delfield_sms_date, None) 
3386   
3387 -    def __getfield_sms_addr(self): 
3388          return self.__field_sms_addr.getvalue() 
3389   
3390 -    def __setfield_sms_addr(self, value): 
3391          if isinstance(value,CSVSTRING): 
3392              self.__field_sms_addr=value 
3393          else: 
3394              self.__field_sms_addr=CSVSTRING(value,**{ 'terminator': None,                      'quotechar': None }) 
3395   
3396 -    def __delfield_sms_addr(self): del self.__field_sms_addr 
3397   
3398      sms_addr=property(__getfield_sms_addr, __setfield_sms_addr, __delfield_sms_addr, None) 
3399   
3400 -    def iscontainer(self): 
3401          return True 
3402   
3403 -    def containerelements(self): 
3404          yield ('command', self.__field_command, None) 
3405          yield ('has_date', self.__field_has_date, None) 
3406          yield ('date_terminated', self.__field_date_terminated, None) 
3407          yield ('sms_type', self.__field_sms_type, None) 
3408          if self.has_date: 
3409              yield ('sms_addr', self.__field_sms_addr, None) 
3410              if self.date_terminated: 
3411                  yield ('sms_date', self.__field_sms_date, None) 
3412              else: 
3413                  yield ('sms_date', self.__field_sms_date, None) 
3414          else: 
3415              yield ('sms_addr', self.__field_sms_addr, None) 
3416   
3417   
3418   
3419   
3420 -class sms_list_req(BaseProtogenClass): 
3421      __fields=['command', 'listtype'] 
3422   
3423 -    def __init__(self, *args, **kwargs): 
3424          dict={} 
3425          # What was supplied to this function 
3426          dict.update(kwargs) 
3427          # Parent constructor 
3428          super(sms_list_req,self).__init__(**dict) 
3429          if self.__class__ is sms_list_req: 
3430              self._update(args,dict) 
3431   
3432   
3433 -    def getfields(self): 
3434          return self.__fields 
3435   
3436   
3437 -    def _update(self, args, kwargs): 
3438          super(sms_list_req,self)._update(args,kwargs) 
3439          keys=kwargs.keys() 
3440          for key in keys: 
3441              if key in self.__fields: 
3442                  setattr(self, key, kwargs[key]) 
3443                  del kwargs[key] 
3444          # Were any unrecognized kwargs passed in? 
3445          if __debug__: 
3446              self._complainaboutunusedargs(sms_list_req,kwargs) 
3447          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3448          # Make all P fields that haven't already been constructed 
3449   
3450   
3451 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3452          'Writes this packet to the supplied buffer' 
3453          self._bufferstartoffset=buf.getcurrentoffset() 
3454          try: self.__field_command 
3455          except: 
3456              self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': None,                  'default': '+MMGL=' }) 
3457          self.__field_command.writetobuffer(buf) 
3458          try: self.__field_listtype 
3459          except: 
3460              self.__field_listtype=CSVSTRING(**{ 'terminator': None,                  'default': SMS_HEADER_ONLY }) 
3461          self.__field_listtype.writetobuffer(buf) 
3462          self._bufferendoffset=buf.getcurrentoffset() 
3463          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3464   
3465   
3466 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3467          'Reads this packet from the supplied buffer' 
3468          self._bufferstartoffset=buf.getcurrentoffset() 
3469          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3470          self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': None,                  'default': '+MMGL=' }) 
3471          self.__field_command.readfrombuffer(buf) 
3472          self.__field_listtype=CSVSTRING(**{ 'terminator': None,                  'default': SMS_HEADER_ONLY }) 
3473          self.__field_listtype.readfrombuffer(buf) 
3474          self._bufferendoffset=buf.getcurrentoffset() 
3475   
3476   
3477 -    def __getfield_command(self): 
3478          try: self.__field_command 
3479          except: 
3480              self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': None,                  'default': '+MMGL=' }) 
3481          return self.__field_command.getvalue() 
3482   
3483 -    def __setfield_command(self, value): 
3484          if isinstance(value,CSVSTRING): 
3485              self.__field_command=value 
3486          else: 
3487              self.__field_command=CSVSTRING(value,**{ 'quotechar': None,                  'terminator': None,                  'default': '+MMGL=' }) 
3488   
3489 -    def __delfield_command(self): del self.__field_command 
3490   
3491      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
3492   
3493 -    def __getfield_listtype(self): 
3494          try: self.__field_listtype 
3495          except: 
3496              self.__field_listtype=CSVSTRING(**{ 'terminator': None,                  'default': SMS_HEADER_ONLY }) 
3497          return self.__field_listtype.getvalue() 
3498   
3499 -    def __setfield_listtype(self, value): 
3500          if isinstance(value,CSVSTRING): 
3501              self.__field_listtype=value 
3502          else: 
3503              self.__field_listtype=CSVSTRING(value,**{ 'terminator': None,                  'default': SMS_HEADER_ONLY }) 
3504   
3505 -    def __delfield_listtype(self): del self.__field_listtype 
3506   
3507      listtype=property(__getfield_listtype, __setfield_listtype, __delfield_listtype, None) 
3508   
3509 -    def iscontainer(self): 
3510          return True 
3511   
3512 -    def containerelements(self): 
3513          yield ('command', self.__field_command, None) 
3514          yield ('listtype', self.__field_listtype, None) 
3515   
3516   
3517   
3518   
3519 -class sms_list_resp(BaseProtogenClass): 
3520      __fields=['command', 'index', 'dontcare'] 
3521   
3522 -    def __init__(self, *args, **kwargs): 
3523          dict={} 
3524          # What was supplied to this function 
3525          dict.update(kwargs) 
3526          # Parent constructor 
3527          super(sms_list_resp,self).__init__(**dict) 
3528          if self.__class__ is sms_list_resp: 
3529              self._update(args,dict) 
3530   
3531   
3532 -    def getfields(self): 
3533          return self.__fields 
3534   
3535   
3536 -    def _update(self, args, kwargs): 
3537          super(sms_list_resp,self)._update(args,kwargs) 
3538          keys=kwargs.keys() 
3539          for key in keys: 
3540              if key in self.__fields: 
3541                  setattr(self, key, kwargs[key]) 
3542                  del kwargs[key] 
3543          # Were any unrecognized kwargs passed in? 
3544          if __debug__: 
3545              self._complainaboutunusedargs(sms_list_resp,kwargs) 
3546          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3547          # Make all P fields that haven't already been constructed 
3548   
3549   
3550 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3551          'Writes this packet to the supplied buffer' 
3552          self._bufferstartoffset=buf.getcurrentoffset() 
3553          self.__field_command.writetobuffer(buf) 
3554          self.__field_index.writetobuffer(buf) 
3555          self.__field_dontcare.writetobuffer(buf) 
3556          self._bufferendoffset=buf.getcurrentoffset() 
3557          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3558   
3559   
3560 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3561          'Reads this packet from the supplied buffer' 
3562          self._bufferstartoffset=buf.getcurrentoffset() 
3563          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3564          self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': ord(' '),                  'default': '+MMGL:' }) 
3565          self.__field_command.readfrombuffer(buf) 
3566          self.__field_index=CSVINT() 
3567          self.__field_index.readfrombuffer(buf) 
3568          self.__field_dontcare=DATA() 
3569          self.__field_dontcare.readfrombuffer(buf) 
3570          self._bufferendoffset=buf.getcurrentoffset() 
3571   
3572   
3573 -    def __getfield_command(self): 
3574          return self.__field_command.getvalue() 
3575   
3576 -    def __setfield_command(self, value): 
3577          if isinstance(value,CSVSTRING): 
3578              self.__field_command=value 
3579          else: 
3580              self.__field_command=CSVSTRING(value,**{ 'quotechar': None,                  'terminator': ord(' '),                  'default': '+MMGL:' }) 
3581   
3582 -    def __delfield_command(self): del self.__field_command 
3583   
3584      command=property(__getfield_command, __setfield_command, __delfield_command, None) 
3585   
3586 -    def __getfield_index(self): 
3587          return self.__field_index.getvalue() 
3588   
3589 -    def __setfield_index(self, value): 
3590          if isinstance(value,CSVINT): 
3591              self.__field_index=value 
3592          else: 
3593              self.__field_index=CSVINT(value,) 
3594   
3595 -    def __delfield_index(self): del self.__field_index 
3596   
3597      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
3598   
3599 -    def __getfield_dontcare(self): 
3600          return self.__field_dontcare.getvalue() 
3601   
3602 -    def __setfield_dontcare(self, value): 
3603          if isinstance(value,DATA): 
3604              self.__field_dontcare=value 
3605          else: 
3606              self.__field_dontcare=DATA(value,) 
3607   
3608 -    def __delfield_dontcare(self): del self.__field_dontcare 
3609   
3610      dontcare=property(__getfield_dontcare, __setfield_dontcare, __delfield_dontcare, None) 
3611   
3612 -    def iscontainer(self): 
3613          return True 
3614   
3615 -    def containerelements(self): 
3616          yield ('command', self.__field_command, None) 
3617          yield ('index', self.__field_index, None) 
3618          yield ('dontcare', self.__field_dontcare, None) 
3619