Subversion Repositories SmartDukaan

Rev

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