Subversion Repositories SmartDukaan

Rev

Rev 130 | Rev 513 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
94 ashish 1 
#
2 
# Autogenerated by Thrift
3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
8 
from ttypes import *
9 
from thrift.Thrift import TProcessor
10 
from thrift.transport import TTransport
11 
from thrift.protocol import TBinaryProtocol
12 
try:
13 
  from thrift.protocol import fastbinary
14 
except:
15 
  fastbinary = None
16 
 
17 
 
18 
class Iface:
19 
  """
20 
  service
21 
  """
22 
  def createContext(self, context, updateExisting):
23 
    """
24 
    Parameters:
25 
     - context
26 
     - updateExisting
27 
    """
28 
    pass
29 
 
122 ashish 30 
  def getContextFromId(self, userId, isSessionId):
94 ashish 31 
    """
32 
    Parameters:
33 
     - userId
122 ashish 34 
     - isSessionId
94 ashish 35 
    """
36 
    pass
37 
 
38 
  def getContextFromEmailOrHandle(self, emailorhandle, isEmail):
39 
    """
40 
    Parameters:
41 
     - emailorhandle
42 
     - isEmail
43 
    """
44 
    pass
45 
 
122 ashish 46 
  def getState(self, userId, isSessionId):
94 ashish 47 
    """
48 
    Parameters:
49 
     - userId
122 ashish 50 
     - isSessionId
94 ashish 51 
    """
52 
    pass
53 
 
122 ashish 54 
  def getPrimaryInfo(self, userId, isSessionId):
94 ashish 55 
    """
56 
    Parameters:
57 
     - userId
122 ashish 58 
     - isSessionId
94 ashish 59 
    """
60 
    pass
61 
 
122 ashish 62 
  def getInternalInfo(self, userId, isSessionId):
94 ashish 63 
    """
64 
    Parameters:
65 
     - userId
122 ashish 66 
     - isSessionId
94 ashish 67 
    """
68 
    pass
69 
 
70 
  def getContext(self, email, password):
71 
    """
72 
    Parameters:
73 
     - email
74 
     - password
75 
    """
76 
    pass
77 
 
122 ashish 78 
  def authenticateUser(self, handle, password, isEmail):
79 
    """
80 
    Parameters:
81 
     - handle
82 
     - password
83 
     - isEmail
84 
    """
85 
    pass
86 
 
94 ashish 87 
  def userExists(self, email):
88 
    """
89 
    Parameters:
90 
     - email
91 
    """
92 
    pass
93 
 
94 
  def addIpAdressForUser(self, ip, timestamp, userId):
95 
    """
96 
    Parameters:
97 
     - ip
98 
     - timestamp
99 
     - userId
100 
    """
101 
    pass
102 
 
103 
  def addAddressForUser(self, address, userid, timestamp):
104 
    """
105 
    Parameters:
106 
     - address
107 
     - userid
108 
     - timestamp
109 
    """
110 
    pass
111 
 
112 
  def removeAddressForUser(self, userid, addressId):
113 
    """
114 
    Parameters:
115 
     - userid
116 
     - addressId
117 
    """
118 
    pass
119 
 
120 
  def setUserAsLoggedIn(self, userId, timestamp):
121 
    """
122 
    Parameters:
123 
     - userId
124 
     - timestamp
125 
    """
126 
    pass
127 
 
128 
  def setUserAsLoggedOut(self, userid, timestamp):
129 
    """
130 
    Parameters:
131 
     - userid
132 
     - timestamp
133 
    """
134 
    pass
135 
 
504 rajveer 136 
  def setDefaultAddress(self, userid, addressId):
137 
    """
138 
    Parameters:
139 
     - userid
140 
     - addressId
141 
    """
142 
    pass
143 
 
94 ashish 144 
  def updatePassword(self, userid, password):
145 
    """
146 
    Parameters:
147 
     - userid
148 
     - password
149 
    """
150 
    pass
151 
 
122 ashish 152 
  def deleteUser(self, userid, isSessionId):
94 ashish 153 
    """
154 
    Parameters:
155 
     - userid
122 ashish 156 
     - isSessionId
94 ashish 157 
    """
158 
    pass
159 
 
160 
  def sendEmailVerification(self, userid):
161 
    """
162 
    Parameters:
163 
     - userid
164 
    """
165 
    pass
166 
 
167 
  def sendSMSVerification(self, userid):
168 
    """
169 
    Parameters:
170 
     - userid
171 
    """
172 
    pass
173 
 
174 
  def confirmEmailVerification(self, userid):
175 
    """
176 
    Parameters:
177 
     - userid
178 
    """
179 
    pass
180 
 
181 
  def confirmSMSVerification(self, userid):
182 
    """
183 
    Parameters:
184 
     - userid
185 
    """
186 
    pass
187 
 
188 
  def addSocialhandle(self, userid, socialService, handle):
189 
    """
190 
    Parameters:
191 
     - userid
192 
     - socialService
193 
     - handle
194 
    """
195 
    pass
196 
 
130 ashish 197 
  def sendNewPasswordById(self, userid):
198 
    """
199 
    Parameters:
200 
     - userid
201 
    """
202 
    pass
94 ashish 203 
 
130 ashish 204 
  def sendNewPasswordByHandle(self, emailOrHandle, isEmail):
205 
    """
206 
    Parameters:
207 
     - emailOrHandle
208 
     - isEmail
209 
    """
210 
    pass
211 
 
212 
 
94 ashish 213 
class Client(Iface):
214 
  """
215 
  service
216 
  """
217 
  def __init__(self, iprot, oprot=None):
218 
    self._iprot = self._oprot = iprot
219 
    if oprot != None:
220 
      self._oprot = oprot
221 
    self._seqid = 0
222 
 
223 
  def createContext(self, context, updateExisting):
224 
    """
225 
    Parameters:
226 
     - context
227 
     - updateExisting
228 
    """
229 
    self.send_createContext(context, updateExisting)
230 
    return self.recv_createContext()
231 
 
232 
  def send_createContext(self, context, updateExisting):
233 
    self._oprot.writeMessageBegin('createContext', TMessageType.CALL, self._seqid)
234 
    args = createContext_args()
235 
    args.context = context
236 
    args.updateExisting = updateExisting
237 
    args.write(self._oprot)
238 
    self._oprot.writeMessageEnd()
239 
    self._oprot.trans.flush()
240 
 
241 
  def recv_createContext(self, ):
242 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
243 
    if mtype == TMessageType.EXCEPTION:
244 
      x = TApplicationException()
245 
      x.read(self._iprot)
246 
      self._iprot.readMessageEnd()
247 
      raise x
248 
    result = createContext_result()
249 
    result.read(self._iprot)
250 
    self._iprot.readMessageEnd()
251 
    if result.success != None:
252 
      return result.success
253 
    if result.cex != None:
254 
      raise result.cex
255 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createContext failed: unknown result");
256 
 
122 ashish 257 
  def getContextFromId(self, userId, isSessionId):
94 ashish 258 
    """
259 
    Parameters:
260 
     - userId
122 ashish 261 
     - isSessionId
94 ashish 262 
    """
122 ashish 263 
    self.send_getContextFromId(userId, isSessionId)
94 ashish 264 
    return self.recv_getContextFromId()
265 
 
122 ashish 266 
  def send_getContextFromId(self, userId, isSessionId):
94 ashish 267 
    self._oprot.writeMessageBegin('getContextFromId', TMessageType.CALL, self._seqid)
268 
    args = getContextFromId_args()
269 
    args.userId = userId
122 ashish 270 
    args.isSessionId = isSessionId
94 ashish 271 
    args.write(self._oprot)
272 
    self._oprot.writeMessageEnd()
273 
    self._oprot.trans.flush()
274 
 
275 
  def recv_getContextFromId(self, ):
276 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
277 
    if mtype == TMessageType.EXCEPTION:
278 
      x = TApplicationException()
279 
      x.read(self._iprot)
280 
      self._iprot.readMessageEnd()
281 
      raise x
282 
    result = getContextFromId_result()
283 
    result.read(self._iprot)
284 
    self._iprot.readMessageEnd()
285 
    if result.success != None:
286 
      return result.success
287 
    if result.ucx != None:
288 
      raise result.ucx
289 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getContextFromId failed: unknown result");
290 
 
291 
  def getContextFromEmailOrHandle(self, emailorhandle, isEmail):
292 
    """
293 
    Parameters:
294 
     - emailorhandle
295 
     - isEmail
296 
    """
297 
    self.send_getContextFromEmailOrHandle(emailorhandle, isEmail)
298 
    return self.recv_getContextFromEmailOrHandle()
299 
 
300 
  def send_getContextFromEmailOrHandle(self, emailorhandle, isEmail):
301 
    self._oprot.writeMessageBegin('getContextFromEmailOrHandle', TMessageType.CALL, self._seqid)
302 
    args = getContextFromEmailOrHandle_args()
303 
    args.emailorhandle = emailorhandle
304 
    args.isEmail = isEmail
305 
    args.write(self._oprot)
306 
    self._oprot.writeMessageEnd()
307 
    self._oprot.trans.flush()
308 
 
309 
  def recv_getContextFromEmailOrHandle(self, ):
310 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
311 
    if mtype == TMessageType.EXCEPTION:
312 
      x = TApplicationException()
313 
      x.read(self._iprot)
314 
      self._iprot.readMessageEnd()
315 
      raise x
316 
    result = getContextFromEmailOrHandle_result()
317 
    result.read(self._iprot)
318 
    self._iprot.readMessageEnd()
319 
    if result.success != None:
320 
      return result.success
321 
    if result.ucx != None:
322 
      raise result.ucx
323 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getContextFromEmailOrHandle failed: unknown result");
324 
 
122 ashish 325 
  def getState(self, userId, isSessionId):
94 ashish 326 
    """
327 
    Parameters:
328 
     - userId
122 ashish 329 
     - isSessionId
94 ashish 330 
    """
122 ashish 331 
    self.send_getState(userId, isSessionId)
94 ashish 332 
    return self.recv_getState()
333 
 
122 ashish 334 
  def send_getState(self, userId, isSessionId):
94 ashish 335 
    self._oprot.writeMessageBegin('getState', TMessageType.CALL, self._seqid)
336 
    args = getState_args()
337 
    args.userId = userId
122 ashish 338 
    args.isSessionId = isSessionId
94 ashish 339 
    args.write(self._oprot)
340 
    self._oprot.writeMessageEnd()
341 
    self._oprot.trans.flush()
342 
 
343 
  def recv_getState(self, ):
344 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
345 
    if mtype == TMessageType.EXCEPTION:
346 
      x = TApplicationException()
347 
      x.read(self._iprot)
348 
      self._iprot.readMessageEnd()
349 
      raise x
350 
    result = getState_result()
351 
    result.read(self._iprot)
352 
    self._iprot.readMessageEnd()
353 
    if result.success != None:
354 
      return result.success
355 
    if result.ucx != None:
356 
      raise result.ucx
357 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getState failed: unknown result");
358 
 
122 ashish 359 
  def getPrimaryInfo(self, userId, isSessionId):
94 ashish 360 
    """
361 
    Parameters:
362 
     - userId
122 ashish 363 
     - isSessionId
94 ashish 364 
    """
122 ashish 365 
    self.send_getPrimaryInfo(userId, isSessionId)
94 ashish 366 
    return self.recv_getPrimaryInfo()
367 
 
122 ashish 368 
  def send_getPrimaryInfo(self, userId, isSessionId):
94 ashish 369 
    self._oprot.writeMessageBegin('getPrimaryInfo', TMessageType.CALL, self._seqid)
370 
    args = getPrimaryInfo_args()
371 
    args.userId = userId
122 ashish 372 
    args.isSessionId = isSessionId
94 ashish 373 
    args.write(self._oprot)
374 
    self._oprot.writeMessageEnd()
375 
    self._oprot.trans.flush()
376 
 
377 
  def recv_getPrimaryInfo(self, ):
378 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
379 
    if mtype == TMessageType.EXCEPTION:
380 
      x = TApplicationException()
381 
      x.read(self._iprot)
382 
      self._iprot.readMessageEnd()
383 
      raise x
384 
    result = getPrimaryInfo_result()
385 
    result.read(self._iprot)
386 
    self._iprot.readMessageEnd()
387 
    if result.success != None:
388 
      return result.success
389 
    if result.ucx != None:
390 
      raise result.ucx
391 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrimaryInfo failed: unknown result");
392 
 
122 ashish 393 
  def getInternalInfo(self, userId, isSessionId):
94 ashish 394 
    """
395 
    Parameters:
396 
     - userId
122 ashish 397 
     - isSessionId
94 ashish 398 
    """
122 ashish 399 
    self.send_getInternalInfo(userId, isSessionId)
94 ashish 400 
    return self.recv_getInternalInfo()
401 
 
122 ashish 402 
  def send_getInternalInfo(self, userId, isSessionId):
94 ashish 403 
    self._oprot.writeMessageBegin('getInternalInfo', TMessageType.CALL, self._seqid)
404 
    args = getInternalInfo_args()
405 
    args.userId = userId
122 ashish 406 
    args.isSessionId = isSessionId
94 ashish 407 
    args.write(self._oprot)
408 
    self._oprot.writeMessageEnd()
409 
    self._oprot.trans.flush()
410 
 
411 
  def recv_getInternalInfo(self, ):
412 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
413 
    if mtype == TMessageType.EXCEPTION:
414 
      x = TApplicationException()
415 
      x.read(self._iprot)
416 
      self._iprot.readMessageEnd()
417 
      raise x
418 
    result = getInternalInfo_result()
419 
    result.read(self._iprot)
420 
    self._iprot.readMessageEnd()
421 
    if result.success != None:
422 
      return result.success
423 
    if result.ucx != None:
424 
      raise result.ucx
425 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInternalInfo failed: unknown result");
426 
 
427 
  def getContext(self, email, password):
428 
    """
429 
    Parameters:
430 
     - email
431 
     - password
432 
    """
433 
    self.send_getContext(email, password)
434 
    return self.recv_getContext()
435 
 
436 
  def send_getContext(self, email, password):
437 
    self._oprot.writeMessageBegin('getContext', TMessageType.CALL, self._seqid)
438 
    args = getContext_args()
439 
    args.email = email
440 
    args.password = password
441 
    args.write(self._oprot)
442 
    self._oprot.writeMessageEnd()
443 
    self._oprot.trans.flush()
444 
 
445 
  def recv_getContext(self, ):
446 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
447 
    if mtype == TMessageType.EXCEPTION:
448 
      x = TApplicationException()
449 
      x.read(self._iprot)
450 
      self._iprot.readMessageEnd()
451 
      raise x
452 
    result = getContext_result()
453 
    result.read(self._iprot)
454 
    self._iprot.readMessageEnd()
455 
    if result.success != None:
456 
      return result.success
457 
    if result.ax != None:
458 
      raise result.ax
459 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getContext failed: unknown result");
460 
 
122 ashish 461 
  def authenticateUser(self, handle, password, isEmail):
462 
    """
463 
    Parameters:
464 
     - handle
465 
     - password
466 
     - isEmail
467 
    """
468 
    self.send_authenticateUser(handle, password, isEmail)
469 
    return self.recv_authenticateUser()
470 
 
471 
  def send_authenticateUser(self, handle, password, isEmail):
472 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
473 
    args = authenticateUser_args()
474 
    args.handle = handle
475 
    args.password = password
476 
    args.isEmail = isEmail
477 
    args.write(self._oprot)
478 
    self._oprot.writeMessageEnd()
479 
    self._oprot.trans.flush()
480 
 
481 
  def recv_authenticateUser(self, ):
482 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
483 
    if mtype == TMessageType.EXCEPTION:
484 
      x = TApplicationException()
485 
      x.read(self._iprot)
486 
      self._iprot.readMessageEnd()
487 
      raise x
488 
    result = authenticateUser_result()
489 
    result.read(self._iprot)
490 
    self._iprot.readMessageEnd()
491 
    if result.success != None:
492 
      return result.success
493 
    if result.ax != None:
494 
      raise result.ax
495 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
496 
 
94 ashish 497 
  def userExists(self, email):
498 
    """
499 
    Parameters:
500 
     - email
501 
    """
502 
    self.send_userExists(email)
503 
    return self.recv_userExists()
504 
 
505 
  def send_userExists(self, email):
506 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
507 
    args = userExists_args()
508 
    args.email = email
509 
    args.write(self._oprot)
510 
    self._oprot.writeMessageEnd()
511 
    self._oprot.trans.flush()
512 
 
513 
  def recv_userExists(self, ):
514 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
515 
    if mtype == TMessageType.EXCEPTION:
516 
      x = TApplicationException()
517 
      x.read(self._iprot)
518 
      self._iprot.readMessageEnd()
519 
      raise x
520 
    result = userExists_result()
521 
    result.read(self._iprot)
522 
    self._iprot.readMessageEnd()
523 
    if result.success != None:
524 
      return result.success
525 
    if result.ucx != None:
526 
      raise result.ucx
527 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
528 
 
529 
  def addIpAdressForUser(self, ip, timestamp, userId):
530 
    """
531 
    Parameters:
532 
     - ip
533 
     - timestamp
534 
     - userId
535 
    """
536 
    self.send_addIpAdressForUser(ip, timestamp, userId)
537 
    return self.recv_addIpAdressForUser()
538 
 
539 
  def send_addIpAdressForUser(self, ip, timestamp, userId):
540 
    self._oprot.writeMessageBegin('addIpAdressForUser', TMessageType.CALL, self._seqid)
541 
    args = addIpAdressForUser_args()
542 
    args.ip = ip
543 
    args.timestamp = timestamp
544 
    args.userId = userId
545 
    args.write(self._oprot)
546 
    self._oprot.writeMessageEnd()
547 
    self._oprot.trans.flush()
548 
 
549 
  def recv_addIpAdressForUser(self, ):
550 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
551 
    if mtype == TMessageType.EXCEPTION:
552 
      x = TApplicationException()
553 
      x.read(self._iprot)
554 
      self._iprot.readMessageEnd()
555 
      raise x
556 
    result = addIpAdressForUser_result()
557 
    result.read(self._iprot)
558 
    self._iprot.readMessageEnd()
559 
    if result.success != None:
560 
      return result.success
561 
    if result.ucx != None:
562 
      raise result.ucx
563 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addIpAdressForUser failed: unknown result");
564 
 
565 
  def addAddressForUser(self, address, userid, timestamp):
566 
    """
567 
    Parameters:
568 
     - address
569 
     - userid
570 
     - timestamp
571 
    """
572 
    self.send_addAddressForUser(address, userid, timestamp)
573 
    return self.recv_addAddressForUser()
574 
 
575 
  def send_addAddressForUser(self, address, userid, timestamp):
576 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
577 
    args = addAddressForUser_args()
578 
    args.address = address
579 
    args.userid = userid
580 
    args.timestamp = timestamp
581 
    args.write(self._oprot)
582 
    self._oprot.writeMessageEnd()
583 
    self._oprot.trans.flush()
584 
 
585 
  def recv_addAddressForUser(self, ):
586 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
587 
    if mtype == TMessageType.EXCEPTION:
588 
      x = TApplicationException()
589 
      x.read(self._iprot)
590 
      self._iprot.readMessageEnd()
591 
      raise x
592 
    result = addAddressForUser_result()
593 
    result.read(self._iprot)
594 
    self._iprot.readMessageEnd()
595 
    if result.success != None:
596 
      return result.success
597 
    if result.ucx != None:
598 
      raise result.ucx
599 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
600 
 
601 
  def removeAddressForUser(self, userid, addressId):
602 
    """
603 
    Parameters:
604 
     - userid
605 
     - addressId
606 
    """
607 
    self.send_removeAddressForUser(userid, addressId)
608 
    return self.recv_removeAddressForUser()
609 
 
610 
  def send_removeAddressForUser(self, userid, addressId):
611 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
612 
    args = removeAddressForUser_args()
613 
    args.userid = userid
614 
    args.addressId = addressId
615 
    args.write(self._oprot)
616 
    self._oprot.writeMessageEnd()
617 
    self._oprot.trans.flush()
618 
 
619 
  def recv_removeAddressForUser(self, ):
620 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
621 
    if mtype == TMessageType.EXCEPTION:
622 
      x = TApplicationException()
623 
      x.read(self._iprot)
624 
      self._iprot.readMessageEnd()
625 
      raise x
626 
    result = removeAddressForUser_result()
627 
    result.read(self._iprot)
628 
    self._iprot.readMessageEnd()
629 
    if result.success != None:
630 
      return result.success
631 
    if result.ucx != None:
632 
      raise result.ucx
633 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
634 
 
635 
  def setUserAsLoggedIn(self, userId, timestamp):
636 
    """
637 
    Parameters:
638 
     - userId
639 
     - timestamp
640 
    """
641 
    self.send_setUserAsLoggedIn(userId, timestamp)
642 
    return self.recv_setUserAsLoggedIn()
643 
 
644 
  def send_setUserAsLoggedIn(self, userId, timestamp):
645 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
646 
    args = setUserAsLoggedIn_args()
647 
    args.userId = userId
648 
    args.timestamp = timestamp
649 
    args.write(self._oprot)
650 
    self._oprot.writeMessageEnd()
651 
    self._oprot.trans.flush()
652 
 
653 
  def recv_setUserAsLoggedIn(self, ):
654 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
655 
    if mtype == TMessageType.EXCEPTION:
656 
      x = TApplicationException()
657 
      x.read(self._iprot)
658 
      self._iprot.readMessageEnd()
659 
      raise x
660 
    result = setUserAsLoggedIn_result()
661 
    result.read(self._iprot)
662 
    self._iprot.readMessageEnd()
663 
    if result.success != None:
664 
      return result.success
665 
    if result.ucx != None:
666 
      raise result.ucx
667 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
668 
 
669 
  def setUserAsLoggedOut(self, userid, timestamp):
670 
    """
671 
    Parameters:
672 
     - userid
673 
     - timestamp
674 
    """
675 
    self.send_setUserAsLoggedOut(userid, timestamp)
676 
    return self.recv_setUserAsLoggedOut()
677 
 
678 
  def send_setUserAsLoggedOut(self, userid, timestamp):
679 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
680 
    args = setUserAsLoggedOut_args()
681 
    args.userid = userid
682 
    args.timestamp = timestamp
683 
    args.write(self._oprot)
684 
    self._oprot.writeMessageEnd()
685 
    self._oprot.trans.flush()
686 
 
687 
  def recv_setUserAsLoggedOut(self, ):
688 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
689 
    if mtype == TMessageType.EXCEPTION:
690 
      x = TApplicationException()
691 
      x.read(self._iprot)
692 
      self._iprot.readMessageEnd()
693 
      raise x
694 
    result = setUserAsLoggedOut_result()
695 
    result.read(self._iprot)
696 
    self._iprot.readMessageEnd()
697 
    if result.success != None:
698 
      return result.success
699 
    if result.ucx != None:
700 
      raise result.ucx
701 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
702 
 
504 rajveer 703 
  def setDefaultAddress(self, userid, addressId):
704 
    """
705 
    Parameters:
706 
     - userid
707 
     - addressId
708 
    """
709 
    self.send_setDefaultAddress(userid, addressId)
710 
    return self.recv_setDefaultAddress()
711 
 
712 
  def send_setDefaultAddress(self, userid, addressId):
713 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
714 
    args = setDefaultAddress_args()
715 
    args.userid = userid
716 
    args.addressId = addressId
717 
    args.write(self._oprot)
718 
    self._oprot.writeMessageEnd()
719 
    self._oprot.trans.flush()
720 
 
721 
  def recv_setDefaultAddress(self, ):
722 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
723 
    if mtype == TMessageType.EXCEPTION:
724 
      x = TApplicationException()
725 
      x.read(self._iprot)
726 
      self._iprot.readMessageEnd()
727 
      raise x
728 
    result = setDefaultAddress_result()
729 
    result.read(self._iprot)
730 
    self._iprot.readMessageEnd()
731 
    if result.success != None:
732 
      return result.success
733 
    if result.ucx != None:
734 
      raise result.ucx
735 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
736 
 
94 ashish 737 
  def updatePassword(self, userid, password):
738 
    """
739 
    Parameters:
740 
     - userid
741 
     - password
742 
    """
743 
    self.send_updatePassword(userid, password)
744 
    return self.recv_updatePassword()
745 
 
746 
  def send_updatePassword(self, userid, password):
747 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
748 
    args = updatePassword_args()
749 
    args.userid = userid
750 
    args.password = password
751 
    args.write(self._oprot)
752 
    self._oprot.writeMessageEnd()
753 
    self._oprot.trans.flush()
754 
 
755 
  def recv_updatePassword(self, ):
756 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
757 
    if mtype == TMessageType.EXCEPTION:
758 
      x = TApplicationException()
759 
      x.read(self._iprot)
760 
      self._iprot.readMessageEnd()
761 
      raise x
762 
    result = updatePassword_result()
763 
    result.read(self._iprot)
764 
    self._iprot.readMessageEnd()
765 
    if result.success != None:
766 
      return result.success
767 
    if result.ucx != None:
768 
      raise result.ucx
769 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
770 
 
122 ashish 771 
  def deleteUser(self, userid, isSessionId):
94 ashish 772 
    """
773 
    Parameters:
774 
     - userid
122 ashish 775 
     - isSessionId
94 ashish 776 
    """
122 ashish 777 
    self.send_deleteUser(userid, isSessionId)
94 ashish 778 
    return self.recv_deleteUser()
779 
 
122 ashish 780 
  def send_deleteUser(self, userid, isSessionId):
94 ashish 781 
    self._oprot.writeMessageBegin('deleteUser', TMessageType.CALL, self._seqid)
782 
    args = deleteUser_args()
783 
    args.userid = userid
122 ashish 784 
    args.isSessionId = isSessionId
94 ashish 785 
    args.write(self._oprot)
786 
    self._oprot.writeMessageEnd()
787 
    self._oprot.trans.flush()
788 
 
789 
  def recv_deleteUser(self, ):
790 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
791 
    if mtype == TMessageType.EXCEPTION:
792 
      x = TApplicationException()
793 
      x.read(self._iprot)
794 
      self._iprot.readMessageEnd()
795 
      raise x
796 
    result = deleteUser_result()
797 
    result.read(self._iprot)
798 
    self._iprot.readMessageEnd()
799 
    if result.success != None:
800 
      return result.success
801 
    if result.ucx != None:
802 
      raise result.ucx
803 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteUser failed: unknown result");
804 
 
805 
  def sendEmailVerification(self, userid):
806 
    """
807 
    Parameters:
808 
     - userid
809 
    """
810 
    self.send_sendEmailVerification(userid)
811 
    return self.recv_sendEmailVerification()
812 
 
813 
  def send_sendEmailVerification(self, userid):
814 
    self._oprot.writeMessageBegin('sendEmailVerification', TMessageType.CALL, self._seqid)
815 
    args = sendEmailVerification_args()
816 
    args.userid = userid
817 
    args.write(self._oprot)
818 
    self._oprot.writeMessageEnd()
819 
    self._oprot.trans.flush()
820 
 
821 
  def recv_sendEmailVerification(self, ):
822 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
823 
    if mtype == TMessageType.EXCEPTION:
824 
      x = TApplicationException()
825 
      x.read(self._iprot)
826 
      self._iprot.readMessageEnd()
827 
      raise x
828 
    result = sendEmailVerification_result()
829 
    result.read(self._iprot)
830 
    self._iprot.readMessageEnd()
831 
    if result.success != None:
832 
      return result.success
833 
    if result.ucx != None:
834 
      raise result.ucx
835 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendEmailVerification failed: unknown result");
836 
 
837 
  def sendSMSVerification(self, userid):
838 
    """
839 
    Parameters:
840 
     - userid
841 
    """
842 
    self.send_sendSMSVerification(userid)
843 
    return self.recv_sendSMSVerification()
844 
 
845 
  def send_sendSMSVerification(self, userid):
846 
    self._oprot.writeMessageBegin('sendSMSVerification', TMessageType.CALL, self._seqid)
847 
    args = sendSMSVerification_args()
848 
    args.userid = userid
849 
    args.write(self._oprot)
850 
    self._oprot.writeMessageEnd()
851 
    self._oprot.trans.flush()
852 
 
853 
  def recv_sendSMSVerification(self, ):
854 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
855 
    if mtype == TMessageType.EXCEPTION:
856 
      x = TApplicationException()
857 
      x.read(self._iprot)
858 
      self._iprot.readMessageEnd()
859 
      raise x
860 
    result = sendSMSVerification_result()
861 
    result.read(self._iprot)
862 
    self._iprot.readMessageEnd()
863 
    if result.success != None:
864 
      return result.success
865 
    if result.ucx != None:
866 
      raise result.ucx
867 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendSMSVerification failed: unknown result");
868 
 
869 
  def confirmEmailVerification(self, userid):
870 
    """
871 
    Parameters:
872 
     - userid
873 
    """
874 
    self.send_confirmEmailVerification(userid)
875 
    return self.recv_confirmEmailVerification()
876 
 
877 
  def send_confirmEmailVerification(self, userid):
878 
    self._oprot.writeMessageBegin('confirmEmailVerification', TMessageType.CALL, self._seqid)
879 
    args = confirmEmailVerification_args()
880 
    args.userid = userid
881 
    args.write(self._oprot)
882 
    self._oprot.writeMessageEnd()
883 
    self._oprot.trans.flush()
884 
 
885 
  def recv_confirmEmailVerification(self, ):
886 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
887 
    if mtype == TMessageType.EXCEPTION:
888 
      x = TApplicationException()
889 
      x.read(self._iprot)
890 
      self._iprot.readMessageEnd()
891 
      raise x
892 
    result = confirmEmailVerification_result()
893 
    result.read(self._iprot)
894 
    self._iprot.readMessageEnd()
895 
    if result.success != None:
896 
      return result.success
897 
    if result.ucx != None:
898 
      raise result.ucx
899 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "confirmEmailVerification failed: unknown result");
900 
 
901 
  def confirmSMSVerification(self, userid):
902 
    """
903 
    Parameters:
904 
     - userid
905 
    """
906 
    self.send_confirmSMSVerification(userid)
907 
    return self.recv_confirmSMSVerification()
908 
 
909 
  def send_confirmSMSVerification(self, userid):
910 
    self._oprot.writeMessageBegin('confirmSMSVerification', TMessageType.CALL, self._seqid)
911 
    args = confirmSMSVerification_args()
912 
    args.userid = userid
913 
    args.write(self._oprot)
914 
    self._oprot.writeMessageEnd()
915 
    self._oprot.trans.flush()
916 
 
917 
  def recv_confirmSMSVerification(self, ):
918 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
919 
    if mtype == TMessageType.EXCEPTION:
920 
      x = TApplicationException()
921 
      x.read(self._iprot)
922 
      self._iprot.readMessageEnd()
923 
      raise x
924 
    result = confirmSMSVerification_result()
925 
    result.read(self._iprot)
926 
    self._iprot.readMessageEnd()
927 
    if result.success != None:
928 
      return result.success
929 
    if result.ucx != None:
930 
      raise result.ucx
931 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "confirmSMSVerification failed: unknown result");
932 
 
933 
  def addSocialhandle(self, userid, socialService, handle):
934 
    """
935 
    Parameters:
936 
     - userid
937 
     - socialService
938 
     - handle
939 
    """
940 
    self.send_addSocialhandle(userid, socialService, handle)
941 
    return self.recv_addSocialhandle()
942 
 
943 
  def send_addSocialhandle(self, userid, socialService, handle):
944 
    self._oprot.writeMessageBegin('addSocialhandle', TMessageType.CALL, self._seqid)
945 
    args = addSocialhandle_args()
946 
    args.userid = userid
947 
    args.socialService = socialService
948 
    args.handle = handle
949 
    args.write(self._oprot)
950 
    self._oprot.writeMessageEnd()
951 
    self._oprot.trans.flush()
952 
 
953 
  def recv_addSocialhandle(self, ):
954 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
955 
    if mtype == TMessageType.EXCEPTION:
956 
      x = TApplicationException()
957 
      x.read(self._iprot)
958 
      self._iprot.readMessageEnd()
959 
      raise x
960 
    result = addSocialhandle_result()
961 
    result.read(self._iprot)
962 
    self._iprot.readMessageEnd()
963 
    if result.success != None:
964 
      return result.success
965 
    if result.ucx != None:
966 
      raise result.ucx
967 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSocialhandle failed: unknown result");
968 
 
130 ashish 969 
  def sendNewPasswordById(self, userid):
970 
    """
971 
    Parameters:
972 
     - userid
973 
    """
974 
    self.send_sendNewPasswordById(userid)
975 
    return self.recv_sendNewPasswordById()
94 ashish 976 
 
130 ashish 977 
  def send_sendNewPasswordById(self, userid):
978 
    self._oprot.writeMessageBegin('sendNewPasswordById', TMessageType.CALL, self._seqid)
979 
    args = sendNewPasswordById_args()
980 
    args.userid = userid
981 
    args.write(self._oprot)
982 
    self._oprot.writeMessageEnd()
983 
    self._oprot.trans.flush()
984 
 
985 
  def recv_sendNewPasswordById(self, ):
986 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
987 
    if mtype == TMessageType.EXCEPTION:
988 
      x = TApplicationException()
989 
      x.read(self._iprot)
990 
      self._iprot.readMessageEnd()
991 
      raise x
992 
    result = sendNewPasswordById_result()
993 
    result.read(self._iprot)
994 
    self._iprot.readMessageEnd()
995 
    if result.success != None:
996 
      return result.success
997 
    if result.ucx != None:
998 
      raise result.ucx
999 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendNewPasswordById failed: unknown result");
1000 
 
1001 
  def sendNewPasswordByHandle(self, emailOrHandle, isEmail):
1002 
    """
1003 
    Parameters:
1004 
     - emailOrHandle
1005 
     - isEmail
1006 
    """
1007 
    self.send_sendNewPasswordByHandle(emailOrHandle, isEmail)
1008 
    return self.recv_sendNewPasswordByHandle()
1009 
 
1010 
  def send_sendNewPasswordByHandle(self, emailOrHandle, isEmail):
1011 
    self._oprot.writeMessageBegin('sendNewPasswordByHandle', TMessageType.CALL, self._seqid)
1012 
    args = sendNewPasswordByHandle_args()
1013 
    args.emailOrHandle = emailOrHandle
1014 
    args.isEmail = isEmail
1015 
    args.write(self._oprot)
1016 
    self._oprot.writeMessageEnd()
1017 
    self._oprot.trans.flush()
1018 
 
1019 
  def recv_sendNewPasswordByHandle(self, ):
1020 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1021 
    if mtype == TMessageType.EXCEPTION:
1022 
      x = TApplicationException()
1023 
      x.read(self._iprot)
1024 
      self._iprot.readMessageEnd()
1025 
      raise x
1026 
    result = sendNewPasswordByHandle_result()
1027 
    result.read(self._iprot)
1028 
    self._iprot.readMessageEnd()
1029 
    if result.success != None:
1030 
      return result.success
1031 
    if result.ucx != None:
1032 
      raise result.ucx
1033 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendNewPasswordByHandle failed: unknown result");
1034 
 
1035 
 
94 ashish 1036 
class Processor(Iface, TProcessor):
1037 
  def __init__(self, handler):
1038 
    self._handler = handler
1039 
    self._processMap = {}
1040 
    self._processMap["createContext"] = Processor.process_createContext
1041 
    self._processMap["getContextFromId"] = Processor.process_getContextFromId
1042 
    self._processMap["getContextFromEmailOrHandle"] = Processor.process_getContextFromEmailOrHandle
1043 
    self._processMap["getState"] = Processor.process_getState
1044 
    self._processMap["getPrimaryInfo"] = Processor.process_getPrimaryInfo
1045 
    self._processMap["getInternalInfo"] = Processor.process_getInternalInfo
1046 
    self._processMap["getContext"] = Processor.process_getContext
122 ashish 1047 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 1048 
    self._processMap["userExists"] = Processor.process_userExists
1049 
    self._processMap["addIpAdressForUser"] = Processor.process_addIpAdressForUser
1050 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
1051 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
1052 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
1053 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 1054 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 1055 
    self._processMap["updatePassword"] = Processor.process_updatePassword
1056 
    self._processMap["deleteUser"] = Processor.process_deleteUser
1057 
    self._processMap["sendEmailVerification"] = Processor.process_sendEmailVerification
1058 
    self._processMap["sendSMSVerification"] = Processor.process_sendSMSVerification
1059 
    self._processMap["confirmEmailVerification"] = Processor.process_confirmEmailVerification
1060 
    self._processMap["confirmSMSVerification"] = Processor.process_confirmSMSVerification
1061 
    self._processMap["addSocialhandle"] = Processor.process_addSocialhandle
130 ashish 1062 
    self._processMap["sendNewPasswordById"] = Processor.process_sendNewPasswordById
1063 
    self._processMap["sendNewPasswordByHandle"] = Processor.process_sendNewPasswordByHandle
94 ashish 1064 
 
1065 
  def process(self, iprot, oprot):
1066 
    (name, type, seqid) = iprot.readMessageBegin()
1067 
    if name not in self._processMap:
1068 
      iprot.skip(TType.STRUCT)
1069 
      iprot.readMessageEnd()
1070 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
1071 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
1072 
      x.write(oprot)
1073 
      oprot.writeMessageEnd()
1074 
      oprot.trans.flush()
1075 
      return
1076 
    else:
1077 
      self._processMap[name](self, seqid, iprot, oprot)
1078 
    return True
1079 
 
1080 
  def process_createContext(self, seqid, iprot, oprot):
1081 
    args = createContext_args()
1082 
    args.read(iprot)
1083 
    iprot.readMessageEnd()
1084 
    result = createContext_result()
1085 
    try:
1086 
      result.success = self._handler.createContext(args.context, args.updateExisting)
1087 
    except UserContextException, cex:
1088 
      result.cex = cex
1089 
    oprot.writeMessageBegin("createContext", TMessageType.REPLY, seqid)
1090 
    result.write(oprot)
1091 
    oprot.writeMessageEnd()
1092 
    oprot.trans.flush()
1093 
 
1094 
  def process_getContextFromId(self, seqid, iprot, oprot):
1095 
    args = getContextFromId_args()
1096 
    args.read(iprot)
1097 
    iprot.readMessageEnd()
1098 
    result = getContextFromId_result()
1099 
    try:
122 ashish 1100 
      result.success = self._handler.getContextFromId(args.userId, args.isSessionId)
94 ashish 1101 
    except UserContextException, ucx:
1102 
      result.ucx = ucx
1103 
    oprot.writeMessageBegin("getContextFromId", TMessageType.REPLY, seqid)
1104 
    result.write(oprot)
1105 
    oprot.writeMessageEnd()
1106 
    oprot.trans.flush()
1107 
 
1108 
  def process_getContextFromEmailOrHandle(self, seqid, iprot, oprot):
1109 
    args = getContextFromEmailOrHandle_args()
1110 
    args.read(iprot)
1111 
    iprot.readMessageEnd()
1112 
    result = getContextFromEmailOrHandle_result()
1113 
    try:
1114 
      result.success = self._handler.getContextFromEmailOrHandle(args.emailorhandle, args.isEmail)
1115 
    except UserContextException, ucx:
1116 
      result.ucx = ucx
1117 
    oprot.writeMessageBegin("getContextFromEmailOrHandle", TMessageType.REPLY, seqid)
1118 
    result.write(oprot)
1119 
    oprot.writeMessageEnd()
1120 
    oprot.trans.flush()
1121 
 
1122 
  def process_getState(self, seqid, iprot, oprot):
1123 
    args = getState_args()
1124 
    args.read(iprot)
1125 
    iprot.readMessageEnd()
1126 
    result = getState_result()
1127 
    try:
122 ashish 1128 
      result.success = self._handler.getState(args.userId, args.isSessionId)
94 ashish 1129 
    except UserContextException, ucx:
1130 
      result.ucx = ucx
1131 
    oprot.writeMessageBegin("getState", TMessageType.REPLY, seqid)
1132 
    result.write(oprot)
1133 
    oprot.writeMessageEnd()
1134 
    oprot.trans.flush()
1135 
 
1136 
  def process_getPrimaryInfo(self, seqid, iprot, oprot):
1137 
    args = getPrimaryInfo_args()
1138 
    args.read(iprot)
1139 
    iprot.readMessageEnd()
1140 
    result = getPrimaryInfo_result()
1141 
    try:
122 ashish 1142 
      result.success = self._handler.getPrimaryInfo(args.userId, args.isSessionId)
94 ashish 1143 
    except UserContextException, ucx:
1144 
      result.ucx = ucx
1145 
    oprot.writeMessageBegin("getPrimaryInfo", TMessageType.REPLY, seqid)
1146 
    result.write(oprot)
1147 
    oprot.writeMessageEnd()
1148 
    oprot.trans.flush()
1149 
 
1150 
  def process_getInternalInfo(self, seqid, iprot, oprot):
1151 
    args = getInternalInfo_args()
1152 
    args.read(iprot)
1153 
    iprot.readMessageEnd()
1154 
    result = getInternalInfo_result()
1155 
    try:
122 ashish 1156 
      result.success = self._handler.getInternalInfo(args.userId, args.isSessionId)
94 ashish 1157 
    except UserContextException, ucx:
1158 
      result.ucx = ucx
1159 
    oprot.writeMessageBegin("getInternalInfo", TMessageType.REPLY, seqid)
1160 
    result.write(oprot)
1161 
    oprot.writeMessageEnd()
1162 
    oprot.trans.flush()
1163 
 
1164 
  def process_getContext(self, seqid, iprot, oprot):
1165 
    args = getContext_args()
1166 
    args.read(iprot)
1167 
    iprot.readMessageEnd()
1168 
    result = getContext_result()
1169 
    try:
1170 
      result.success = self._handler.getContext(args.email, args.password)
1171 
    except AuthenticationException, ax:
1172 
      result.ax = ax
1173 
    oprot.writeMessageBegin("getContext", TMessageType.REPLY, seqid)
1174 
    result.write(oprot)
1175 
    oprot.writeMessageEnd()
1176 
    oprot.trans.flush()
1177 
 
122 ashish 1178 
  def process_authenticateUser(self, seqid, iprot, oprot):
1179 
    args = authenticateUser_args()
1180 
    args.read(iprot)
1181 
    iprot.readMessageEnd()
1182 
    result = authenticateUser_result()
1183 
    try:
1184 
      result.success = self._handler.authenticateUser(args.handle, args.password, args.isEmail)
1185 
    except AuthenticationException, ax:
1186 
      result.ax = ax
1187 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
1188 
    result.write(oprot)
1189 
    oprot.writeMessageEnd()
1190 
    oprot.trans.flush()
1191 
 
94 ashish 1192 
  def process_userExists(self, seqid, iprot, oprot):
1193 
    args = userExists_args()
1194 
    args.read(iprot)
1195 
    iprot.readMessageEnd()
1196 
    result = userExists_result()
1197 
    try:
1198 
      result.success = self._handler.userExists(args.email)
1199 
    except UserContextException, ucx:
1200 
      result.ucx = ucx
1201 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
1202 
    result.write(oprot)
1203 
    oprot.writeMessageEnd()
1204 
    oprot.trans.flush()
1205 
 
1206 
  def process_addIpAdressForUser(self, seqid, iprot, oprot):
1207 
    args = addIpAdressForUser_args()
1208 
    args.read(iprot)
1209 
    iprot.readMessageEnd()
1210 
    result = addIpAdressForUser_result()
1211 
    try:
1212 
      result.success = self._handler.addIpAdressForUser(args.ip, args.timestamp, args.userId)
1213 
    except UserContextException, ucx:
1214 
      result.ucx = ucx
1215 
    oprot.writeMessageBegin("addIpAdressForUser", TMessageType.REPLY, seqid)
1216 
    result.write(oprot)
1217 
    oprot.writeMessageEnd()
1218 
    oprot.trans.flush()
1219 
 
1220 
  def process_addAddressForUser(self, seqid, iprot, oprot):
1221 
    args = addAddressForUser_args()
1222 
    args.read(iprot)
1223 
    iprot.readMessageEnd()
1224 
    result = addAddressForUser_result()
1225 
    try:
1226 
      result.success = self._handler.addAddressForUser(args.address, args.userid, args.timestamp)
1227 
    except UserContextException, ucx:
1228 
      result.ucx = ucx
1229 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
1230 
    result.write(oprot)
1231 
    oprot.writeMessageEnd()
1232 
    oprot.trans.flush()
1233 
 
1234 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
1235 
    args = removeAddressForUser_args()
1236 
    args.read(iprot)
1237 
    iprot.readMessageEnd()
1238 
    result = removeAddressForUser_result()
1239 
    try:
1240 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
1241 
    except UserContextException, ucx:
1242 
      result.ucx = ucx
1243 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
1244 
    result.write(oprot)
1245 
    oprot.writeMessageEnd()
1246 
    oprot.trans.flush()
1247 
 
1248 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
1249 
    args = setUserAsLoggedIn_args()
1250 
    args.read(iprot)
1251 
    iprot.readMessageEnd()
1252 
    result = setUserAsLoggedIn_result()
1253 
    try:
1254 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
1255 
    except UserContextException, ucx:
1256 
      result.ucx = ucx
1257 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
1258 
    result.write(oprot)
1259 
    oprot.writeMessageEnd()
1260 
    oprot.trans.flush()
1261 
 
1262 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
1263 
    args = setUserAsLoggedOut_args()
1264 
    args.read(iprot)
1265 
    iprot.readMessageEnd()
1266 
    result = setUserAsLoggedOut_result()
1267 
    try:
1268 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
1269 
    except UserContextException, ucx:
1270 
      result.ucx = ucx
1271 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
1272 
    result.write(oprot)
1273 
    oprot.writeMessageEnd()
1274 
    oprot.trans.flush()
1275 
 
504 rajveer 1276 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
1277 
    args = setDefaultAddress_args()
1278 
    args.read(iprot)
1279 
    iprot.readMessageEnd()
1280 
    result = setDefaultAddress_result()
1281 
    try:
1282 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
1283 
    except UserContextException, ucx:
1284 
      result.ucx = ucx
1285 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
1286 
    result.write(oprot)
1287 
    oprot.writeMessageEnd()
1288 
    oprot.trans.flush()
1289 
 
94 ashish 1290 
  def process_updatePassword(self, seqid, iprot, oprot):
1291 
    args = updatePassword_args()
1292 
    args.read(iprot)
1293 
    iprot.readMessageEnd()
1294 
    result = updatePassword_result()
1295 
    try:
1296 
      result.success = self._handler.updatePassword(args.userid, args.password)
1297 
    except UserContextException, ucx:
1298 
      result.ucx = ucx
1299 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
1300 
    result.write(oprot)
1301 
    oprot.writeMessageEnd()
1302 
    oprot.trans.flush()
1303 
 
1304 
  def process_deleteUser(self, seqid, iprot, oprot):
1305 
    args = deleteUser_args()
1306 
    args.read(iprot)
1307 
    iprot.readMessageEnd()
1308 
    result = deleteUser_result()
1309 
    try:
122 ashish 1310 
      result.success = self._handler.deleteUser(args.userid, args.isSessionId)
94 ashish 1311 
    except UserContextException, ucx:
1312 
      result.ucx = ucx
1313 
    oprot.writeMessageBegin("deleteUser", TMessageType.REPLY, seqid)
1314 
    result.write(oprot)
1315 
    oprot.writeMessageEnd()
1316 
    oprot.trans.flush()
1317 
 
1318 
  def process_sendEmailVerification(self, seqid, iprot, oprot):
1319 
    args = sendEmailVerification_args()
1320 
    args.read(iprot)
1321 
    iprot.readMessageEnd()
1322 
    result = sendEmailVerification_result()
1323 
    try:
1324 
      result.success = self._handler.sendEmailVerification(args.userid)
1325 
    except UserContextException, ucx:
1326 
      result.ucx = ucx
1327 
    oprot.writeMessageBegin("sendEmailVerification", TMessageType.REPLY, seqid)
1328 
    result.write(oprot)
1329 
    oprot.writeMessageEnd()
1330 
    oprot.trans.flush()
1331 
 
1332 
  def process_sendSMSVerification(self, seqid, iprot, oprot):
1333 
    args = sendSMSVerification_args()
1334 
    args.read(iprot)
1335 
    iprot.readMessageEnd()
1336 
    result = sendSMSVerification_result()
1337 
    try:
1338 
      result.success = self._handler.sendSMSVerification(args.userid)
1339 
    except UserContextException, ucx:
1340 
      result.ucx = ucx
1341 
    oprot.writeMessageBegin("sendSMSVerification", TMessageType.REPLY, seqid)
1342 
    result.write(oprot)
1343 
    oprot.writeMessageEnd()
1344 
    oprot.trans.flush()
1345 
 
1346 
  def process_confirmEmailVerification(self, seqid, iprot, oprot):
1347 
    args = confirmEmailVerification_args()
1348 
    args.read(iprot)
1349 
    iprot.readMessageEnd()
1350 
    result = confirmEmailVerification_result()
1351 
    try:
1352 
      result.success = self._handler.confirmEmailVerification(args.userid)
1353 
    except UserContextException, ucx:
1354 
      result.ucx = ucx
1355 
    oprot.writeMessageBegin("confirmEmailVerification", TMessageType.REPLY, seqid)
1356 
    result.write(oprot)
1357 
    oprot.writeMessageEnd()
1358 
    oprot.trans.flush()
1359 
 
1360 
  def process_confirmSMSVerification(self, seqid, iprot, oprot):
1361 
    args = confirmSMSVerification_args()
1362 
    args.read(iprot)
1363 
    iprot.readMessageEnd()
1364 
    result = confirmSMSVerification_result()
1365 
    try:
1366 
      result.success = self._handler.confirmSMSVerification(args.userid)
1367 
    except UserContextException, ucx:
1368 
      result.ucx = ucx
1369 
    oprot.writeMessageBegin("confirmSMSVerification", TMessageType.REPLY, seqid)
1370 
    result.write(oprot)
1371 
    oprot.writeMessageEnd()
1372 
    oprot.trans.flush()
1373 
 
1374 
  def process_addSocialhandle(self, seqid, iprot, oprot):
1375 
    args = addSocialhandle_args()
1376 
    args.read(iprot)
1377 
    iprot.readMessageEnd()
1378 
    result = addSocialhandle_result()
1379 
    try:
1380 
      result.success = self._handler.addSocialhandle(args.userid, args.socialService, args.handle)
1381 
    except UserContextException, ucx:
1382 
      result.ucx = ucx
1383 
    oprot.writeMessageBegin("addSocialhandle", TMessageType.REPLY, seqid)
1384 
    result.write(oprot)
1385 
    oprot.writeMessageEnd()
1386 
    oprot.trans.flush()
1387 
 
130 ashish 1388 
  def process_sendNewPasswordById(self, seqid, iprot, oprot):
1389 
    args = sendNewPasswordById_args()
1390 
    args.read(iprot)
1391 
    iprot.readMessageEnd()
1392 
    result = sendNewPasswordById_result()
1393 
    try:
1394 
      result.success = self._handler.sendNewPasswordById(args.userid)
1395 
    except UserContextException, ucx:
1396 
      result.ucx = ucx
1397 
    oprot.writeMessageBegin("sendNewPasswordById", TMessageType.REPLY, seqid)
1398 
    result.write(oprot)
1399 
    oprot.writeMessageEnd()
1400 
    oprot.trans.flush()
94 ashish 1401 
 
130 ashish 1402 
  def process_sendNewPasswordByHandle(self, seqid, iprot, oprot):
1403 
    args = sendNewPasswordByHandle_args()
1404 
    args.read(iprot)
1405 
    iprot.readMessageEnd()
1406 
    result = sendNewPasswordByHandle_result()
1407 
    try:
1408 
      result.success = self._handler.sendNewPasswordByHandle(args.emailOrHandle, args.isEmail)
1409 
    except UserContextException, ucx:
1410 
      result.ucx = ucx
1411 
    oprot.writeMessageBegin("sendNewPasswordByHandle", TMessageType.REPLY, seqid)
1412 
    result.write(oprot)
1413 
    oprot.writeMessageEnd()
1414 
    oprot.trans.flush()
1415 
 
1416 
 
94 ashish 1417 
# HELPER FUNCTIONS AND STRUCTURES
1418 
 
1419 
class createContext_args:
1420 
  """
1421 
  Attributes:
1422 
   - context
1423 
   - updateExisting
1424 
  """
1425 
 
1426 
  thrift_spec = (
1427 
    None, # 0
122 ashish 1428 
    (1, TType.STRUCT, 'context', (UserContext, UserContext.thrift_spec), None, ), # 1
94 ashish 1429 
    (2, TType.BOOL, 'updateExisting', None, None, ), # 2
1430 
  )
1431 
 
1432 
  def __init__(self, context=None, updateExisting=None,):
1433 
    self.context = context
1434 
    self.updateExisting = updateExisting
1435 
 
1436 
  def read(self, iprot):
1437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1439 
      return
1440 
    iprot.readStructBegin()
1441 
    while True:
1442 
      (fname, ftype, fid) = iprot.readFieldBegin()
1443 
      if ftype == TType.STOP:
1444 
        break
1445 
      if fid == 1:
1446 
        if ftype == TType.STRUCT:
122 ashish 1447 
          self.context = UserContext()
94 ashish 1448 
          self.context.read(iprot)
1449 
        else:
1450 
          iprot.skip(ftype)
1451 
      elif fid == 2:
1452 
        if ftype == TType.BOOL:
1453 
          self.updateExisting = iprot.readBool();
1454 
        else:
1455 
          iprot.skip(ftype)
1456 
      else:
1457 
        iprot.skip(ftype)
1458 
      iprot.readFieldEnd()
1459 
    iprot.readStructEnd()
1460 
 
1461 
  def write(self, oprot):
1462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1464 
      return
1465 
    oprot.writeStructBegin('createContext_args')
1466 
    if self.context != None:
1467 
      oprot.writeFieldBegin('context', TType.STRUCT, 1)
1468 
      self.context.write(oprot)
1469 
      oprot.writeFieldEnd()
1470 
    if self.updateExisting != None:
1471 
      oprot.writeFieldBegin('updateExisting', TType.BOOL, 2)
1472 
      oprot.writeBool(self.updateExisting)
1473 
      oprot.writeFieldEnd()
1474 
    oprot.writeFieldStop()
1475 
    oprot.writeStructEnd()
1476 
 
1477 
  def __repr__(self):
1478 
    L = ['%s=%r' % (key, value)
1479 
      for key, value in self.__dict__.iteritems()]
1480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1481 
 
1482 
  def __eq__(self, other):
1483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1484 
 
1485 
  def __ne__(self, other):
1486 
    return not (self == other)
1487 
 
1488 
class createContext_result:
1489 
  """
1490 
  Attributes:
1491 
   - success
1492 
   - cex
1493 
  """
1494 
 
1495 
  thrift_spec = (
122 ashish 1496 
    (0, TType.STRUCT, 'success', (UserContext, UserContext.thrift_spec), None, ), # 0
94 ashish 1497 
    (1, TType.STRUCT, 'cex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
1498 
  )
1499 
 
1500 
  def __init__(self, success=None, cex=None,):
1501 
    self.success = success
1502 
    self.cex = cex
1503 
 
1504 
  def read(self, iprot):
1505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1507 
      return
1508 
    iprot.readStructBegin()
1509 
    while True:
1510 
      (fname, ftype, fid) = iprot.readFieldBegin()
1511 
      if ftype == TType.STOP:
1512 
        break
1513 
      if fid == 0:
1514 
        if ftype == TType.STRUCT:
122 ashish 1515 
          self.success = UserContext()
94 ashish 1516 
          self.success.read(iprot)
1517 
        else:
1518 
          iprot.skip(ftype)
1519 
      elif fid == 1:
1520 
        if ftype == TType.STRUCT:
1521 
          self.cex = UserContextException()
1522 
          self.cex.read(iprot)
1523 
        else:
1524 
          iprot.skip(ftype)
1525 
      else:
1526 
        iprot.skip(ftype)
1527 
      iprot.readFieldEnd()
1528 
    iprot.readStructEnd()
1529 
 
1530 
  def write(self, oprot):
1531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1533 
      return
1534 
    oprot.writeStructBegin('createContext_result')
1535 
    if self.success != None:
1536 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
1537 
      self.success.write(oprot)
1538 
      oprot.writeFieldEnd()
1539 
    if self.cex != None:
1540 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
1541 
      self.cex.write(oprot)
1542 
      oprot.writeFieldEnd()
1543 
    oprot.writeFieldStop()
1544 
    oprot.writeStructEnd()
1545 
 
1546 
  def __repr__(self):
1547 
    L = ['%s=%r' % (key, value)
1548 
      for key, value in self.__dict__.iteritems()]
1549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1550 
 
1551 
  def __eq__(self, other):
1552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1553 
 
1554 
  def __ne__(self, other):
1555 
    return not (self == other)
1556 
 
1557 
class getContextFromId_args:
1558 
  """
1559 
  Attributes:
1560 
   - userId
122 ashish 1561 
   - isSessionId
94 ashish 1562 
  """
1563 
 
1564 
  thrift_spec = (
1565 
    None, # 0
1566 
    (1, TType.I64, 'userId', None, None, ), # 1
122 ashish 1567 
    (2, TType.BOOL, 'isSessionId', None, None, ), # 2
94 ashish 1568 
  )
1569 
 
122 ashish 1570 
  def __init__(self, userId=None, isSessionId=None,):
94 ashish 1571 
    self.userId = userId
122 ashish 1572 
    self.isSessionId = isSessionId
94 ashish 1573 
 
1574 
  def read(self, iprot):
1575 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1576 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1577 
      return
1578 
    iprot.readStructBegin()
1579 
    while True:
1580 
      (fname, ftype, fid) = iprot.readFieldBegin()
1581 
      if ftype == TType.STOP:
1582 
        break
1583 
      if fid == 1:
1584 
        if ftype == TType.I64:
1585 
          self.userId = iprot.readI64();
1586 
        else:
1587 
          iprot.skip(ftype)
122 ashish 1588 
      elif fid == 2:
1589 
        if ftype == TType.BOOL:
1590 
          self.isSessionId = iprot.readBool();
1591 
        else:
1592 
          iprot.skip(ftype)
94 ashish 1593 
      else:
1594 
        iprot.skip(ftype)
1595 
      iprot.readFieldEnd()
1596 
    iprot.readStructEnd()
1597 
 
1598 
  def write(self, oprot):
1599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1601 
      return
1602 
    oprot.writeStructBegin('getContextFromId_args')
1603 
    if self.userId != None:
1604 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1605 
      oprot.writeI64(self.userId)
1606 
      oprot.writeFieldEnd()
122 ashish 1607 
    if self.isSessionId != None:
1608 
      oprot.writeFieldBegin('isSessionId', TType.BOOL, 2)
1609 
      oprot.writeBool(self.isSessionId)
1610 
      oprot.writeFieldEnd()
94 ashish 1611 
    oprot.writeFieldStop()
1612 
    oprot.writeStructEnd()
1613 
 
1614 
  def __repr__(self):
1615 
    L = ['%s=%r' % (key, value)
1616 
      for key, value in self.__dict__.iteritems()]
1617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1618 
 
1619 
  def __eq__(self, other):
1620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1621 
 
1622 
  def __ne__(self, other):
1623 
    return not (self == other)
1624 
 
1625 
class getContextFromId_result:
1626 
  """
1627 
  Attributes:
1628 
   - success
1629 
   - ucx
1630 
  """
1631 
 
1632 
  thrift_spec = (
122 ashish 1633 
    (0, TType.STRUCT, 'success', (UserContext, UserContext.thrift_spec), None, ), # 0
94 ashish 1634 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
1635 
  )
1636 
 
1637 
  def __init__(self, success=None, ucx=None,):
1638 
    self.success = success
1639 
    self.ucx = ucx
1640 
 
1641 
  def read(self, iprot):
1642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1644 
      return
1645 
    iprot.readStructBegin()
1646 
    while True:
1647 
      (fname, ftype, fid) = iprot.readFieldBegin()
1648 
      if ftype == TType.STOP:
1649 
        break
1650 
      if fid == 0:
1651 
        if ftype == TType.STRUCT:
122 ashish 1652 
          self.success = UserContext()
94 ashish 1653 
          self.success.read(iprot)
1654 
        else:
1655 
          iprot.skip(ftype)
1656 
      elif fid == 1:
1657 
        if ftype == TType.STRUCT:
1658 
          self.ucx = UserContextException()
1659 
          self.ucx.read(iprot)
1660 
        else:
1661 
          iprot.skip(ftype)
1662 
      else:
1663 
        iprot.skip(ftype)
1664 
      iprot.readFieldEnd()
1665 
    iprot.readStructEnd()
1666 
 
1667 
  def write(self, oprot):
1668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1670 
      return
1671 
    oprot.writeStructBegin('getContextFromId_result')
1672 
    if self.success != None:
1673 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
1674 
      self.success.write(oprot)
1675 
      oprot.writeFieldEnd()
1676 
    if self.ucx != None:
1677 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
1678 
      self.ucx.write(oprot)
1679 
      oprot.writeFieldEnd()
1680 
    oprot.writeFieldStop()
1681 
    oprot.writeStructEnd()
1682 
 
1683 
  def __repr__(self):
1684 
    L = ['%s=%r' % (key, value)
1685 
      for key, value in self.__dict__.iteritems()]
1686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1687 
 
1688 
  def __eq__(self, other):
1689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1690 
 
1691 
  def __ne__(self, other):
1692 
    return not (self == other)
1693 
 
1694 
class getContextFromEmailOrHandle_args:
1695 
  """
1696 
  Attributes:
1697 
   - emailorhandle
1698 
   - isEmail
1699 
  """
1700 
 
1701 
  thrift_spec = (
1702 
    None, # 0
1703 
    (1, TType.STRING, 'emailorhandle', None, None, ), # 1
1704 
    (2, TType.BOOL, 'isEmail', None, None, ), # 2
1705 
  )
1706 
 
1707 
  def __init__(self, emailorhandle=None, isEmail=None,):
1708 
    self.emailorhandle = emailorhandle
1709 
    self.isEmail = isEmail
1710 
 
1711 
  def read(self, iprot):
1712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1714 
      return
1715 
    iprot.readStructBegin()
1716 
    while True:
1717 
      (fname, ftype, fid) = iprot.readFieldBegin()
1718 
      if ftype == TType.STOP:
1719 
        break
1720 
      if fid == 1:
1721 
        if ftype == TType.STRING:
1722 
          self.emailorhandle = iprot.readString();
1723 
        else:
1724 
          iprot.skip(ftype)
1725 
      elif fid == 2:
1726 
        if ftype == TType.BOOL:
1727 
          self.isEmail = iprot.readBool();
1728 
        else:
1729 
          iprot.skip(ftype)
1730 
      else:
1731 
        iprot.skip(ftype)
1732 
      iprot.readFieldEnd()
1733 
    iprot.readStructEnd()
1734 
 
1735 
  def write(self, oprot):
1736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1738 
      return
1739 
    oprot.writeStructBegin('getContextFromEmailOrHandle_args')
1740 
    if self.emailorhandle != None:
1741 
      oprot.writeFieldBegin('emailorhandle', TType.STRING, 1)
1742 
      oprot.writeString(self.emailorhandle)
1743 
      oprot.writeFieldEnd()
1744 
    if self.isEmail != None:
1745 
      oprot.writeFieldBegin('isEmail', TType.BOOL, 2)
1746 
      oprot.writeBool(self.isEmail)
1747 
      oprot.writeFieldEnd()
1748 
    oprot.writeFieldStop()
1749 
    oprot.writeStructEnd()
1750 
 
1751 
  def __repr__(self):
1752 
    L = ['%s=%r' % (key, value)
1753 
      for key, value in self.__dict__.iteritems()]
1754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1755 
 
1756 
  def __eq__(self, other):
1757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1758 
 
1759 
  def __ne__(self, other):
1760 
    return not (self == other)
1761 
 
1762 
class getContextFromEmailOrHandle_result:
1763 
  """
1764 
  Attributes:
1765 
   - success
1766 
   - ucx
1767 
  """
1768 
 
1769 
  thrift_spec = (
122 ashish 1770 
    (0, TType.STRUCT, 'success', (UserContext, UserContext.thrift_spec), None, ), # 0
94 ashish 1771 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
1772 
  )
1773 
 
1774 
  def __init__(self, success=None, ucx=None,):
1775 
    self.success = success
1776 
    self.ucx = ucx
1777 
 
1778 
  def read(self, iprot):
1779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1781 
      return
1782 
    iprot.readStructBegin()
1783 
    while True:
1784 
      (fname, ftype, fid) = iprot.readFieldBegin()
1785 
      if ftype == TType.STOP:
1786 
        break
1787 
      if fid == 0:
1788 
        if ftype == TType.STRUCT:
122 ashish 1789 
          self.success = UserContext()
94 ashish 1790 
          self.success.read(iprot)
1791 
        else:
1792 
          iprot.skip(ftype)
1793 
      elif fid == 1:
1794 
        if ftype == TType.STRUCT:
1795 
          self.ucx = UserContextException()
1796 
          self.ucx.read(iprot)
1797 
        else:
1798 
          iprot.skip(ftype)
1799 
      else:
1800 
        iprot.skip(ftype)
1801 
      iprot.readFieldEnd()
1802 
    iprot.readStructEnd()
1803 
 
1804 
  def write(self, oprot):
1805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1807 
      return
1808 
    oprot.writeStructBegin('getContextFromEmailOrHandle_result')
1809 
    if self.success != None:
1810 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
1811 
      self.success.write(oprot)
1812 
      oprot.writeFieldEnd()
1813 
    if self.ucx != None:
1814 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
1815 
      self.ucx.write(oprot)
1816 
      oprot.writeFieldEnd()
1817 
    oprot.writeFieldStop()
1818 
    oprot.writeStructEnd()
1819 
 
1820 
  def __repr__(self):
1821 
    L = ['%s=%r' % (key, value)
1822 
      for key, value in self.__dict__.iteritems()]
1823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1824 
 
1825 
  def __eq__(self, other):
1826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1827 
 
1828 
  def __ne__(self, other):
1829 
    return not (self == other)
1830 
 
1831 
class getState_args:
1832 
  """
1833 
  Attributes:
1834 
   - userId
122 ashish 1835 
   - isSessionId
94 ashish 1836 
  """
1837 
 
1838 
  thrift_spec = (
1839 
    None, # 0
1840 
    (1, TType.I64, 'userId', None, None, ), # 1
122 ashish 1841 
    (2, TType.BOOL, 'isSessionId', None, None, ), # 2
94 ashish 1842 
  )
1843 
 
122 ashish 1844 
  def __init__(self, userId=None, isSessionId=None,):
94 ashish 1845 
    self.userId = userId
122 ashish 1846 
    self.isSessionId = isSessionId
94 ashish 1847 
 
1848 
  def read(self, iprot):
1849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1851 
      return
1852 
    iprot.readStructBegin()
1853 
    while True:
1854 
      (fname, ftype, fid) = iprot.readFieldBegin()
1855 
      if ftype == TType.STOP:
1856 
        break
1857 
      if fid == 1:
1858 
        if ftype == TType.I64:
1859 
          self.userId = iprot.readI64();
1860 
        else:
1861 
          iprot.skip(ftype)
122 ashish 1862 
      elif fid == 2:
1863 
        if ftype == TType.BOOL:
1864 
          self.isSessionId = iprot.readBool();
1865 
        else:
1866 
          iprot.skip(ftype)
94 ashish 1867 
      else:
1868 
        iprot.skip(ftype)
1869 
      iprot.readFieldEnd()
1870 
    iprot.readStructEnd()
1871 
 
1872 
  def write(self, oprot):
1873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1875 
      return
1876 
    oprot.writeStructBegin('getState_args')
1877 
    if self.userId != None:
1878 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1879 
      oprot.writeI64(self.userId)
1880 
      oprot.writeFieldEnd()
122 ashish 1881 
    if self.isSessionId != None:
1882 
      oprot.writeFieldBegin('isSessionId', TType.BOOL, 2)
1883 
      oprot.writeBool(self.isSessionId)
1884 
      oprot.writeFieldEnd()
94 ashish 1885 
    oprot.writeFieldStop()
1886 
    oprot.writeStructEnd()
1887 
 
1888 
  def __repr__(self):
1889 
    L = ['%s=%r' % (key, value)
1890 
      for key, value in self.__dict__.iteritems()]
1891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1892 
 
1893 
  def __eq__(self, other):
1894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1895 
 
1896 
  def __ne__(self, other):
1897 
    return not (self == other)
1898 
 
1899 
class getState_result:
1900 
  """
1901 
  Attributes:
1902 
   - success
1903 
   - ucx
1904 
  """
1905 
 
1906 
  thrift_spec = (
122 ashish 1907 
    (0, TType.STRUCT, 'success', (UserState, UserState.thrift_spec), None, ), # 0
94 ashish 1908 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
1909 
  )
1910 
 
1911 
  def __init__(self, success=None, ucx=None,):
1912 
    self.success = success
1913 
    self.ucx = ucx
1914 
 
1915 
  def read(self, iprot):
1916 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1917 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1918 
      return
1919 
    iprot.readStructBegin()
1920 
    while True:
1921 
      (fname, ftype, fid) = iprot.readFieldBegin()
1922 
      if ftype == TType.STOP:
1923 
        break
1924 
      if fid == 0:
1925 
        if ftype == TType.STRUCT:
122 ashish 1926 
          self.success = UserState()
94 ashish 1927 
          self.success.read(iprot)
1928 
        else:
1929 
          iprot.skip(ftype)
1930 
      elif fid == 1:
1931 
        if ftype == TType.STRUCT:
1932 
          self.ucx = UserContextException()
1933 
          self.ucx.read(iprot)
1934 
        else:
1935 
          iprot.skip(ftype)
1936 
      else:
1937 
        iprot.skip(ftype)
1938 
      iprot.readFieldEnd()
1939 
    iprot.readStructEnd()
1940 
 
1941 
  def write(self, oprot):
1942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1944 
      return
1945 
    oprot.writeStructBegin('getState_result')
1946 
    if self.success != None:
1947 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
1948 
      self.success.write(oprot)
1949 
      oprot.writeFieldEnd()
1950 
    if self.ucx != None:
1951 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
1952 
      self.ucx.write(oprot)
1953 
      oprot.writeFieldEnd()
1954 
    oprot.writeFieldStop()
1955 
    oprot.writeStructEnd()
1956 
 
1957 
  def __repr__(self):
1958 
    L = ['%s=%r' % (key, value)
1959 
      for key, value in self.__dict__.iteritems()]
1960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1961 
 
1962 
  def __eq__(self, other):
1963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1964 
 
1965 
  def __ne__(self, other):
1966 
    return not (self == other)
1967 
 
1968 
class getPrimaryInfo_args:
1969 
  """
1970 
  Attributes:
1971 
   - userId
122 ashish 1972 
   - isSessionId
94 ashish 1973 
  """
1974 
 
1975 
  thrift_spec = (
1976 
    None, # 0
1977 
    (1, TType.I64, 'userId', None, None, ), # 1
122 ashish 1978 
    (2, TType.BOOL, 'isSessionId', None, None, ), # 2
94 ashish 1979 
  )
1980 
 
122 ashish 1981 
  def __init__(self, userId=None, isSessionId=None,):
94 ashish 1982 
    self.userId = userId
122 ashish 1983 
    self.isSessionId = isSessionId
94 ashish 1984 
 
1985 
  def read(self, iprot):
1986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1988 
      return
1989 
    iprot.readStructBegin()
1990 
    while True:
1991 
      (fname, ftype, fid) = iprot.readFieldBegin()
1992 
      if ftype == TType.STOP:
1993 
        break
1994 
      if fid == 1:
1995 
        if ftype == TType.I64:
1996 
          self.userId = iprot.readI64();
1997 
        else:
1998 
          iprot.skip(ftype)
122 ashish 1999 
      elif fid == 2:
2000 
        if ftype == TType.BOOL:
2001 
          self.isSessionId = iprot.readBool();
2002 
        else:
2003 
          iprot.skip(ftype)
94 ashish 2004 
      else:
2005 
        iprot.skip(ftype)
2006 
      iprot.readFieldEnd()
2007 
    iprot.readStructEnd()
2008 
 
2009 
  def write(self, oprot):
2010 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2011 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2012 
      return
2013 
    oprot.writeStructBegin('getPrimaryInfo_args')
2014 
    if self.userId != None:
2015 
      oprot.writeFieldBegin('userId', TType.I64, 1)
2016 
      oprot.writeI64(self.userId)
2017 
      oprot.writeFieldEnd()
122 ashish 2018 
    if self.isSessionId != None:
2019 
      oprot.writeFieldBegin('isSessionId', TType.BOOL, 2)
2020 
      oprot.writeBool(self.isSessionId)
2021 
      oprot.writeFieldEnd()
94 ashish 2022 
    oprot.writeFieldStop()
2023 
    oprot.writeStructEnd()
2024 
 
2025 
  def __repr__(self):
2026 
    L = ['%s=%r' % (key, value)
2027 
      for key, value in self.__dict__.iteritems()]
2028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2029 
 
2030 
  def __eq__(self, other):
2031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2032 
 
2033 
  def __ne__(self, other):
2034 
    return not (self == other)
2035 
 
2036 
class getPrimaryInfo_result:
2037 
  """
2038 
  Attributes:
2039 
   - success
2040 
   - ucx
2041 
  """
2042 
 
2043 
  thrift_spec = (
122 ashish 2044 
    (0, TType.STRUCT, 'success', (UserPrimaryInfo, UserPrimaryInfo.thrift_spec), None, ), # 0
94 ashish 2045 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
2046 
  )
2047 
 
2048 
  def __init__(self, success=None, ucx=None,):
2049 
    self.success = success
2050 
    self.ucx = ucx
2051 
 
2052 
  def read(self, iprot):
2053 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2054 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2055 
      return
2056 
    iprot.readStructBegin()
2057 
    while True:
2058 
      (fname, ftype, fid) = iprot.readFieldBegin()
2059 
      if ftype == TType.STOP:
2060 
        break
2061 
      if fid == 0:
2062 
        if ftype == TType.STRUCT:
122 ashish 2063 
          self.success = UserPrimaryInfo()
94 ashish 2064 
          self.success.read(iprot)
2065 
        else:
2066 
          iprot.skip(ftype)
2067 
      elif fid == 1:
2068 
        if ftype == TType.STRUCT:
2069 
          self.ucx = UserContextException()
2070 
          self.ucx.read(iprot)
2071 
        else:
2072 
          iprot.skip(ftype)
2073 
      else:
2074 
        iprot.skip(ftype)
2075 
      iprot.readFieldEnd()
2076 
    iprot.readStructEnd()
2077 
 
2078 
  def write(self, oprot):
2079 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2080 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2081 
      return
2082 
    oprot.writeStructBegin('getPrimaryInfo_result')
2083 
    if self.success != None:
2084 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
2085 
      self.success.write(oprot)
2086 
      oprot.writeFieldEnd()
2087 
    if self.ucx != None:
2088 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
2089 
      self.ucx.write(oprot)
2090 
      oprot.writeFieldEnd()
2091 
    oprot.writeFieldStop()
2092 
    oprot.writeStructEnd()
2093 
 
2094 
  def __repr__(self):
2095 
    L = ['%s=%r' % (key, value)
2096 
      for key, value in self.__dict__.iteritems()]
2097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2098 
 
2099 
  def __eq__(self, other):
2100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2101 
 
2102 
  def __ne__(self, other):
2103 
    return not (self == other)
2104 
 
2105 
class getInternalInfo_args:
2106 
  """
2107 
  Attributes:
2108 
   - userId
122 ashish 2109 
   - isSessionId
94 ashish 2110 
  """
2111 
 
2112 
  thrift_spec = (
2113 
    None, # 0
2114 
    (1, TType.I64, 'userId', None, None, ), # 1
122 ashish 2115 
    (2, TType.BOOL, 'isSessionId', None, None, ), # 2
94 ashish 2116 
  )
2117 
 
122 ashish 2118 
  def __init__(self, userId=None, isSessionId=None,):
94 ashish 2119 
    self.userId = userId
122 ashish 2120 
    self.isSessionId = isSessionId
94 ashish 2121 
 
2122 
  def read(self, iprot):
2123 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2124 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2125 
      return
2126 
    iprot.readStructBegin()
2127 
    while True:
2128 
      (fname, ftype, fid) = iprot.readFieldBegin()
2129 
      if ftype == TType.STOP:
2130 
        break
2131 
      if fid == 1:
2132 
        if ftype == TType.I64:
2133 
          self.userId = iprot.readI64();
2134 
        else:
2135 
          iprot.skip(ftype)
122 ashish 2136 
      elif fid == 2:
2137 
        if ftype == TType.BOOL:
2138 
          self.isSessionId = iprot.readBool();
2139 
        else:
2140 
          iprot.skip(ftype)
94 ashish 2141 
      else:
2142 
        iprot.skip(ftype)
2143 
      iprot.readFieldEnd()
2144 
    iprot.readStructEnd()
2145 
 
2146 
  def write(self, oprot):
2147 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2148 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2149 
      return
2150 
    oprot.writeStructBegin('getInternalInfo_args')
2151 
    if self.userId != None:
2152 
      oprot.writeFieldBegin('userId', TType.I64, 1)
2153 
      oprot.writeI64(self.userId)
2154 
      oprot.writeFieldEnd()
122 ashish 2155 
    if self.isSessionId != None:
2156 
      oprot.writeFieldBegin('isSessionId', TType.BOOL, 2)
2157 
      oprot.writeBool(self.isSessionId)
2158 
      oprot.writeFieldEnd()
94 ashish 2159 
    oprot.writeFieldStop()
2160 
    oprot.writeStructEnd()
2161 
 
2162 
  def __repr__(self):
2163 
    L = ['%s=%r' % (key, value)
2164 
      for key, value in self.__dict__.iteritems()]
2165 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2166 
 
2167 
  def __eq__(self, other):
2168 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2169 
 
2170 
  def __ne__(self, other):
2171 
    return not (self == other)
2172 
 
2173 
class getInternalInfo_result:
2174 
  """
2175 
  Attributes:
2176 
   - success
2177 
   - ucx
2178 
  """
2179 
 
2180 
  thrift_spec = (
122 ashish 2181 
    (0, TType.STRUCT, 'success', (UserInternalInfo, UserInternalInfo.thrift_spec), None, ), # 0
94 ashish 2182 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
2183 
  )
2184 
 
2185 
  def __init__(self, success=None, ucx=None,):
2186 
    self.success = success
2187 
    self.ucx = ucx
2188 
 
2189 
  def read(self, iprot):
2190 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2191 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2192 
      return
2193 
    iprot.readStructBegin()
2194 
    while True:
2195 
      (fname, ftype, fid) = iprot.readFieldBegin()
2196 
      if ftype == TType.STOP:
2197 
        break
2198 
      if fid == 0:
2199 
        if ftype == TType.STRUCT:
122 ashish 2200 
          self.success = UserInternalInfo()
94 ashish 2201 
          self.success.read(iprot)
2202 
        else:
2203 
          iprot.skip(ftype)
2204 
      elif fid == 1:
2205 
        if ftype == TType.STRUCT:
2206 
          self.ucx = UserContextException()
2207 
          self.ucx.read(iprot)
2208 
        else:
2209 
          iprot.skip(ftype)
2210 
      else:
2211 
        iprot.skip(ftype)
2212 
      iprot.readFieldEnd()
2213 
    iprot.readStructEnd()
2214 
 
2215 
  def write(self, oprot):
2216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2218 
      return
2219 
    oprot.writeStructBegin('getInternalInfo_result')
2220 
    if self.success != None:
2221 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
2222 
      self.success.write(oprot)
2223 
      oprot.writeFieldEnd()
2224 
    if self.ucx != None:
2225 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
2226 
      self.ucx.write(oprot)
2227 
      oprot.writeFieldEnd()
2228 
    oprot.writeFieldStop()
2229 
    oprot.writeStructEnd()
2230 
 
2231 
  def __repr__(self):
2232 
    L = ['%s=%r' % (key, value)
2233 
      for key, value in self.__dict__.iteritems()]
2234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2235 
 
2236 
  def __eq__(self, other):
2237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2238 
 
2239 
  def __ne__(self, other):
2240 
    return not (self == other)
2241 
 
2242 
class getContext_args:
2243 
  """
2244 
  Attributes:
2245 
   - email
2246 
   - password
2247 
  """
2248 
 
2249 
  thrift_spec = (
2250 
    None, # 0
2251 
    (1, TType.STRING, 'email', None, None, ), # 1
2252 
    (2, TType.STRING, 'password', None, None, ), # 2
2253 
  )
2254 
 
2255 
  def __init__(self, email=None, password=None,):
2256 
    self.email = email
2257 
    self.password = password
2258 
 
2259 
  def read(self, iprot):
2260 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2261 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2262 
      return
2263 
    iprot.readStructBegin()
2264 
    while True:
2265 
      (fname, ftype, fid) = iprot.readFieldBegin()
2266 
      if ftype == TType.STOP:
2267 
        break
2268 
      if fid == 1:
2269 
        if ftype == TType.STRING:
2270 
          self.email = iprot.readString();
2271 
        else:
2272 
          iprot.skip(ftype)
2273 
      elif fid == 2:
2274 
        if ftype == TType.STRING:
2275 
          self.password = iprot.readString();
2276 
        else:
2277 
          iprot.skip(ftype)
2278 
      else:
2279 
        iprot.skip(ftype)
2280 
      iprot.readFieldEnd()
2281 
    iprot.readStructEnd()
2282 
 
2283 
  def write(self, oprot):
2284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2286 
      return
2287 
    oprot.writeStructBegin('getContext_args')
2288 
    if self.email != None:
2289 
      oprot.writeFieldBegin('email', TType.STRING, 1)
2290 
      oprot.writeString(self.email)
2291 
      oprot.writeFieldEnd()
2292 
    if self.password != None:
2293 
      oprot.writeFieldBegin('password', TType.STRING, 2)
2294 
      oprot.writeString(self.password)
2295 
      oprot.writeFieldEnd()
2296 
    oprot.writeFieldStop()
2297 
    oprot.writeStructEnd()
2298 
 
2299 
  def __repr__(self):
2300 
    L = ['%s=%r' % (key, value)
2301 
      for key, value in self.__dict__.iteritems()]
2302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2303 
 
2304 
  def __eq__(self, other):
2305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2306 
 
2307 
  def __ne__(self, other):
2308 
    return not (self == other)
2309 
 
2310 
class getContext_result:
2311 
  """
2312 
  Attributes:
2313 
   - success
2314 
   - ax
2315 
  """
2316 
 
2317 
  thrift_spec = (
122 ashish 2318 
    (0, TType.STRUCT, 'success', (UserContext, UserContext.thrift_spec), None, ), # 0
94 ashish 2319 
    (1, TType.STRUCT, 'ax', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
2320 
  )
2321 
 
2322 
  def __init__(self, success=None, ax=None,):
2323 
    self.success = success
2324 
    self.ax = ax
2325 
 
2326 
  def read(self, iprot):
2327 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2328 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2329 
      return
2330 
    iprot.readStructBegin()
2331 
    while True:
2332 
      (fname, ftype, fid) = iprot.readFieldBegin()
2333 
      if ftype == TType.STOP:
2334 
        break
2335 
      if fid == 0:
2336 
        if ftype == TType.STRUCT:
122 ashish 2337 
          self.success = UserContext()
94 ashish 2338 
          self.success.read(iprot)
2339 
        else:
2340 
          iprot.skip(ftype)
2341 
      elif fid == 1:
2342 
        if ftype == TType.STRUCT:
2343 
          self.ax = AuthenticationException()
2344 
          self.ax.read(iprot)
2345 
        else:
2346 
          iprot.skip(ftype)
2347 
      else:
2348 
        iprot.skip(ftype)
2349 
      iprot.readFieldEnd()
2350 
    iprot.readStructEnd()
2351 
 
2352 
  def write(self, oprot):
2353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2355 
      return
2356 
    oprot.writeStructBegin('getContext_result')
2357 
    if self.success != None:
2358 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
2359 
      self.success.write(oprot)
2360 
      oprot.writeFieldEnd()
2361 
    if self.ax != None:
2362 
      oprot.writeFieldBegin('ax', TType.STRUCT, 1)
2363 
      self.ax.write(oprot)
2364 
      oprot.writeFieldEnd()
2365 
    oprot.writeFieldStop()
2366 
    oprot.writeStructEnd()
2367 
 
2368 
  def __repr__(self):
2369 
    L = ['%s=%r' % (key, value)
2370 
      for key, value in self.__dict__.iteritems()]
2371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2372 
 
2373 
  def __eq__(self, other):
2374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2375 
 
2376 
  def __ne__(self, other):
2377 
    return not (self == other)
2378 
 
122 ashish 2379 
class authenticateUser_args:
2380 
  """
2381 
  Attributes:
2382 
   - handle
2383 
   - password
2384 
   - isEmail
2385 
  """
2386 
 
2387 
  thrift_spec = (
2388 
    None, # 0
2389 
    (1, TType.STRING, 'handle', None, None, ), # 1
2390 
    (2, TType.STRING, 'password', None, None, ), # 2
2391 
    (3, TType.BOOL, 'isEmail', None, None, ), # 3
2392 
  )
2393 
 
2394 
  def __init__(self, handle=None, password=None, isEmail=None,):
2395 
    self.handle = handle
2396 
    self.password = password
2397 
    self.isEmail = isEmail
2398 
 
2399 
  def read(self, iprot):
2400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2402 
      return
2403 
    iprot.readStructBegin()
2404 
    while True:
2405 
      (fname, ftype, fid) = iprot.readFieldBegin()
2406 
      if ftype == TType.STOP:
2407 
        break
2408 
      if fid == 1:
2409 
        if ftype == TType.STRING:
2410 
          self.handle = iprot.readString();
2411 
        else:
2412 
          iprot.skip(ftype)
2413 
      elif fid == 2:
2414 
        if ftype == TType.STRING:
2415 
          self.password = iprot.readString();
2416 
        else:
2417 
          iprot.skip(ftype)
2418 
      elif fid == 3:
2419 
        if ftype == TType.BOOL:
2420 
          self.isEmail = iprot.readBool();
2421 
        else:
2422 
          iprot.skip(ftype)
2423 
      else:
2424 
        iprot.skip(ftype)
2425 
      iprot.readFieldEnd()
2426 
    iprot.readStructEnd()
2427 
 
2428 
  def write(self, oprot):
2429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2431 
      return
2432 
    oprot.writeStructBegin('authenticateUser_args')
2433 
    if self.handle != None:
2434 
      oprot.writeFieldBegin('handle', TType.STRING, 1)
2435 
      oprot.writeString(self.handle)
2436 
      oprot.writeFieldEnd()
2437 
    if self.password != None:
2438 
      oprot.writeFieldBegin('password', TType.STRING, 2)
2439 
      oprot.writeString(self.password)
2440 
      oprot.writeFieldEnd()
2441 
    if self.isEmail != None:
2442 
      oprot.writeFieldBegin('isEmail', TType.BOOL, 3)
2443 
      oprot.writeBool(self.isEmail)
2444 
      oprot.writeFieldEnd()
2445 
    oprot.writeFieldStop()
2446 
    oprot.writeStructEnd()
2447 
 
2448 
  def __repr__(self):
2449 
    L = ['%s=%r' % (key, value)
2450 
      for key, value in self.__dict__.iteritems()]
2451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2452 
 
2453 
  def __eq__(self, other):
2454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2455 
 
2456 
  def __ne__(self, other):
2457 
    return not (self == other)
2458 
 
2459 
class authenticateUser_result:
2460 
  """
2461 
  Attributes:
2462 
   - success
2463 
   - ax
2464 
  """
2465 
 
2466 
  thrift_spec = (
2467 
    (0, TType.BOOL, 'success', None, None, ), # 0
2468 
    (1, TType.STRUCT, 'ax', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
2469 
  )
2470 
 
2471 
  def __init__(self, success=None, ax=None,):
2472 
    self.success = success
2473 
    self.ax = ax
2474 
 
2475 
  def read(self, iprot):
2476 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2477 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2478 
      return
2479 
    iprot.readStructBegin()
2480 
    while True:
2481 
      (fname, ftype, fid) = iprot.readFieldBegin()
2482 
      if ftype == TType.STOP:
2483 
        break
2484 
      if fid == 0:
2485 
        if ftype == TType.BOOL:
2486 
          self.success = iprot.readBool();
2487 
        else:
2488 
          iprot.skip(ftype)
2489 
      elif fid == 1:
2490 
        if ftype == TType.STRUCT:
2491 
          self.ax = AuthenticationException()
2492 
          self.ax.read(iprot)
2493 
        else:
2494 
          iprot.skip(ftype)
2495 
      else:
2496 
        iprot.skip(ftype)
2497 
      iprot.readFieldEnd()
2498 
    iprot.readStructEnd()
2499 
 
2500 
  def write(self, oprot):
2501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2503 
      return
2504 
    oprot.writeStructBegin('authenticateUser_result')
2505 
    if self.success != None:
2506 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
2507 
      oprot.writeBool(self.success)
2508 
      oprot.writeFieldEnd()
2509 
    if self.ax != None:
2510 
      oprot.writeFieldBegin('ax', TType.STRUCT, 1)
2511 
      self.ax.write(oprot)
2512 
      oprot.writeFieldEnd()
2513 
    oprot.writeFieldStop()
2514 
    oprot.writeStructEnd()
2515 
 
2516 
  def __repr__(self):
2517 
    L = ['%s=%r' % (key, value)
2518 
      for key, value in self.__dict__.iteritems()]
2519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2520 
 
2521 
  def __eq__(self, other):
2522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2523 
 
2524 
  def __ne__(self, other):
2525 
    return not (self == other)
2526 
 
94 ashish 2527 
class userExists_args:
2528 
  """
2529 
  Attributes:
2530 
   - email
2531 
  """
2532 
 
2533 
  thrift_spec = (
2534 
    None, # 0
2535 
    (1, TType.STRING, 'email', None, None, ), # 1
2536 
  )
2537 
 
2538 
  def __init__(self, email=None,):
2539 
    self.email = email
2540 
 
2541 
  def read(self, iprot):
2542 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2543 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2544 
      return
2545 
    iprot.readStructBegin()
2546 
    while True:
2547 
      (fname, ftype, fid) = iprot.readFieldBegin()
2548 
      if ftype == TType.STOP:
2549 
        break
2550 
      if fid == 1:
2551 
        if ftype == TType.STRING:
2552 
          self.email = iprot.readString();
2553 
        else:
2554 
          iprot.skip(ftype)
2555 
      else:
2556 
        iprot.skip(ftype)
2557 
      iprot.readFieldEnd()
2558 
    iprot.readStructEnd()
2559 
 
2560 
  def write(self, oprot):
2561 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2562 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2563 
      return
2564 
    oprot.writeStructBegin('userExists_args')
2565 
    if self.email != None:
2566 
      oprot.writeFieldBegin('email', TType.STRING, 1)
2567 
      oprot.writeString(self.email)
2568 
      oprot.writeFieldEnd()
2569 
    oprot.writeFieldStop()
2570 
    oprot.writeStructEnd()
2571 
 
2572 
  def __repr__(self):
2573 
    L = ['%s=%r' % (key, value)
2574 
      for key, value in self.__dict__.iteritems()]
2575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2576 
 
2577 
  def __eq__(self, other):
2578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2579 
 
2580 
  def __ne__(self, other):
2581 
    return not (self == other)
2582 
 
2583 
class userExists_result:
2584 
  """
2585 
  Attributes:
2586 
   - success
2587 
   - ucx
2588 
  """
2589 
 
2590 
  thrift_spec = (
2591 
    (0, TType.BOOL, 'success', None, None, ), # 0
2592 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
2593 
  )
2594 
 
2595 
  def __init__(self, success=None, ucx=None,):
2596 
    self.success = success
2597 
    self.ucx = ucx
2598 
 
2599 
  def read(self, iprot):
2600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2602 
      return
2603 
    iprot.readStructBegin()
2604 
    while True:
2605 
      (fname, ftype, fid) = iprot.readFieldBegin()
2606 
      if ftype == TType.STOP:
2607 
        break
2608 
      if fid == 0:
2609 
        if ftype == TType.BOOL:
2610 
          self.success = iprot.readBool();
2611 
        else:
2612 
          iprot.skip(ftype)
2613 
      elif fid == 1:
2614 
        if ftype == TType.STRUCT:
2615 
          self.ucx = UserContextException()
2616 
          self.ucx.read(iprot)
2617 
        else:
2618 
          iprot.skip(ftype)
2619 
      else:
2620 
        iprot.skip(ftype)
2621 
      iprot.readFieldEnd()
2622 
    iprot.readStructEnd()
2623 
 
2624 
  def write(self, oprot):
2625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2627 
      return
2628 
    oprot.writeStructBegin('userExists_result')
2629 
    if self.success != None:
2630 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
2631 
      oprot.writeBool(self.success)
2632 
      oprot.writeFieldEnd()
2633 
    if self.ucx != None:
2634 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
2635 
      self.ucx.write(oprot)
2636 
      oprot.writeFieldEnd()
2637 
    oprot.writeFieldStop()
2638 
    oprot.writeStructEnd()
2639 
 
2640 
  def __repr__(self):
2641 
    L = ['%s=%r' % (key, value)
2642 
      for key, value in self.__dict__.iteritems()]
2643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2644 
 
2645 
  def __eq__(self, other):
2646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2647 
 
2648 
  def __ne__(self, other):
2649 
    return not (self == other)
2650 
 
2651 
class addIpAdressForUser_args:
2652 
  """
2653 
  Attributes:
2654 
   - ip
2655 
   - timestamp
2656 
   - userId
2657 
  """
2658 
 
2659 
  thrift_spec = (
2660 
    None, # 0
2661 
    (1, TType.STRING, 'ip', None, None, ), # 1
2662 
    (2, TType.I64, 'timestamp', None, None, ), # 2
2663 
    (3, TType.I64, 'userId', None, None, ), # 3
2664 
  )
2665 
 
2666 
  def __init__(self, ip=None, timestamp=None, userId=None,):
2667 
    self.ip = ip
2668 
    self.timestamp = timestamp
2669 
    self.userId = userId
2670 
 
2671 
  def read(self, iprot):
2672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2674 
      return
2675 
    iprot.readStructBegin()
2676 
    while True:
2677 
      (fname, ftype, fid) = iprot.readFieldBegin()
2678 
      if ftype == TType.STOP:
2679 
        break
2680 
      if fid == 1:
2681 
        if ftype == TType.STRING:
2682 
          self.ip = iprot.readString();
2683 
        else:
2684 
          iprot.skip(ftype)
2685 
      elif fid == 2:
2686 
        if ftype == TType.I64:
2687 
          self.timestamp = iprot.readI64();
2688 
        else:
2689 
          iprot.skip(ftype)
2690 
      elif fid == 3:
2691 
        if ftype == TType.I64:
2692 
          self.userId = iprot.readI64();
2693 
        else:
2694 
          iprot.skip(ftype)
2695 
      else:
2696 
        iprot.skip(ftype)
2697 
      iprot.readFieldEnd()
2698 
    iprot.readStructEnd()
2699 
 
2700 
  def write(self, oprot):
2701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2703 
      return
2704 
    oprot.writeStructBegin('addIpAdressForUser_args')
2705 
    if self.ip != None:
2706 
      oprot.writeFieldBegin('ip', TType.STRING, 1)
2707 
      oprot.writeString(self.ip)
2708 
      oprot.writeFieldEnd()
2709 
    if self.timestamp != None:
2710 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
2711 
      oprot.writeI64(self.timestamp)
2712 
      oprot.writeFieldEnd()
2713 
    if self.userId != None:
2714 
      oprot.writeFieldBegin('userId', TType.I64, 3)
2715 
      oprot.writeI64(self.userId)
2716 
      oprot.writeFieldEnd()
2717 
    oprot.writeFieldStop()
2718 
    oprot.writeStructEnd()
2719 
 
2720 
  def __repr__(self):
2721 
    L = ['%s=%r' % (key, value)
2722 
      for key, value in self.__dict__.iteritems()]
2723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2724 
 
2725 
  def __eq__(self, other):
2726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2727 
 
2728 
  def __ne__(self, other):
2729 
    return not (self == other)
2730 
 
2731 
class addIpAdressForUser_result:
2732 
  """
2733 
  Attributes:
2734 
   - success
2735 
   - ucx
2736 
  """
2737 
 
2738 
  thrift_spec = (
2739 
    (0, TType.BOOL, 'success', None, None, ), # 0
2740 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
2741 
  )
2742 
 
2743 
  def __init__(self, success=None, ucx=None,):
2744 
    self.success = success
2745 
    self.ucx = ucx
2746 
 
2747 
  def read(self, iprot):
2748 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2749 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2750 
      return
2751 
    iprot.readStructBegin()
2752 
    while True:
2753 
      (fname, ftype, fid) = iprot.readFieldBegin()
2754 
      if ftype == TType.STOP:
2755 
        break
2756 
      if fid == 0:
2757 
        if ftype == TType.BOOL:
2758 
          self.success = iprot.readBool();
2759 
        else:
2760 
          iprot.skip(ftype)
2761 
      elif fid == 1:
2762 
        if ftype == TType.STRUCT:
2763 
          self.ucx = UserContextException()
2764 
          self.ucx.read(iprot)
2765 
        else:
2766 
          iprot.skip(ftype)
2767 
      else:
2768 
        iprot.skip(ftype)
2769 
      iprot.readFieldEnd()
2770 
    iprot.readStructEnd()
2771 
 
2772 
  def write(self, oprot):
2773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2775 
      return
2776 
    oprot.writeStructBegin('addIpAdressForUser_result')
2777 
    if self.success != None:
2778 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
2779 
      oprot.writeBool(self.success)
2780 
      oprot.writeFieldEnd()
2781 
    if self.ucx != None:
2782 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
2783 
      self.ucx.write(oprot)
2784 
      oprot.writeFieldEnd()
2785 
    oprot.writeFieldStop()
2786 
    oprot.writeStructEnd()
2787 
 
2788 
  def __repr__(self):
2789 
    L = ['%s=%r' % (key, value)
2790 
      for key, value in self.__dict__.iteritems()]
2791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2792 
 
2793 
  def __eq__(self, other):
2794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2795 
 
2796 
  def __ne__(self, other):
2797 
    return not (self == other)
2798 
 
2799 
class addAddressForUser_args:
2800 
  """
2801 
  Attributes:
2802 
   - address
2803 
   - userid
2804 
   - timestamp
2805 
  """
2806 
 
2807 
  thrift_spec = (
2808 
    None, # 0
122 ashish 2809 
    (1, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 1
94 ashish 2810 
    (2, TType.I64, 'userid', None, None, ), # 2
2811 
    (3, TType.I64, 'timestamp', None, None, ), # 3
2812 
  )
2813 
 
2814 
  def __init__(self, address=None, userid=None, timestamp=None,):
2815 
    self.address = address
2816 
    self.userid = userid
2817 
    self.timestamp = timestamp
2818 
 
2819 
  def read(self, iprot):
2820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2822 
      return
2823 
    iprot.readStructBegin()
2824 
    while True:
2825 
      (fname, ftype, fid) = iprot.readFieldBegin()
2826 
      if ftype == TType.STOP:
2827 
        break
2828 
      if fid == 1:
2829 
        if ftype == TType.STRUCT:
122 ashish 2830 
          self.address = Address()
94 ashish 2831 
          self.address.read(iprot)
2832 
        else:
2833 
          iprot.skip(ftype)
2834 
      elif fid == 2:
2835 
        if ftype == TType.I64:
2836 
          self.userid = iprot.readI64();
2837 
        else:
2838 
          iprot.skip(ftype)
2839 
      elif fid == 3:
2840 
        if ftype == TType.I64:
2841 
          self.timestamp = iprot.readI64();
2842 
        else:
2843 
          iprot.skip(ftype)
2844 
      else:
2845 
        iprot.skip(ftype)
2846 
      iprot.readFieldEnd()
2847 
    iprot.readStructEnd()
2848 
 
2849 
  def write(self, oprot):
2850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2852 
      return
2853 
    oprot.writeStructBegin('addAddressForUser_args')
2854 
    if self.address != None:
2855 
      oprot.writeFieldBegin('address', TType.STRUCT, 1)
2856 
      self.address.write(oprot)
2857 
      oprot.writeFieldEnd()
2858 
    if self.userid != None:
2859 
      oprot.writeFieldBegin('userid', TType.I64, 2)
2860 
      oprot.writeI64(self.userid)
2861 
      oprot.writeFieldEnd()
2862 
    if self.timestamp != None:
2863 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
2864 
      oprot.writeI64(self.timestamp)
2865 
      oprot.writeFieldEnd()
2866 
    oprot.writeFieldStop()
2867 
    oprot.writeStructEnd()
2868 
 
2869 
  def __repr__(self):
2870 
    L = ['%s=%r' % (key, value)
2871 
      for key, value in self.__dict__.iteritems()]
2872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2873 
 
2874 
  def __eq__(self, other):
2875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2876 
 
2877 
  def __ne__(self, other):
2878 
    return not (self == other)
2879 
 
2880 
class addAddressForUser_result:
2881 
  """
2882 
  Attributes:
2883 
   - success
2884 
   - ucx
2885 
  """
2886 
 
2887 
  thrift_spec = (
2888 
    (0, TType.BOOL, 'success', None, None, ), # 0
2889 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
2890 
  )
2891 
 
2892 
  def __init__(self, success=None, ucx=None,):
2893 
    self.success = success
2894 
    self.ucx = ucx
2895 
 
2896 
  def read(self, iprot):
2897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2899 
      return
2900 
    iprot.readStructBegin()
2901 
    while True:
2902 
      (fname, ftype, fid) = iprot.readFieldBegin()
2903 
      if ftype == TType.STOP:
2904 
        break
2905 
      if fid == 0:
2906 
        if ftype == TType.BOOL:
2907 
          self.success = iprot.readBool();
2908 
        else:
2909 
          iprot.skip(ftype)
2910 
      elif fid == 1:
2911 
        if ftype == TType.STRUCT:
2912 
          self.ucx = UserContextException()
2913 
          self.ucx.read(iprot)
2914 
        else:
2915 
          iprot.skip(ftype)
2916 
      else:
2917 
        iprot.skip(ftype)
2918 
      iprot.readFieldEnd()
2919 
    iprot.readStructEnd()
2920 
 
2921 
  def write(self, oprot):
2922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2924 
      return
2925 
    oprot.writeStructBegin('addAddressForUser_result')
2926 
    if self.success != None:
2927 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
2928 
      oprot.writeBool(self.success)
2929 
      oprot.writeFieldEnd()
2930 
    if self.ucx != None:
2931 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
2932 
      self.ucx.write(oprot)
2933 
      oprot.writeFieldEnd()
2934 
    oprot.writeFieldStop()
2935 
    oprot.writeStructEnd()
2936 
 
2937 
  def __repr__(self):
2938 
    L = ['%s=%r' % (key, value)
2939 
      for key, value in self.__dict__.iteritems()]
2940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2941 
 
2942 
  def __eq__(self, other):
2943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2944 
 
2945 
  def __ne__(self, other):
2946 
    return not (self == other)
2947 
 
2948 
class removeAddressForUser_args:
2949 
  """
2950 
  Attributes:
2951 
   - userid
2952 
   - addressId
2953 
  """
2954 
 
2955 
  thrift_spec = (
2956 
    None, # 0
2957 
    (1, TType.I64, 'userid', None, None, ), # 1
2958 
    (2, TType.I64, 'addressId', None, None, ), # 2
2959 
  )
2960 
 
2961 
  def __init__(self, userid=None, addressId=None,):
2962 
    self.userid = userid
2963 
    self.addressId = addressId
2964 
 
2965 
  def read(self, iprot):
2966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2968 
      return
2969 
    iprot.readStructBegin()
2970 
    while True:
2971 
      (fname, ftype, fid) = iprot.readFieldBegin()
2972 
      if ftype == TType.STOP:
2973 
        break
2974 
      if fid == 1:
2975 
        if ftype == TType.I64:
2976 
          self.userid = iprot.readI64();
2977 
        else:
2978 
          iprot.skip(ftype)
2979 
      elif fid == 2:
2980 
        if ftype == TType.I64:
2981 
          self.addressId = iprot.readI64();
2982 
        else:
2983 
          iprot.skip(ftype)
2984 
      else:
2985 
        iprot.skip(ftype)
2986 
      iprot.readFieldEnd()
2987 
    iprot.readStructEnd()
2988 
 
2989 
  def write(self, oprot):
2990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2992 
      return
2993 
    oprot.writeStructBegin('removeAddressForUser_args')
2994 
    if self.userid != None:
2995 
      oprot.writeFieldBegin('userid', TType.I64, 1)
2996 
      oprot.writeI64(self.userid)
2997 
      oprot.writeFieldEnd()
2998 
    if self.addressId != None:
2999 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
3000 
      oprot.writeI64(self.addressId)
3001 
      oprot.writeFieldEnd()
3002 
    oprot.writeFieldStop()
3003 
    oprot.writeStructEnd()
3004 
 
3005 
  def __repr__(self):
3006 
    L = ['%s=%r' % (key, value)
3007 
      for key, value in self.__dict__.iteritems()]
3008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3009 
 
3010 
  def __eq__(self, other):
3011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3012 
 
3013 
  def __ne__(self, other):
3014 
    return not (self == other)
3015 
 
3016 
class removeAddressForUser_result:
3017 
  """
3018 
  Attributes:
3019 
   - success
3020 
   - ucx
3021 
  """
3022 
 
3023 
  thrift_spec = (
3024 
    (0, TType.BOOL, 'success', None, None, ), # 0
3025 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
3026 
  )
3027 
 
3028 
  def __init__(self, success=None, ucx=None,):
3029 
    self.success = success
3030 
    self.ucx = ucx
3031 
 
3032 
  def read(self, iprot):
3033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3035 
      return
3036 
    iprot.readStructBegin()
3037 
    while True:
3038 
      (fname, ftype, fid) = iprot.readFieldBegin()
3039 
      if ftype == TType.STOP:
3040 
        break
3041 
      if fid == 0:
3042 
        if ftype == TType.BOOL:
3043 
          self.success = iprot.readBool();
3044 
        else:
3045 
          iprot.skip(ftype)
3046 
      elif fid == 1:
3047 
        if ftype == TType.STRUCT:
3048 
          self.ucx = UserContextException()
3049 
          self.ucx.read(iprot)
3050 
        else:
3051 
          iprot.skip(ftype)
3052 
      else:
3053 
        iprot.skip(ftype)
3054 
      iprot.readFieldEnd()
3055 
    iprot.readStructEnd()
3056 
 
3057 
  def write(self, oprot):
3058 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3059 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3060 
      return
3061 
    oprot.writeStructBegin('removeAddressForUser_result')
3062 
    if self.success != None:
3063 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3064 
      oprot.writeBool(self.success)
3065 
      oprot.writeFieldEnd()
3066 
    if self.ucx != None:
3067 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
3068 
      self.ucx.write(oprot)
3069 
      oprot.writeFieldEnd()
3070 
    oprot.writeFieldStop()
3071 
    oprot.writeStructEnd()
3072 
 
3073 
  def __repr__(self):
3074 
    L = ['%s=%r' % (key, value)
3075 
      for key, value in self.__dict__.iteritems()]
3076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3077 
 
3078 
  def __eq__(self, other):
3079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3080 
 
3081 
  def __ne__(self, other):
3082 
    return not (self == other)
3083 
 
3084 
class setUserAsLoggedIn_args:
3085 
  """
3086 
  Attributes:
3087 
   - userId
3088 
   - timestamp
3089 
  """
3090 
 
3091 
  thrift_spec = (
3092 
    None, # 0
3093 
    (1, TType.I64, 'userId', None, None, ), # 1
3094 
    (2, TType.I64, 'timestamp', None, None, ), # 2
3095 
  )
3096 
 
3097 
  def __init__(self, userId=None, timestamp=None,):
3098 
    self.userId = userId
3099 
    self.timestamp = timestamp
3100 
 
3101 
  def read(self, iprot):
3102 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3103 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3104 
      return
3105 
    iprot.readStructBegin()
3106 
    while True:
3107 
      (fname, ftype, fid) = iprot.readFieldBegin()
3108 
      if ftype == TType.STOP:
3109 
        break
3110 
      if fid == 1:
3111 
        if ftype == TType.I64:
3112 
          self.userId = iprot.readI64();
3113 
        else:
3114 
          iprot.skip(ftype)
3115 
      elif fid == 2:
3116 
        if ftype == TType.I64:
3117 
          self.timestamp = iprot.readI64();
3118 
        else:
3119 
          iprot.skip(ftype)
3120 
      else:
3121 
        iprot.skip(ftype)
3122 
      iprot.readFieldEnd()
3123 
    iprot.readStructEnd()
3124 
 
3125 
  def write(self, oprot):
3126 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3127 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3128 
      return
3129 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
3130 
    if self.userId != None:
3131 
      oprot.writeFieldBegin('userId', TType.I64, 1)
3132 
      oprot.writeI64(self.userId)
3133 
      oprot.writeFieldEnd()
3134 
    if self.timestamp != None:
3135 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
3136 
      oprot.writeI64(self.timestamp)
3137 
      oprot.writeFieldEnd()
3138 
    oprot.writeFieldStop()
3139 
    oprot.writeStructEnd()
3140 
 
3141 
  def __repr__(self):
3142 
    L = ['%s=%r' % (key, value)
3143 
      for key, value in self.__dict__.iteritems()]
3144 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3145 
 
3146 
  def __eq__(self, other):
3147 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3148 
 
3149 
  def __ne__(self, other):
3150 
    return not (self == other)
3151 
 
3152 
class setUserAsLoggedIn_result:
3153 
  """
3154 
  Attributes:
3155 
   - success
3156 
   - ucx
3157 
  """
3158 
 
3159 
  thrift_spec = (
3160 
    (0, TType.BOOL, 'success', None, None, ), # 0
3161 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
3162 
  )
3163 
 
3164 
  def __init__(self, success=None, ucx=None,):
3165 
    self.success = success
3166 
    self.ucx = ucx
3167 
 
3168 
  def read(self, iprot):
3169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3171 
      return
3172 
    iprot.readStructBegin()
3173 
    while True:
3174 
      (fname, ftype, fid) = iprot.readFieldBegin()
3175 
      if ftype == TType.STOP:
3176 
        break
3177 
      if fid == 0:
3178 
        if ftype == TType.BOOL:
3179 
          self.success = iprot.readBool();
3180 
        else:
3181 
          iprot.skip(ftype)
3182 
      elif fid == 1:
3183 
        if ftype == TType.STRUCT:
3184 
          self.ucx = UserContextException()
3185 
          self.ucx.read(iprot)
3186 
        else:
3187 
          iprot.skip(ftype)
3188 
      else:
3189 
        iprot.skip(ftype)
3190 
      iprot.readFieldEnd()
3191 
    iprot.readStructEnd()
3192 
 
3193 
  def write(self, oprot):
3194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3196 
      return
3197 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
3198 
    if self.success != None:
3199 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3200 
      oprot.writeBool(self.success)
3201 
      oprot.writeFieldEnd()
3202 
    if self.ucx != None:
3203 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
3204 
      self.ucx.write(oprot)
3205 
      oprot.writeFieldEnd()
3206 
    oprot.writeFieldStop()
3207 
    oprot.writeStructEnd()
3208 
 
3209 
  def __repr__(self):
3210 
    L = ['%s=%r' % (key, value)
3211 
      for key, value in self.__dict__.iteritems()]
3212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3213 
 
3214 
  def __eq__(self, other):
3215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3216 
 
3217 
  def __ne__(self, other):
3218 
    return not (self == other)
3219 
 
3220 
class setUserAsLoggedOut_args:
3221 
  """
3222 
  Attributes:
3223 
   - userid
3224 
   - timestamp
3225 
  """
3226 
 
3227 
  thrift_spec = (
3228 
    None, # 0
3229 
    (1, TType.I64, 'userid', None, None, ), # 1
3230 
    (2, TType.I64, 'timestamp', None, None, ), # 2
3231 
  )
3232 
 
3233 
  def __init__(self, userid=None, timestamp=None,):
3234 
    self.userid = userid
3235 
    self.timestamp = timestamp
3236 
 
3237 
  def read(self, iprot):
3238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3240 
      return
3241 
    iprot.readStructBegin()
3242 
    while True:
3243 
      (fname, ftype, fid) = iprot.readFieldBegin()
3244 
      if ftype == TType.STOP:
3245 
        break
3246 
      if fid == 1:
3247 
        if ftype == TType.I64:
3248 
          self.userid = iprot.readI64();
3249 
        else:
3250 
          iprot.skip(ftype)
3251 
      elif fid == 2:
3252 
        if ftype == TType.I64:
3253 
          self.timestamp = iprot.readI64();
3254 
        else:
3255 
          iprot.skip(ftype)
3256 
      else:
3257 
        iprot.skip(ftype)
3258 
      iprot.readFieldEnd()
3259 
    iprot.readStructEnd()
3260 
 
3261 
  def write(self, oprot):
3262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3264 
      return
3265 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
3266 
    if self.userid != None:
3267 
      oprot.writeFieldBegin('userid', TType.I64, 1)
3268 
      oprot.writeI64(self.userid)
3269 
      oprot.writeFieldEnd()
3270 
    if self.timestamp != None:
3271 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
3272 
      oprot.writeI64(self.timestamp)
3273 
      oprot.writeFieldEnd()
3274 
    oprot.writeFieldStop()
3275 
    oprot.writeStructEnd()
3276 
 
3277 
  def __repr__(self):
3278 
    L = ['%s=%r' % (key, value)
3279 
      for key, value in self.__dict__.iteritems()]
3280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3281 
 
3282 
  def __eq__(self, other):
3283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3284 
 
3285 
  def __ne__(self, other):
3286 
    return not (self == other)
3287 
 
3288 
class setUserAsLoggedOut_result:
3289 
  """
3290 
  Attributes:
3291 
   - success
3292 
   - ucx
3293 
  """
3294 
 
3295 
  thrift_spec = (
3296 
    (0, TType.BOOL, 'success', None, None, ), # 0
3297 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
3298 
  )
3299 
 
3300 
  def __init__(self, success=None, ucx=None,):
3301 
    self.success = success
3302 
    self.ucx = ucx
3303 
 
3304 
  def read(self, iprot):
3305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3307 
      return
3308 
    iprot.readStructBegin()
3309 
    while True:
3310 
      (fname, ftype, fid) = iprot.readFieldBegin()
3311 
      if ftype == TType.STOP:
3312 
        break
3313 
      if fid == 0:
3314 
        if ftype == TType.BOOL:
3315 
          self.success = iprot.readBool();
3316 
        else:
3317 
          iprot.skip(ftype)
3318 
      elif fid == 1:
3319 
        if ftype == TType.STRUCT:
3320 
          self.ucx = UserContextException()
3321 
          self.ucx.read(iprot)
3322 
        else:
3323 
          iprot.skip(ftype)
3324 
      else:
3325 
        iprot.skip(ftype)
3326 
      iprot.readFieldEnd()
3327 
    iprot.readStructEnd()
3328 
 
3329 
  def write(self, oprot):
3330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3332 
      return
3333 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
3334 
    if self.success != None:
3335 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3336 
      oprot.writeBool(self.success)
3337 
      oprot.writeFieldEnd()
3338 
    if self.ucx != None:
3339 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
3340 
      self.ucx.write(oprot)
3341 
      oprot.writeFieldEnd()
3342 
    oprot.writeFieldStop()
3343 
    oprot.writeStructEnd()
3344 
 
3345 
  def __repr__(self):
3346 
    L = ['%s=%r' % (key, value)
3347 
      for key, value in self.__dict__.iteritems()]
3348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3349 
 
3350 
  def __eq__(self, other):
3351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3352 
 
3353 
  def __ne__(self, other):
3354 
    return not (self == other)
3355 
 
504 rajveer 3356 
class setDefaultAddress_args:
3357 
  """
3358 
  Attributes:
3359 
   - userid
3360 
   - addressId
3361 
  """
3362 
 
3363 
  thrift_spec = (
3364 
    None, # 0
3365 
    (1, TType.I64, 'userid', None, None, ), # 1
3366 
    (2, TType.I64, 'addressId', None, None, ), # 2
3367 
  )
3368 
 
3369 
  def __init__(self, userid=None, addressId=None,):
3370 
    self.userid = userid
3371 
    self.addressId = addressId
3372 
 
3373 
  def read(self, iprot):
3374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3376 
      return
3377 
    iprot.readStructBegin()
3378 
    while True:
3379 
      (fname, ftype, fid) = iprot.readFieldBegin()
3380 
      if ftype == TType.STOP:
3381 
        break
3382 
      if fid == 1:
3383 
        if ftype == TType.I64:
3384 
          self.userid = iprot.readI64();
3385 
        else:
3386 
          iprot.skip(ftype)
3387 
      elif fid == 2:
3388 
        if ftype == TType.I64:
3389 
          self.addressId = iprot.readI64();
3390 
        else:
3391 
          iprot.skip(ftype)
3392 
      else:
3393 
        iprot.skip(ftype)
3394 
      iprot.readFieldEnd()
3395 
    iprot.readStructEnd()
3396 
 
3397 
  def write(self, oprot):
3398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3400 
      return
3401 
    oprot.writeStructBegin('setDefaultAddress_args')
3402 
    if self.userid != None:
3403 
      oprot.writeFieldBegin('userid', TType.I64, 1)
3404 
      oprot.writeI64(self.userid)
3405 
      oprot.writeFieldEnd()
3406 
    if self.addressId != None:
3407 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
3408 
      oprot.writeI64(self.addressId)
3409 
      oprot.writeFieldEnd()
3410 
    oprot.writeFieldStop()
3411 
    oprot.writeStructEnd()
3412 
 
3413 
  def __repr__(self):
3414 
    L = ['%s=%r' % (key, value)
3415 
      for key, value in self.__dict__.iteritems()]
3416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3417 
 
3418 
  def __eq__(self, other):
3419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3420 
 
3421 
  def __ne__(self, other):
3422 
    return not (self == other)
3423 
 
3424 
class setDefaultAddress_result:
3425 
  """
3426 
  Attributes:
3427 
   - success
3428 
   - ucx
3429 
  """
3430 
 
3431 
  thrift_spec = (
3432 
    (0, TType.BOOL, 'success', None, None, ), # 0
3433 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
3434 
  )
3435 
 
3436 
  def __init__(self, success=None, ucx=None,):
3437 
    self.success = success
3438 
    self.ucx = ucx
3439 
 
3440 
  def read(self, iprot):
3441 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3442 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3443 
      return
3444 
    iprot.readStructBegin()
3445 
    while True:
3446 
      (fname, ftype, fid) = iprot.readFieldBegin()
3447 
      if ftype == TType.STOP:
3448 
        break
3449 
      if fid == 0:
3450 
        if ftype == TType.BOOL:
3451 
          self.success = iprot.readBool();
3452 
        else:
3453 
          iprot.skip(ftype)
3454 
      elif fid == 1:
3455 
        if ftype == TType.STRUCT:
3456 
          self.ucx = UserContextException()
3457 
          self.ucx.read(iprot)
3458 
        else:
3459 
          iprot.skip(ftype)
3460 
      else:
3461 
        iprot.skip(ftype)
3462 
      iprot.readFieldEnd()
3463 
    iprot.readStructEnd()
3464 
 
3465 
  def write(self, oprot):
3466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3468 
      return
3469 
    oprot.writeStructBegin('setDefaultAddress_result')
3470 
    if self.success != None:
3471 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3472 
      oprot.writeBool(self.success)
3473 
      oprot.writeFieldEnd()
3474 
    if self.ucx != None:
3475 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
3476 
      self.ucx.write(oprot)
3477 
      oprot.writeFieldEnd()
3478 
    oprot.writeFieldStop()
3479 
    oprot.writeStructEnd()
3480 
 
3481 
  def __repr__(self):
3482 
    L = ['%s=%r' % (key, value)
3483 
      for key, value in self.__dict__.iteritems()]
3484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3485 
 
3486 
  def __eq__(self, other):
3487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3488 
 
3489 
  def __ne__(self, other):
3490 
    return not (self == other)
3491 
 
94 ashish 3492 
class updatePassword_args:
3493 
  """
3494 
  Attributes:
3495 
   - userid
3496 
   - password
3497 
  """
3498 
 
3499 
  thrift_spec = (
3500 
    None, # 0
3501 
    (1, TType.I64, 'userid', None, None, ), # 1
3502 
    (2, TType.STRING, 'password', None, None, ), # 2
3503 
  )
3504 
 
3505 
  def __init__(self, userid=None, password=None,):
3506 
    self.userid = userid
3507 
    self.password = password
3508 
 
3509 
  def read(self, iprot):
3510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3512 
      return
3513 
    iprot.readStructBegin()
3514 
    while True:
3515 
      (fname, ftype, fid) = iprot.readFieldBegin()
3516 
      if ftype == TType.STOP:
3517 
        break
3518 
      if fid == 1:
3519 
        if ftype == TType.I64:
3520 
          self.userid = iprot.readI64();
3521 
        else:
3522 
          iprot.skip(ftype)
3523 
      elif fid == 2:
3524 
        if ftype == TType.STRING:
3525 
          self.password = iprot.readString();
3526 
        else:
3527 
          iprot.skip(ftype)
3528 
      else:
3529 
        iprot.skip(ftype)
3530 
      iprot.readFieldEnd()
3531 
    iprot.readStructEnd()
3532 
 
3533 
  def write(self, oprot):
3534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3536 
      return
3537 
    oprot.writeStructBegin('updatePassword_args')
3538 
    if self.userid != None:
3539 
      oprot.writeFieldBegin('userid', TType.I64, 1)
3540 
      oprot.writeI64(self.userid)
3541 
      oprot.writeFieldEnd()
3542 
    if self.password != None:
3543 
      oprot.writeFieldBegin('password', TType.STRING, 2)
3544 
      oprot.writeString(self.password)
3545 
      oprot.writeFieldEnd()
3546 
    oprot.writeFieldStop()
3547 
    oprot.writeStructEnd()
3548 
 
3549 
  def __repr__(self):
3550 
    L = ['%s=%r' % (key, value)
3551 
      for key, value in self.__dict__.iteritems()]
3552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3553 
 
3554 
  def __eq__(self, other):
3555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3556 
 
3557 
  def __ne__(self, other):
3558 
    return not (self == other)
3559 
 
3560 
class updatePassword_result:
3561 
  """
3562 
  Attributes:
3563 
   - success
3564 
   - ucx
3565 
  """
3566 
 
3567 
  thrift_spec = (
3568 
    (0, TType.BOOL, 'success', None, None, ), # 0
3569 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
3570 
  )
3571 
 
3572 
  def __init__(self, success=None, ucx=None,):
3573 
    self.success = success
3574 
    self.ucx = ucx
3575 
 
3576 
  def read(self, iprot):
3577 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3578 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3579 
      return
3580 
    iprot.readStructBegin()
3581 
    while True:
3582 
      (fname, ftype, fid) = iprot.readFieldBegin()
3583 
      if ftype == TType.STOP:
3584 
        break
3585 
      if fid == 0:
3586 
        if ftype == TType.BOOL:
3587 
          self.success = iprot.readBool();
3588 
        else:
3589 
          iprot.skip(ftype)
3590 
      elif fid == 1:
3591 
        if ftype == TType.STRUCT:
3592 
          self.ucx = UserContextException()
3593 
          self.ucx.read(iprot)
3594 
        else:
3595 
          iprot.skip(ftype)
3596 
      else:
3597 
        iprot.skip(ftype)
3598 
      iprot.readFieldEnd()
3599 
    iprot.readStructEnd()
3600 
 
3601 
  def write(self, oprot):
3602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3604 
      return
3605 
    oprot.writeStructBegin('updatePassword_result')
3606 
    if self.success != None:
3607 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3608 
      oprot.writeBool(self.success)
3609 
      oprot.writeFieldEnd()
3610 
    if self.ucx != None:
3611 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
3612 
      self.ucx.write(oprot)
3613 
      oprot.writeFieldEnd()
3614 
    oprot.writeFieldStop()
3615 
    oprot.writeStructEnd()
3616 
 
3617 
  def __repr__(self):
3618 
    L = ['%s=%r' % (key, value)
3619 
      for key, value in self.__dict__.iteritems()]
3620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3621 
 
3622 
  def __eq__(self, other):
3623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3624 
 
3625 
  def __ne__(self, other):
3626 
    return not (self == other)
3627 
 
3628 
class deleteUser_args:
3629 
  """
3630 
  Attributes:
3631 
   - userid
122 ashish 3632 
   - isSessionId
94 ashish 3633 
  """
3634 
 
3635 
  thrift_spec = (
3636 
    None, # 0
3637 
    (1, TType.I64, 'userid', None, None, ), # 1
122 ashish 3638 
    (2, TType.BOOL, 'isSessionId', None, None, ), # 2
94 ashish 3639 
  )
3640 
 
122 ashish 3641 
  def __init__(self, userid=None, isSessionId=None,):
94 ashish 3642 
    self.userid = userid
122 ashish 3643 
    self.isSessionId = isSessionId
94 ashish 3644 
 
3645 
  def read(self, iprot):
3646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3648 
      return
3649 
    iprot.readStructBegin()
3650 
    while True:
3651 
      (fname, ftype, fid) = iprot.readFieldBegin()
3652 
      if ftype == TType.STOP:
3653 
        break
3654 
      if fid == 1:
3655 
        if ftype == TType.I64:
3656 
          self.userid = iprot.readI64();
3657 
        else:
3658 
          iprot.skip(ftype)
122 ashish 3659 
      elif fid == 2:
3660 
        if ftype == TType.BOOL:
3661 
          self.isSessionId = iprot.readBool();
3662 
        else:
3663 
          iprot.skip(ftype)
94 ashish 3664 
      else:
3665 
        iprot.skip(ftype)
3666 
      iprot.readFieldEnd()
3667 
    iprot.readStructEnd()
3668 
 
3669 
  def write(self, oprot):
3670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3672 
      return
3673 
    oprot.writeStructBegin('deleteUser_args')
3674 
    if self.userid != None:
3675 
      oprot.writeFieldBegin('userid', TType.I64, 1)
3676 
      oprot.writeI64(self.userid)
3677 
      oprot.writeFieldEnd()
122 ashish 3678 
    if self.isSessionId != None:
3679 
      oprot.writeFieldBegin('isSessionId', TType.BOOL, 2)
3680 
      oprot.writeBool(self.isSessionId)
3681 
      oprot.writeFieldEnd()
94 ashish 3682 
    oprot.writeFieldStop()
3683 
    oprot.writeStructEnd()
3684 
 
3685 
  def __repr__(self):
3686 
    L = ['%s=%r' % (key, value)
3687 
      for key, value in self.__dict__.iteritems()]
3688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3689 
 
3690 
  def __eq__(self, other):
3691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3692 
 
3693 
  def __ne__(self, other):
3694 
    return not (self == other)
3695 
 
3696 
class deleteUser_result:
3697 
  """
3698 
  Attributes:
3699 
   - success
3700 
   - ucx
3701 
  """
3702 
 
3703 
  thrift_spec = (
3704 
    (0, TType.BOOL, 'success', None, None, ), # 0
3705 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
3706 
  )
3707 
 
3708 
  def __init__(self, success=None, ucx=None,):
3709 
    self.success = success
3710 
    self.ucx = ucx
3711 
 
3712 
  def read(self, iprot):
3713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3715 
      return
3716 
    iprot.readStructBegin()
3717 
    while True:
3718 
      (fname, ftype, fid) = iprot.readFieldBegin()
3719 
      if ftype == TType.STOP:
3720 
        break
3721 
      if fid == 0:
3722 
        if ftype == TType.BOOL:
3723 
          self.success = iprot.readBool();
3724 
        else:
3725 
          iprot.skip(ftype)
3726 
      elif fid == 1:
3727 
        if ftype == TType.STRUCT:
3728 
          self.ucx = UserContextException()
3729 
          self.ucx.read(iprot)
3730 
        else:
3731 
          iprot.skip(ftype)
3732 
      else:
3733 
        iprot.skip(ftype)
3734 
      iprot.readFieldEnd()
3735 
    iprot.readStructEnd()
3736 
 
3737 
  def write(self, oprot):
3738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3740 
      return
3741 
    oprot.writeStructBegin('deleteUser_result')
3742 
    if self.success != None:
3743 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3744 
      oprot.writeBool(self.success)
3745 
      oprot.writeFieldEnd()
3746 
    if self.ucx != None:
3747 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
3748 
      self.ucx.write(oprot)
3749 
      oprot.writeFieldEnd()
3750 
    oprot.writeFieldStop()
3751 
    oprot.writeStructEnd()
3752 
 
3753 
  def __repr__(self):
3754 
    L = ['%s=%r' % (key, value)
3755 
      for key, value in self.__dict__.iteritems()]
3756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3757 
 
3758 
  def __eq__(self, other):
3759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3760 
 
3761 
  def __ne__(self, other):
3762 
    return not (self == other)
3763 
 
3764 
class sendEmailVerification_args:
3765 
  """
3766 
  Attributes:
3767 
   - userid
3768 
  """
3769 
 
3770 
  thrift_spec = (
3771 
    None, # 0
3772 
    (1, TType.I64, 'userid', None, None, ), # 1
3773 
  )
3774 
 
3775 
  def __init__(self, userid=None,):
3776 
    self.userid = userid
3777 
 
3778 
  def read(self, iprot):
3779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3781 
      return
3782 
    iprot.readStructBegin()
3783 
    while True:
3784 
      (fname, ftype, fid) = iprot.readFieldBegin()
3785 
      if ftype == TType.STOP:
3786 
        break
3787 
      if fid == 1:
3788 
        if ftype == TType.I64:
3789 
          self.userid = iprot.readI64();
3790 
        else:
3791 
          iprot.skip(ftype)
3792 
      else:
3793 
        iprot.skip(ftype)
3794 
      iprot.readFieldEnd()
3795 
    iprot.readStructEnd()
3796 
 
3797 
  def write(self, oprot):
3798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3800 
      return
3801 
    oprot.writeStructBegin('sendEmailVerification_args')
3802 
    if self.userid != None:
3803 
      oprot.writeFieldBegin('userid', TType.I64, 1)
3804 
      oprot.writeI64(self.userid)
3805 
      oprot.writeFieldEnd()
3806 
    oprot.writeFieldStop()
3807 
    oprot.writeStructEnd()
3808 
 
3809 
  def __repr__(self):
3810 
    L = ['%s=%r' % (key, value)
3811 
      for key, value in self.__dict__.iteritems()]
3812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3813 
 
3814 
  def __eq__(self, other):
3815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3816 
 
3817 
  def __ne__(self, other):
3818 
    return not (self == other)
3819 
 
3820 
class sendEmailVerification_result:
3821 
  """
3822 
  Attributes:
3823 
   - success
3824 
   - ucx
3825 
  """
3826 
 
3827 
  thrift_spec = (
3828 
    (0, TType.BOOL, 'success', None, None, ), # 0
3829 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
3830 
  )
3831 
 
3832 
  def __init__(self, success=None, ucx=None,):
3833 
    self.success = success
3834 
    self.ucx = ucx
3835 
 
3836 
  def read(self, iprot):
3837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3839 
      return
3840 
    iprot.readStructBegin()
3841 
    while True:
3842 
      (fname, ftype, fid) = iprot.readFieldBegin()
3843 
      if ftype == TType.STOP:
3844 
        break
3845 
      if fid == 0:
3846 
        if ftype == TType.BOOL:
3847 
          self.success = iprot.readBool();
3848 
        else:
3849 
          iprot.skip(ftype)
3850 
      elif fid == 1:
3851 
        if ftype == TType.STRUCT:
3852 
          self.ucx = UserContextException()
3853 
          self.ucx.read(iprot)
3854 
        else:
3855 
          iprot.skip(ftype)
3856 
      else:
3857 
        iprot.skip(ftype)
3858 
      iprot.readFieldEnd()
3859 
    iprot.readStructEnd()
3860 
 
3861 
  def write(self, oprot):
3862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3864 
      return
3865 
    oprot.writeStructBegin('sendEmailVerification_result')
3866 
    if self.success != None:
3867 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3868 
      oprot.writeBool(self.success)
3869 
      oprot.writeFieldEnd()
3870 
    if self.ucx != None:
3871 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
3872 
      self.ucx.write(oprot)
3873 
      oprot.writeFieldEnd()
3874 
    oprot.writeFieldStop()
3875 
    oprot.writeStructEnd()
3876 
 
3877 
  def __repr__(self):
3878 
    L = ['%s=%r' % (key, value)
3879 
      for key, value in self.__dict__.iteritems()]
3880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3881 
 
3882 
  def __eq__(self, other):
3883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3884 
 
3885 
  def __ne__(self, other):
3886 
    return not (self == other)
3887 
 
3888 
class sendSMSVerification_args:
3889 
  """
3890 
  Attributes:
3891 
   - userid
3892 
  """
3893 
 
3894 
  thrift_spec = (
3895 
    None, # 0
3896 
    (1, TType.I64, 'userid', None, None, ), # 1
3897 
  )
3898 
 
3899 
  def __init__(self, userid=None,):
3900 
    self.userid = userid
3901 
 
3902 
  def read(self, iprot):
3903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3905 
      return
3906 
    iprot.readStructBegin()
3907 
    while True:
3908 
      (fname, ftype, fid) = iprot.readFieldBegin()
3909 
      if ftype == TType.STOP:
3910 
        break
3911 
      if fid == 1:
3912 
        if ftype == TType.I64:
3913 
          self.userid = iprot.readI64();
3914 
        else:
3915 
          iprot.skip(ftype)
3916 
      else:
3917 
        iprot.skip(ftype)
3918 
      iprot.readFieldEnd()
3919 
    iprot.readStructEnd()
3920 
 
3921 
  def write(self, oprot):
3922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3924 
      return
3925 
    oprot.writeStructBegin('sendSMSVerification_args')
3926 
    if self.userid != None:
3927 
      oprot.writeFieldBegin('userid', TType.I64, 1)
3928 
      oprot.writeI64(self.userid)
3929 
      oprot.writeFieldEnd()
3930 
    oprot.writeFieldStop()
3931 
    oprot.writeStructEnd()
3932 
 
3933 
  def __repr__(self):
3934 
    L = ['%s=%r' % (key, value)
3935 
      for key, value in self.__dict__.iteritems()]
3936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3937 
 
3938 
  def __eq__(self, other):
3939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3940 
 
3941 
  def __ne__(self, other):
3942 
    return not (self == other)
3943 
 
3944 
class sendSMSVerification_result:
3945 
  """
3946 
  Attributes:
3947 
   - success
3948 
   - ucx
3949 
  """
3950 
 
3951 
  thrift_spec = (
3952 
    (0, TType.BOOL, 'success', None, None, ), # 0
3953 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
3954 
  )
3955 
 
3956 
  def __init__(self, success=None, ucx=None,):
3957 
    self.success = success
3958 
    self.ucx = ucx
3959 
 
3960 
  def read(self, iprot):
3961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3963 
      return
3964 
    iprot.readStructBegin()
3965 
    while True:
3966 
      (fname, ftype, fid) = iprot.readFieldBegin()
3967 
      if ftype == TType.STOP:
3968 
        break
3969 
      if fid == 0:
3970 
        if ftype == TType.BOOL:
3971 
          self.success = iprot.readBool();
3972 
        else:
3973 
          iprot.skip(ftype)
3974 
      elif fid == 1:
3975 
        if ftype == TType.STRUCT:
3976 
          self.ucx = UserContextException()
3977 
          self.ucx.read(iprot)
3978 
        else:
3979 
          iprot.skip(ftype)
3980 
      else:
3981 
        iprot.skip(ftype)
3982 
      iprot.readFieldEnd()
3983 
    iprot.readStructEnd()
3984 
 
3985 
  def write(self, oprot):
3986 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3987 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3988 
      return
3989 
    oprot.writeStructBegin('sendSMSVerification_result')
3990 
    if self.success != None:
3991 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3992 
      oprot.writeBool(self.success)
3993 
      oprot.writeFieldEnd()
3994 
    if self.ucx != None:
3995 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
3996 
      self.ucx.write(oprot)
3997 
      oprot.writeFieldEnd()
3998 
    oprot.writeFieldStop()
3999 
    oprot.writeStructEnd()
4000 
 
4001 
  def __repr__(self):
4002 
    L = ['%s=%r' % (key, value)
4003 
      for key, value in self.__dict__.iteritems()]
4004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4005 
 
4006 
  def __eq__(self, other):
4007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4008 
 
4009 
  def __ne__(self, other):
4010 
    return not (self == other)
4011 
 
4012 
class confirmEmailVerification_args:
4013 
  """
4014 
  Attributes:
4015 
   - userid
4016 
  """
4017 
 
4018 
  thrift_spec = (
4019 
    None, # 0
4020 
    (1, TType.I64, 'userid', None, None, ), # 1
4021 
  )
4022 
 
4023 
  def __init__(self, userid=None,):
4024 
    self.userid = userid
4025 
 
4026 
  def read(self, iprot):
4027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4029 
      return
4030 
    iprot.readStructBegin()
4031 
    while True:
4032 
      (fname, ftype, fid) = iprot.readFieldBegin()
4033 
      if ftype == TType.STOP:
4034 
        break
4035 
      if fid == 1:
4036 
        if ftype == TType.I64:
4037 
          self.userid = iprot.readI64();
4038 
        else:
4039 
          iprot.skip(ftype)
4040 
      else:
4041 
        iprot.skip(ftype)
4042 
      iprot.readFieldEnd()
4043 
    iprot.readStructEnd()
4044 
 
4045 
  def write(self, oprot):
4046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4048 
      return
4049 
    oprot.writeStructBegin('confirmEmailVerification_args')
4050 
    if self.userid != None:
4051 
      oprot.writeFieldBegin('userid', TType.I64, 1)
4052 
      oprot.writeI64(self.userid)
4053 
      oprot.writeFieldEnd()
4054 
    oprot.writeFieldStop()
4055 
    oprot.writeStructEnd()
4056 
 
4057 
  def __repr__(self):
4058 
    L = ['%s=%r' % (key, value)
4059 
      for key, value in self.__dict__.iteritems()]
4060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4061 
 
4062 
  def __eq__(self, other):
4063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4064 
 
4065 
  def __ne__(self, other):
4066 
    return not (self == other)
4067 
 
4068 
class confirmEmailVerification_result:
4069 
  """
4070 
  Attributes:
4071 
   - success
4072 
   - ucx
4073 
  """
4074 
 
4075 
  thrift_spec = (
4076 
    (0, TType.BOOL, 'success', None, None, ), # 0
4077 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4078 
  )
4079 
 
4080 
  def __init__(self, success=None, ucx=None,):
4081 
    self.success = success
4082 
    self.ucx = ucx
4083 
 
4084 
  def read(self, iprot):
4085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4087 
      return
4088 
    iprot.readStructBegin()
4089 
    while True:
4090 
      (fname, ftype, fid) = iprot.readFieldBegin()
4091 
      if ftype == TType.STOP:
4092 
        break
4093 
      if fid == 0:
4094 
        if ftype == TType.BOOL:
4095 
          self.success = iprot.readBool();
4096 
        else:
4097 
          iprot.skip(ftype)
4098 
      elif fid == 1:
4099 
        if ftype == TType.STRUCT:
4100 
          self.ucx = UserContextException()
4101 
          self.ucx.read(iprot)
4102 
        else:
4103 
          iprot.skip(ftype)
4104 
      else:
4105 
        iprot.skip(ftype)
4106 
      iprot.readFieldEnd()
4107 
    iprot.readStructEnd()
4108 
 
4109 
  def write(self, oprot):
4110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4112 
      return
4113 
    oprot.writeStructBegin('confirmEmailVerification_result')
4114 
    if self.success != None:
4115 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4116 
      oprot.writeBool(self.success)
4117 
      oprot.writeFieldEnd()
4118 
    if self.ucx != None:
4119 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
4120 
      self.ucx.write(oprot)
4121 
      oprot.writeFieldEnd()
4122 
    oprot.writeFieldStop()
4123 
    oprot.writeStructEnd()
4124 
 
4125 
  def __repr__(self):
4126 
    L = ['%s=%r' % (key, value)
4127 
      for key, value in self.__dict__.iteritems()]
4128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4129 
 
4130 
  def __eq__(self, other):
4131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4132 
 
4133 
  def __ne__(self, other):
4134 
    return not (self == other)
4135 
 
4136 
class confirmSMSVerification_args:
4137 
  """
4138 
  Attributes:
4139 
   - userid
4140 
  """
4141 
 
4142 
  thrift_spec = (
4143 
    None, # 0
4144 
    (1, TType.I64, 'userid', None, None, ), # 1
4145 
  )
4146 
 
4147 
  def __init__(self, userid=None,):
4148 
    self.userid = userid
4149 
 
4150 
  def read(self, iprot):
4151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4153 
      return
4154 
    iprot.readStructBegin()
4155 
    while True:
4156 
      (fname, ftype, fid) = iprot.readFieldBegin()
4157 
      if ftype == TType.STOP:
4158 
        break
4159 
      if fid == 1:
4160 
        if ftype == TType.I64:
4161 
          self.userid = iprot.readI64();
4162 
        else:
4163 
          iprot.skip(ftype)
4164 
      else:
4165 
        iprot.skip(ftype)
4166 
      iprot.readFieldEnd()
4167 
    iprot.readStructEnd()
4168 
 
4169 
  def write(self, oprot):
4170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4172 
      return
4173 
    oprot.writeStructBegin('confirmSMSVerification_args')
4174 
    if self.userid != None:
4175 
      oprot.writeFieldBegin('userid', TType.I64, 1)
4176 
      oprot.writeI64(self.userid)
4177 
      oprot.writeFieldEnd()
4178 
    oprot.writeFieldStop()
4179 
    oprot.writeStructEnd()
4180 
 
4181 
  def __repr__(self):
4182 
    L = ['%s=%r' % (key, value)
4183 
      for key, value in self.__dict__.iteritems()]
4184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4185 
 
4186 
  def __eq__(self, other):
4187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4188 
 
4189 
  def __ne__(self, other):
4190 
    return not (self == other)
4191 
 
4192 
class confirmSMSVerification_result:
4193 
  """
4194 
  Attributes:
4195 
   - success
4196 
   - ucx
4197 
  """
4198 
 
4199 
  thrift_spec = (
4200 
    (0, TType.BOOL, 'success', None, None, ), # 0
4201 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4202 
  )
4203 
 
4204 
  def __init__(self, success=None, ucx=None,):
4205 
    self.success = success
4206 
    self.ucx = ucx
4207 
 
4208 
  def read(self, iprot):
4209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4211 
      return
4212 
    iprot.readStructBegin()
4213 
    while True:
4214 
      (fname, ftype, fid) = iprot.readFieldBegin()
4215 
      if ftype == TType.STOP:
4216 
        break
4217 
      if fid == 0:
4218 
        if ftype == TType.BOOL:
4219 
          self.success = iprot.readBool();
4220 
        else:
4221 
          iprot.skip(ftype)
4222 
      elif fid == 1:
4223 
        if ftype == TType.STRUCT:
4224 
          self.ucx = UserContextException()
4225 
          self.ucx.read(iprot)
4226 
        else:
4227 
          iprot.skip(ftype)
4228 
      else:
4229 
        iprot.skip(ftype)
4230 
      iprot.readFieldEnd()
4231 
    iprot.readStructEnd()
4232 
 
4233 
  def write(self, oprot):
4234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4236 
      return
4237 
    oprot.writeStructBegin('confirmSMSVerification_result')
4238 
    if self.success != None:
4239 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4240 
      oprot.writeBool(self.success)
4241 
      oprot.writeFieldEnd()
4242 
    if self.ucx != None:
4243 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
4244 
      self.ucx.write(oprot)
4245 
      oprot.writeFieldEnd()
4246 
    oprot.writeFieldStop()
4247 
    oprot.writeStructEnd()
4248 
 
4249 
  def __repr__(self):
4250 
    L = ['%s=%r' % (key, value)
4251 
      for key, value in self.__dict__.iteritems()]
4252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4253 
 
4254 
  def __eq__(self, other):
4255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4256 
 
4257 
  def __ne__(self, other):
4258 
    return not (self == other)
4259 
 
4260 
class addSocialhandle_args:
4261 
  """
4262 
  Attributes:
4263 
   - userid
4264 
   - socialService
4265 
   - handle
4266 
  """
4267 
 
4268 
  thrift_spec = (
4269 
    None, # 0
4270 
    (1, TType.I64, 'userid', None, None, ), # 1
4271 
    (2, TType.STRING, 'socialService', None, None, ), # 2
4272 
    (3, TType.STRING, 'handle', None, None, ), # 3
4273 
  )
4274 
 
4275 
  def __init__(self, userid=None, socialService=None, handle=None,):
4276 
    self.userid = userid
4277 
    self.socialService = socialService
4278 
    self.handle = handle
4279 
 
4280 
  def read(self, iprot):
4281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4283 
      return
4284 
    iprot.readStructBegin()
4285 
    while True:
4286 
      (fname, ftype, fid) = iprot.readFieldBegin()
4287 
      if ftype == TType.STOP:
4288 
        break
4289 
      if fid == 1:
4290 
        if ftype == TType.I64:
4291 
          self.userid = iprot.readI64();
4292 
        else:
4293 
          iprot.skip(ftype)
4294 
      elif fid == 2:
4295 
        if ftype == TType.STRING:
4296 
          self.socialService = iprot.readString();
4297 
        else:
4298 
          iprot.skip(ftype)
4299 
      elif fid == 3:
4300 
        if ftype == TType.STRING:
4301 
          self.handle = iprot.readString();
4302 
        else:
4303 
          iprot.skip(ftype)
4304 
      else:
4305 
        iprot.skip(ftype)
4306 
      iprot.readFieldEnd()
4307 
    iprot.readStructEnd()
4308 
 
4309 
  def write(self, oprot):
4310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4312 
      return
4313 
    oprot.writeStructBegin('addSocialhandle_args')
4314 
    if self.userid != None:
4315 
      oprot.writeFieldBegin('userid', TType.I64, 1)
4316 
      oprot.writeI64(self.userid)
4317 
      oprot.writeFieldEnd()
4318 
    if self.socialService != None:
4319 
      oprot.writeFieldBegin('socialService', TType.STRING, 2)
4320 
      oprot.writeString(self.socialService)
4321 
      oprot.writeFieldEnd()
4322 
    if self.handle != None:
4323 
      oprot.writeFieldBegin('handle', TType.STRING, 3)
4324 
      oprot.writeString(self.handle)
4325 
      oprot.writeFieldEnd()
4326 
    oprot.writeFieldStop()
4327 
    oprot.writeStructEnd()
4328 
 
4329 
  def __repr__(self):
4330 
    L = ['%s=%r' % (key, value)
4331 
      for key, value in self.__dict__.iteritems()]
4332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4333 
 
4334 
  def __eq__(self, other):
4335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4336 
 
4337 
  def __ne__(self, other):
4338 
    return not (self == other)
4339 
 
4340 
class addSocialhandle_result:
4341 
  """
4342 
  Attributes:
4343 
   - success
4344 
   - ucx
4345 
  """
4346 
 
4347 
  thrift_spec = (
4348 
    (0, TType.BOOL, 'success', None, None, ), # 0
4349 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4350 
  )
4351 
 
4352 
  def __init__(self, success=None, ucx=None,):
4353 
    self.success = success
4354 
    self.ucx = ucx
4355 
 
4356 
  def read(self, iprot):
4357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4359 
      return
4360 
    iprot.readStructBegin()
4361 
    while True:
4362 
      (fname, ftype, fid) = iprot.readFieldBegin()
4363 
      if ftype == TType.STOP:
4364 
        break
4365 
      if fid == 0:
4366 
        if ftype == TType.BOOL:
4367 
          self.success = iprot.readBool();
4368 
        else:
4369 
          iprot.skip(ftype)
4370 
      elif fid == 1:
4371 
        if ftype == TType.STRUCT:
4372 
          self.ucx = UserContextException()
4373 
          self.ucx.read(iprot)
4374 
        else:
4375 
          iprot.skip(ftype)
4376 
      else:
4377 
        iprot.skip(ftype)
4378 
      iprot.readFieldEnd()
4379 
    iprot.readStructEnd()
4380 
 
4381 
  def write(self, oprot):
4382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4384 
      return
4385 
    oprot.writeStructBegin('addSocialhandle_result')
4386 
    if self.success != None:
4387 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4388 
      oprot.writeBool(self.success)
4389 
      oprot.writeFieldEnd()
4390 
    if self.ucx != None:
4391 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
4392 
      self.ucx.write(oprot)
4393 
      oprot.writeFieldEnd()
4394 
    oprot.writeFieldStop()
4395 
    oprot.writeStructEnd()
4396 
 
4397 
  def __repr__(self):
4398 
    L = ['%s=%r' % (key, value)
4399 
      for key, value in self.__dict__.iteritems()]
4400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4401 
 
4402 
  def __eq__(self, other):
4403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4404 
 
4405 
  def __ne__(self, other):
4406 
    return not (self == other)
4407 
 
130 ashish 4408 
class sendNewPasswordById_args:
4409 
  """
4410 
  Attributes:
4411 
   - userid
4412 
  """
94 ashish 4413 
 
130 ashish 4414 
  thrift_spec = (
4415 
    None, # 0
4416 
    (1, TType.I64, 'userid', None, None, ), # 1
4417 
  )
4418 
 
4419 
  def __init__(self, userid=None,):
4420 
    self.userid = userid
4421 
 
4422 
  def read(self, iprot):
4423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4425 
      return
4426 
    iprot.readStructBegin()
4427 
    while True:
4428 
      (fname, ftype, fid) = iprot.readFieldBegin()
4429 
      if ftype == TType.STOP:
4430 
        break
4431 
      if fid == 1:
4432 
        if ftype == TType.I64:
4433 
          self.userid = iprot.readI64();
4434 
        else:
4435 
          iprot.skip(ftype)
4436 
      else:
4437 
        iprot.skip(ftype)
4438 
      iprot.readFieldEnd()
4439 
    iprot.readStructEnd()
4440 
 
4441 
  def write(self, oprot):
4442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4444 
      return
4445 
    oprot.writeStructBegin('sendNewPasswordById_args')
4446 
    if self.userid != None:
4447 
      oprot.writeFieldBegin('userid', TType.I64, 1)
4448 
      oprot.writeI64(self.userid)
4449 
      oprot.writeFieldEnd()
4450 
    oprot.writeFieldStop()
4451 
    oprot.writeStructEnd()
4452 
 
4453 
  def __repr__(self):
4454 
    L = ['%s=%r' % (key, value)
4455 
      for key, value in self.__dict__.iteritems()]
4456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4457 
 
4458 
  def __eq__(self, other):
4459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4460 
 
4461 
  def __ne__(self, other):
4462 
    return not (self == other)
4463 
 
4464 
class sendNewPasswordById_result:
4465 
  """
4466 
  Attributes:
4467 
   - success
4468 
   - ucx
4469 
  """
4470 
 
4471 
  thrift_spec = (
4472 
    (0, TType.BOOL, 'success', None, None, ), # 0
4473 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4474 
  )
4475 
 
4476 
  def __init__(self, success=None, ucx=None,):
4477 
    self.success = success
4478 
    self.ucx = ucx
4479 
 
4480 
  def read(self, iprot):
4481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4483 
      return
4484 
    iprot.readStructBegin()
4485 
    while True:
4486 
      (fname, ftype, fid) = iprot.readFieldBegin()
4487 
      if ftype == TType.STOP:
4488 
        break
4489 
      if fid == 0:
4490 
        if ftype == TType.BOOL:
4491 
          self.success = iprot.readBool();
4492 
        else:
4493 
          iprot.skip(ftype)
4494 
      elif fid == 1:
4495 
        if ftype == TType.STRUCT:
4496 
          self.ucx = UserContextException()
4497 
          self.ucx.read(iprot)
4498 
        else:
4499 
          iprot.skip(ftype)
4500 
      else:
4501 
        iprot.skip(ftype)
4502 
      iprot.readFieldEnd()
4503 
    iprot.readStructEnd()
4504 
 
4505 
  def write(self, oprot):
4506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4508 
      return
4509 
    oprot.writeStructBegin('sendNewPasswordById_result')
4510 
    if self.success != None:
4511 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4512 
      oprot.writeBool(self.success)
4513 
      oprot.writeFieldEnd()
4514 
    if self.ucx != None:
4515 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
4516 
      self.ucx.write(oprot)
4517 
      oprot.writeFieldEnd()
4518 
    oprot.writeFieldStop()
4519 
    oprot.writeStructEnd()
4520 
 
4521 
  def __repr__(self):
4522 
    L = ['%s=%r' % (key, value)
4523 
      for key, value in self.__dict__.iteritems()]
4524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4525 
 
4526 
  def __eq__(self, other):
4527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4528 
 
4529 
  def __ne__(self, other):
4530 
    return not (self == other)
4531 
 
4532 
class sendNewPasswordByHandle_args:
4533 
  """
4534 
  Attributes:
4535 
   - emailOrHandle
4536 
   - isEmail
4537 
  """
4538 
 
4539 
  thrift_spec = (
4540 
    None, # 0
4541 
    (1, TType.STRING, 'emailOrHandle', None, None, ), # 1
4542 
    (2, TType.BOOL, 'isEmail', None, None, ), # 2
4543 
  )
4544 
 
4545 
  def __init__(self, emailOrHandle=None, isEmail=None,):
4546 
    self.emailOrHandle = emailOrHandle
4547 
    self.isEmail = isEmail
4548 
 
4549 
  def read(self, iprot):
4550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4552 
      return
4553 
    iprot.readStructBegin()
4554 
    while True:
4555 
      (fname, ftype, fid) = iprot.readFieldBegin()
4556 
      if ftype == TType.STOP:
4557 
        break
4558 
      if fid == 1:
4559 
        if ftype == TType.STRING:
4560 
          self.emailOrHandle = iprot.readString();
4561 
        else:
4562 
          iprot.skip(ftype)
4563 
      elif fid == 2:
4564 
        if ftype == TType.BOOL:
4565 
          self.isEmail = iprot.readBool();
4566 
        else:
4567 
          iprot.skip(ftype)
4568 
      else:
4569 
        iprot.skip(ftype)
4570 
      iprot.readFieldEnd()
4571 
    iprot.readStructEnd()
4572 
 
4573 
  def write(self, oprot):
4574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4576 
      return
4577 
    oprot.writeStructBegin('sendNewPasswordByHandle_args')
4578 
    if self.emailOrHandle != None:
4579 
      oprot.writeFieldBegin('emailOrHandle', TType.STRING, 1)
4580 
      oprot.writeString(self.emailOrHandle)
4581 
      oprot.writeFieldEnd()
4582 
    if self.isEmail != None:
4583 
      oprot.writeFieldBegin('isEmail', TType.BOOL, 2)
4584 
      oprot.writeBool(self.isEmail)
4585 
      oprot.writeFieldEnd()
4586 
    oprot.writeFieldStop()
4587 
    oprot.writeStructEnd()
4588 
 
4589 
  def __repr__(self):
4590 
    L = ['%s=%r' % (key, value)
4591 
      for key, value in self.__dict__.iteritems()]
4592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4593 
 
4594 
  def __eq__(self, other):
4595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4596 
 
4597 
  def __ne__(self, other):
4598 
    return not (self == other)
4599 
 
4600 
class sendNewPasswordByHandle_result:
4601 
  """
4602 
  Attributes:
4603 
   - success
4604 
   - ucx
4605 
  """
4606 
 
4607 
  thrift_spec = (
4608 
    (0, TType.BOOL, 'success', None, None, ), # 0
4609 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4610 
  )
4611 
 
4612 
  def __init__(self, success=None, ucx=None,):
4613 
    self.success = success
4614 
    self.ucx = ucx
4615 
 
4616 
  def read(self, iprot):
4617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4619 
      return
4620 
    iprot.readStructBegin()
4621 
    while True:
4622 
      (fname, ftype, fid) = iprot.readFieldBegin()
4623 
      if ftype == TType.STOP:
4624 
        break
4625 
      if fid == 0:
4626 
        if ftype == TType.BOOL:
4627 
          self.success = iprot.readBool();
4628 
        else:
4629 
          iprot.skip(ftype)
4630 
      elif fid == 1:
4631 
        if ftype == TType.STRUCT:
4632 
          self.ucx = UserContextException()
4633 
          self.ucx.read(iprot)
4634 
        else:
4635 
          iprot.skip(ftype)
4636 
      else:
4637 
        iprot.skip(ftype)
4638 
      iprot.readFieldEnd()
4639 
    iprot.readStructEnd()
4640 
 
4641 
  def write(self, oprot):
4642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4644 
      return
4645 
    oprot.writeStructBegin('sendNewPasswordByHandle_result')
4646 
    if self.success != None:
4647 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4648 
      oprot.writeBool(self.success)
4649 
      oprot.writeFieldEnd()
4650 
    if self.ucx != None:
4651 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
4652 
      self.ucx.write(oprot)
4653 
      oprot.writeFieldEnd()
4654 
    oprot.writeFieldStop()
4655 
    oprot.writeStructEnd()
4656 
 
4657 
  def __repr__(self):
4658 
    L = ['%s=%r' % (key, value)
4659 
      for key, value in self.__dict__.iteritems()]
4660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4661 
 
4662 
  def __eq__(self, other):
4663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4664 
 
4665 
  def __ne__(self, other):
4666 
    return not (self == other)
4667 
 
4668