mirror of
https://github.com/hyper-neptune/yuuki.git
synced 2024-11-16 03:14:36 +08:00
6138 lines
210 KiB
Python
6138 lines
210 KiB
Python
#
|
|
# Autogenerated by Thrift Compiler (0.14.0)
|
|
#
|
|
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
|
|
#
|
|
# options string: py
|
|
#
|
|
|
|
from thrift.Thrift import TType, TMessageType, TFrozenDict, TException, TApplicationException
|
|
from thrift.protocol.TProtocol import TProtocolException
|
|
from thrift.TRecursive import fix_spec
|
|
|
|
import sys
|
|
import logging
|
|
from .ttypes import *
|
|
from thrift.Thrift import TProcessor
|
|
from thrift.transport import TTransport
|
|
all_structs = []
|
|
|
|
|
|
class Iface(object):
|
|
def activeBuddySubscriberCount(self):
|
|
pass
|
|
|
|
def addOperationForChannel(self, opType, param1, param2, param3):
|
|
"""
|
|
Parameters:
|
|
- opType
|
|
- param1
|
|
- param2
|
|
- param3
|
|
|
|
"""
|
|
pass
|
|
|
|
def displayBuddySubscriberCount(self):
|
|
pass
|
|
|
|
def findContactByUseridWithoutAbuseBlockForChannel(self, userid):
|
|
"""
|
|
Parameters:
|
|
- userid
|
|
|
|
"""
|
|
pass
|
|
|
|
def getAllContactIdsForChannel(self):
|
|
pass
|
|
|
|
def getCompactContacts(self, lastModifiedTimestamp):
|
|
"""
|
|
Parameters:
|
|
- lastModifiedTimestamp
|
|
|
|
"""
|
|
pass
|
|
|
|
def getContactsForChannel(self, ids):
|
|
"""
|
|
Parameters:
|
|
- ids
|
|
|
|
"""
|
|
pass
|
|
|
|
def getDisplayName(self, mid):
|
|
"""
|
|
Parameters:
|
|
- mid
|
|
|
|
"""
|
|
pass
|
|
|
|
def getFavoriteMidsForChannel(self):
|
|
pass
|
|
|
|
def getFriendMids(self):
|
|
pass
|
|
|
|
def getGroupMemberMids(self, groupId):
|
|
"""
|
|
Parameters:
|
|
- groupId
|
|
|
|
"""
|
|
pass
|
|
|
|
def getGroupsForChannel(self, groupIds):
|
|
"""
|
|
Parameters:
|
|
- groupIds
|
|
|
|
"""
|
|
pass
|
|
|
|
def getIdentityCredential(self):
|
|
pass
|
|
|
|
def getJoinedGroupIdsForChannel(self):
|
|
pass
|
|
|
|
def getMetaProfile(self):
|
|
pass
|
|
|
|
def getMid(self):
|
|
pass
|
|
|
|
def getPrimaryClientForChannel(self):
|
|
pass
|
|
|
|
def getProfileForChannel(self):
|
|
pass
|
|
|
|
def getSimpleChannelContacts(self, ids):
|
|
"""
|
|
Parameters:
|
|
- ids
|
|
|
|
"""
|
|
pass
|
|
|
|
def getUserCountryForBilling(self, country, remoteIp):
|
|
"""
|
|
Parameters:
|
|
- country
|
|
- remoteIp
|
|
|
|
"""
|
|
pass
|
|
|
|
def getUserCreateTime(self):
|
|
pass
|
|
|
|
def getUserIdentities(self):
|
|
pass
|
|
|
|
def getUserLanguage(self):
|
|
pass
|
|
|
|
def getUserMidsWhoAddedMe(self):
|
|
pass
|
|
|
|
def isGroupMember(self, groupId):
|
|
"""
|
|
Parameters:
|
|
- groupId
|
|
|
|
"""
|
|
pass
|
|
|
|
def isInContact(self, mid):
|
|
"""
|
|
Parameters:
|
|
- mid
|
|
|
|
"""
|
|
pass
|
|
|
|
def registerChannelCP(self, cpId, registerPassword):
|
|
"""
|
|
Parameters:
|
|
- cpId
|
|
- registerPassword
|
|
|
|
"""
|
|
pass
|
|
|
|
def removeNotificationStatus(self, notificationStatus):
|
|
"""
|
|
Parameters:
|
|
- notificationStatus
|
|
|
|
"""
|
|
pass
|
|
|
|
def sendMessageForChannel(self, message):
|
|
"""
|
|
Parameters:
|
|
- message
|
|
|
|
"""
|
|
pass
|
|
|
|
def sendPinCodeOperation(self, verifier):
|
|
"""
|
|
Parameters:
|
|
- verifier
|
|
|
|
"""
|
|
pass
|
|
|
|
def updateProfileAttributeForChannel(self, profileAttribute, value):
|
|
"""
|
|
Parameters:
|
|
- profileAttribute
|
|
- value
|
|
|
|
"""
|
|
pass
|
|
|
|
|
|
class Client(Iface):
|
|
def __init__(self, iprot, oprot=None):
|
|
self._iprot = self._oprot = iprot
|
|
if oprot is not None:
|
|
self._oprot = oprot
|
|
self._seqid = 0
|
|
|
|
def activeBuddySubscriberCount(self):
|
|
self.send_activeBuddySubscriberCount()
|
|
return self.recv_activeBuddySubscriberCount()
|
|
|
|
def send_activeBuddySubscriberCount(self):
|
|
self._oprot.writeMessageBegin('activeBuddySubscriberCount', TMessageType.CALL, self._seqid)
|
|
args = activeBuddySubscriberCount_args()
|
|
args.write(self._oprot)
|
|
self._oprot.writeMessageEnd()
|
|
self._oprot.trans.flush()
|
|
|
|
def recv_activeBuddySubscriberCount(self):
|
|
iprot = self._iprot
|
|
(fname, mtype, rseqid) = iprot.readMessageBegin()
|
|
if mtype == TMessageType.EXCEPTION:
|
|
x = TApplicationException()
|
|
x.read(iprot)
|
|
iprot.readMessageEnd()
|
|
raise x
|
|
result = activeBuddySubscriberCount_result()
|
|
result.read(iprot)
|
|
iprot.readMessageEnd()
|
|
if result.success is not None:
|
|
return result.success
|
|
if result.e is not None:
|
|
raise result.e
|
|
raise TApplicationException(TApplicationException.MISSING_RESULT, "activeBuddySubscriberCount failed: unknown result")
|
|
|
|
def addOperationForChannel(self, opType, param1, param2, param3):
|
|
"""
|
|
Parameters:
|
|
- opType
|
|
- param1
|
|
- param2
|
|
- param3
|
|
|
|
"""
|
|
self.send_addOperationForChannel(opType, param1, param2, param3)
|
|
self.recv_addOperationForChannel()
|
|
|
|
def send_addOperationForChannel(self, opType, param1, param2, param3):
|
|
self._oprot.writeMessageBegin('addOperationForChannel', TMessageType.CALL, self._seqid)
|
|
args = addOperationForChannel_args()
|
|
args.opType = opType
|
|
args.param1 = param1
|
|
args.param2 = param2
|
|
args.param3 = param3
|
|
args.write(self._oprot)
|
|
self._oprot.writeMessageEnd()
|
|
self._oprot.trans.flush()
|
|
|
|
def recv_addOperationForChannel(self):
|
|
iprot = self._iprot
|
|
(fname, mtype, rseqid) = iprot.readMessageBegin()
|
|
if mtype == TMessageType.EXCEPTION:
|
|
x = TApplicationException()
|
|
x.read(iprot)
|
|
iprot.readMessageEnd()
|
|
raise x
|
|
result = addOperationForChannel_result()
|
|
result.read(iprot)
|
|
iprot.readMessageEnd()
|
|
if result.e is not None:
|
|
raise result.e
|
|
return
|
|
|
|
def displayBuddySubscriberCount(self):
|
|
self.send_displayBuddySubscriberCount()
|
|
return self.recv_displayBuddySubscriberCount()
|
|
|
|
def send_displayBuddySubscriberCount(self):
|
|
self._oprot.writeMessageBegin('displayBuddySubscriberCount', TMessageType.CALL, self._seqid)
|
|
args = displayBuddySubscriberCount_args()
|
|
args.write(self._oprot)
|
|
self._oprot.writeMessageEnd()
|
|
self._oprot.trans.flush()
|
|
|
|
def recv_displayBuddySubscriberCount(self):
|
|
iprot = self._iprot
|
|
(fname, mtype, rseqid) = iprot.readMessageBegin()
|
|
if mtype == TMessageType.EXCEPTION:
|
|
x = TApplicationException()
|
|
x.read(iprot)
|
|
iprot.readMessageEnd()
|
|
raise x
|
|
result = displayBuddySubscriberCount_result()
|
|
result.read(iprot)
|
|
iprot.readMessageEnd()
|
|
if result.success is not None:
|
|
return result.success
|
|
if result.e is not None:
|
|
raise result.e
|
|
raise TApplicationException(TApplicationException.MISSING_RESULT, "displayBuddySubscriberCount failed: unknown result")
|
|
|
|
def findContactByUseridWithoutAbuseBlockForChannel(self, userid):
|
|
"""
|
|
Parameters:
|
|
- userid
|
|
|
|
"""
|
|
self.send_findContactByUseridWithoutAbuseBlockForChannel(userid)
|
|
return self.recv_findContactByUseridWithoutAbuseBlockForChannel()
|
|
|
|
def send_findContactByUseridWithoutAbuseBlockForChannel(self, userid):
|
|
self._oprot.writeMessageBegin('findContactByUseridWithoutAbuseBlockForChannel', TMessageType.CALL, self._seqid)
|
|
args = findContactByUseridWithoutAbuseBlockForChannel_args()
|
|
args.userid = userid
|
|
args.write(self._oprot)
|
|
self._oprot.writeMessageEnd()
|
|
self._oprot.trans.flush()
|
|
|
|
def recv_findContactByUseridWithoutAbuseBlockForChannel(self):
|
|
iprot = self._iprot
|
|
(fname, mtype, rseqid) = iprot.readMessageBegin()
|
|
if mtype == TMessageType.EXCEPTION:
|
|
x = TApplicationException()
|
|
x.read(iprot)
|
|
iprot.readMessageEnd()
|
|
raise x
|
|
result = findContactByUseridWithoutAbuseBlockForChannel_result()
|
|
result.read(iprot)
|
|
iprot.readMessageEnd()
|
|
if result.success is not None:
|
|
return result.success
|
|
if result.e is not None:
|
|
raise result.e
|
|
raise TApplicationException(TApplicationException.MISSING_RESULT, "findContactByUseridWithoutAbuseBlockForChannel failed: unknown result")
|
|
|
|
def getAllContactIdsForChannel(self):
|
|
self.send_getAllContactIdsForChannel()
|
|
return self.recv_getAllContactIdsForChannel()
|
|
|
|
def send_getAllContactIdsForChannel(self):
|
|
self._oprot.writeMessageBegin('getAllContactIdsForChannel', TMessageType.CALL, self._seqid)
|
|
args = getAllContactIdsForChannel_args()
|
|
args.write(self._oprot)
|
|
self._oprot.writeMessageEnd()
|
|
self._oprot.trans.flush()
|
|
|
|
def recv_getAllContactIdsForChannel(self):
|
|
iprot = self._iprot
|
|
(fname, mtype, rseqid) = iprot.readMessageBegin()
|
|
if mtype == TMessageType.EXCEPTION:
|
|
x = TApplicationException()
|
|
x.read(iprot)
|
|
iprot.readMessageEnd()
|
|
raise x
|
|
result = getAllContactIdsForChannel_result()
|
|
result.read(iprot)
|
|
iprot.readMessageEnd()
|
|
if result.success is not None:
|
|
return result.success
|
|
if result.e is not None:
|
|
raise result.e
|
|
raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllContactIdsForChannel failed: unknown result")
|
|
|
|
def getCompactContacts(self, lastModifiedTimestamp):
|
|
"""
|
|
Parameters:
|
|
- lastModifiedTimestamp
|
|
|
|
"""
|
|
self.send_getCompactContacts(lastModifiedTimestamp)
|
|
return self.recv_getCompactContacts()
|
|
|
|
def send_getCompactContacts(self, lastModifiedTimestamp):
|
|
self._oprot.writeMessageBegin('getCompactContacts', TMessageType.CALL, self._seqid)
|
|
args = getCompactContacts_args()
|
|
args.lastModifiedTimestamp = lastModifiedTimestamp
|
|
args.write(self._oprot)
|
|
self._oprot.writeMessageEnd()
|
|
self._oprot.trans.flush()
|
|
|
|
def recv_getCompactContacts(self):
|
|
iprot = self._iprot
|
|
(fname, mtype, rseqid) = iprot.readMessageBegin()
|
|
if mtype == TMessageType.EXCEPTION:
|
|
x = TApplicationException()
|
|
x.read(iprot)
|
|
iprot.readMessageEnd()
|
|
raise x
|
|
result = getCompactContacts_result()
|
|
result.read(iprot)
|
|
iprot.readMessageEnd()
|
|
if result.success is not None:
|
|
return result.success
|
|
if result.e is not None:
|
|
raise result.e
|
|
raise TApplicationException(TApplicationException.MISSING_RESULT, "getCompactContacts failed: unknown result")
|
|
|
|
def getContactsForChannel(self, ids):
|
|
"""
|
|
Parameters:
|
|
- ids
|
|
|
|
"""
|
|
self.send_getContactsForChannel(ids)
|
|
return self.recv_getContactsForChannel()
|
|
|
|
def send_getContactsForChannel(self, ids):
|
|
self._oprot.writeMessageBegin('getContactsForChannel', TMessageType.CALL, self._seqid)
|
|
args = getContactsForChannel_args()
|
|
args.ids = ids
|
|
args.write(self._oprot)
|
|
self._oprot.writeMessageEnd()
|
|
self._oprot.trans.flush()
|
|
|
|
def recv_getContactsForChannel(self):
|
|
iprot = self._iprot
|
|
(fname, mtype, rseqid) = iprot.readMessageBegin()
|
|
if mtype == TMessageType.EXCEPTION:
|
|
x = TApplicationException()
|
|
x.read(iprot)
|
|
iprot.readMessageEnd()
|
|
raise x
|
|
result = getContactsForChannel_result()
|
|
result.read(iprot)
|
|
iprot.readMessageEnd()
|
|
if result.success is not None:
|
|
return result.success
|
|
if result.e is not None:
|
|
raise result.e
|
|
raise TApplicationException(TApplicationException.MISSING_RESULT, "getContactsForChannel failed: unknown result")
|
|
|
|
def getDisplayName(self, mid):
|
|
"""
|
|
Parameters:
|
|
- mid
|
|
|
|
"""
|
|
self.send_getDisplayName(mid)
|
|
return self.recv_getDisplayName()
|
|
|
|
def send_getDisplayName(self, mid):
|
|
self._oprot.writeMessageBegin('getDisplayName', TMessageType.CALL, self._seqid)
|
|
args = getDisplayName_args()
|
|
args.mid = mid
|
|
args.write(self._oprot)
|
|
self._oprot.writeMessageEnd()
|
|
self._oprot.trans.flush()
|
|
|
|
def recv_getDisplayName(self):
|
|
iprot = self._iprot
|
|
(fname, mtype, rseqid) = iprot.readMessageBegin()
|
|
if mtype == TMessageType.EXCEPTION:
|
|
x = TApplicationException()
|
|
x.read(iprot)
|
|
iprot.readMessageEnd()
|
|
raise x
|
|
result = getDisplayName_result()
|
|
result.read(iprot)
|
|
iprot.readMessageEnd()
|
|
if result.success is not None:
|
|
return result.success
|
|
if result.e is not None:
|
|
raise result.e
|
|
raise TApplicationException(TApplicationException.MISSING_RESULT, "getDisplayName failed: unknown result")
|
|
|
|
def getFavoriteMidsForChannel(self):
|
|
self.send_getFavoriteMidsForChannel()
|
|
return self.recv_getFavoriteMidsForChannel()
|
|
|
|
def send_getFavoriteMidsForChannel(self):
|
|
self._oprot.writeMessageBegin('getFavoriteMidsForChannel', TMessageType.CALL, self._seqid)
|
|
args = getFavoriteMidsForChannel_args()
|
|
args.write(self._oprot)
|
|
self._oprot.writeMessageEnd()
|
|
self._oprot.trans.flush()
|
|
|
|
def recv_getFavoriteMidsForChannel(self):
|
|
iprot = self._iprot
|
|
(fname, mtype, rseqid) = iprot.readMessageBegin()
|
|
if mtype == TMessageType.EXCEPTION:
|
|
x = TApplicationException()
|
|
x.read(iprot)
|
|
iprot.readMessageEnd()
|
|
raise x
|
|
result = getFavoriteMidsForChannel_result()
|
|
result.read(iprot)
|
|
iprot.readMessageEnd()
|
|
if result.success is not None:
|
|
return result.success
|
|
if result.e is not None:
|
|
raise result.e
|
|
raise TApplicationException(TApplicationException.MISSING_RESULT, "getFavoriteMidsForChannel failed: unknown result")
|
|
|
|
def getFriendMids(self):
|
|
self.send_getFriendMids()
|
|
return self.recv_getFriendMids()
|
|
|
|
def send_getFriendMids(self):
|
|
self._oprot.writeMessageBegin('getFriendMids', TMessageType.CALL, self._seqid)
|
|
args = getFriendMids_args()
|
|
args.write(self._oprot)
|
|
self._oprot.writeMessageEnd()
|
|
self._oprot.trans.flush()
|
|
|
|
def recv_getFriendMids(self):
|
|
iprot = self._iprot
|
|
(fname, mtype, rseqid) = iprot.readMessageBegin()
|
|
if mtype == TMessageType.EXCEPTION:
|
|
x = TApplicationException()
|
|
x.read(iprot)
|
|
iprot.readMessageEnd()
|
|
raise x
|
|
result = getFriendMids_result()
|
|
result.read(iprot)
|
|
iprot.readMessageEnd()
|
|
if result.success is not None:
|
|
return result.success
|
|
if result.e is not None:
|
|
raise result.e
|
|
raise TApplicationException(TApplicationException.MISSING_RESULT, "getFriendMids failed: unknown result")
|
|
|
|
def getGroupMemberMids(self, groupId):
|
|
"""
|
|
Parameters:
|
|
- groupId
|
|
|
|
"""
|
|
self.send_getGroupMemberMids(groupId)
|
|
return self.recv_getGroupMemberMids()
|
|
|
|
def send_getGroupMemberMids(self, groupId):
|
|
self._oprot.writeMessageBegin('getGroupMemberMids', TMessageType.CALL, self._seqid)
|
|
args = getGroupMemberMids_args()
|
|
args.groupId = groupId
|
|
args.write(self._oprot)
|
|
self._oprot.writeMessageEnd()
|
|
self._oprot.trans.flush()
|
|
|
|
def recv_getGroupMemberMids(self):
|
|
iprot = self._iprot
|
|
(fname, mtype, rseqid) = iprot.readMessageBegin()
|
|
if mtype == TMessageType.EXCEPTION:
|
|
x = TApplicationException()
|
|
x.read(iprot)
|
|
iprot.readMessageEnd()
|
|
raise x
|
|
result = getGroupMemberMids_result()
|
|
result.read(iprot)
|
|
iprot.readMessageEnd()
|
|
if result.success is not None:
|
|
return result.success
|
|
if result.e is not None:
|
|
raise result.e
|
|
raise TApplicationException(TApplicationException.MISSING_RESULT, "getGroupMemberMids failed: unknown result")
|
|
|
|
def getGroupsForChannel(self, groupIds):
|
|
"""
|
|
Parameters:
|
|
- groupIds
|
|
|
|
"""
|
|
self.send_getGroupsForChannel(groupIds)
|
|
return self.recv_getGroupsForChannel()
|
|
|
|
def send_getGroupsForChannel(self, groupIds):
|
|
self._oprot.writeMessageBegin('getGroupsForChannel', TMessageType.CALL, self._seqid)
|
|
args = getGroupsForChannel_args()
|
|
args.groupIds = groupIds
|
|
args.write(self._oprot)
|
|
self._oprot.writeMessageEnd()
|
|
self._oprot.trans.flush()
|
|
|
|
def recv_getGroupsForChannel(self):
|
|
iprot = self._iprot
|
|
(fname, mtype, rseqid) = iprot.readMessageBegin()
|
|
if mtype == TMessageType.EXCEPTION:
|
|
x = TApplicationException()
|
|
x.read(iprot)
|
|
iprot.readMessageEnd()
|
|
raise x
|
|
result = getGroupsForChannel_result()
|
|
result.read(iprot)
|
|
iprot.readMessageEnd()
|
|
if result.success is not None:
|
|
return result.success
|
|
if result.e is not None:
|
|
raise result.e
|
|
raise TApplicationException(TApplicationException.MISSING_RESULT, "getGroupsForChannel failed: unknown result")
|
|
|
|
def getIdentityCredential(self):
|
|
self.send_getIdentityCredential()
|
|
return self.recv_getIdentityCredential()
|
|
|
|
def send_getIdentityCredential(self):
|
|
self._oprot.writeMessageBegin('getIdentityCredential', TMessageType.CALL, self._seqid)
|
|
args = getIdentityCredential_args()
|
|
args.write(self._oprot)
|
|
self._oprot.writeMessageEnd()
|
|
self._oprot.trans.flush()
|
|
|
|
def recv_getIdentityCredential(self):
|
|
iprot = self._iprot
|
|
(fname, mtype, rseqid) = iprot.readMessageBegin()
|
|
if mtype == TMessageType.EXCEPTION:
|
|
x = TApplicationException()
|
|
x.read(iprot)
|
|
iprot.readMessageEnd()
|
|
raise x
|
|
result = getIdentityCredential_result()
|
|
result.read(iprot)
|
|
iprot.readMessageEnd()
|
|
if result.success is not None:
|
|
return result.success
|
|
if result.e is not None:
|
|
raise result.e
|
|
raise TApplicationException(TApplicationException.MISSING_RESULT, "getIdentityCredential failed: unknown result")
|
|
|
|
def getJoinedGroupIdsForChannel(self):
|
|
self.send_getJoinedGroupIdsForChannel()
|
|
return self.recv_getJoinedGroupIdsForChannel()
|
|
|
|
def send_getJoinedGroupIdsForChannel(self):
|
|
self._oprot.writeMessageBegin('getJoinedGroupIdsForChannel', TMessageType.CALL, self._seqid)
|
|
args = getJoinedGroupIdsForChannel_args()
|
|
args.write(self._oprot)
|
|
self._oprot.writeMessageEnd()
|
|
self._oprot.trans.flush()
|
|
|
|
def recv_getJoinedGroupIdsForChannel(self):
|
|
iprot = self._iprot
|
|
(fname, mtype, rseqid) = iprot.readMessageBegin()
|
|
if mtype == TMessageType.EXCEPTION:
|
|
x = TApplicationException()
|
|
x.read(iprot)
|
|
iprot.readMessageEnd()
|
|
raise x
|
|
result = getJoinedGroupIdsForChannel_result()
|
|
result.read(iprot)
|
|
iprot.readMessageEnd()
|
|
if result.success is not None:
|
|
return result.success
|
|
if result.e is not None:
|
|
raise result.e
|
|
raise TApplicationException(TApplicationException.MISSING_RESULT, "getJoinedGroupIdsForChannel failed: unknown result")
|
|
|
|
def getMetaProfile(self):
|
|
self.send_getMetaProfile()
|
|
return self.recv_getMetaProfile()
|
|
|
|
def send_getMetaProfile(self):
|
|
self._oprot.writeMessageBegin('getMetaProfile', TMessageType.CALL, self._seqid)
|
|
args = getMetaProfile_args()
|
|
args.write(self._oprot)
|
|
self._oprot.writeMessageEnd()
|
|
self._oprot.trans.flush()
|
|
|
|
def recv_getMetaProfile(self):
|
|
iprot = self._iprot
|
|
(fname, mtype, rseqid) = iprot.readMessageBegin()
|
|
if mtype == TMessageType.EXCEPTION:
|
|
x = TApplicationException()
|
|
x.read(iprot)
|
|
iprot.readMessageEnd()
|
|
raise x
|
|
result = getMetaProfile_result()
|
|
result.read(iprot)
|
|
iprot.readMessageEnd()
|
|
if result.success is not None:
|
|
return result.success
|
|
if result.e is not None:
|
|
raise result.e
|
|
raise TApplicationException(TApplicationException.MISSING_RESULT, "getMetaProfile failed: unknown result")
|
|
|
|
def getMid(self):
|
|
self.send_getMid()
|
|
return self.recv_getMid()
|
|
|
|
def send_getMid(self):
|
|
self._oprot.writeMessageBegin('getMid', TMessageType.CALL, self._seqid)
|
|
args = getMid_args()
|
|
args.write(self._oprot)
|
|
self._oprot.writeMessageEnd()
|
|
self._oprot.trans.flush()
|
|
|
|
def recv_getMid(self):
|
|
iprot = self._iprot
|
|
(fname, mtype, rseqid) = iprot.readMessageBegin()
|
|
if mtype == TMessageType.EXCEPTION:
|
|
x = TApplicationException()
|
|
x.read(iprot)
|
|
iprot.readMessageEnd()
|
|
raise x
|
|
result = getMid_result()
|
|
result.read(iprot)
|
|
iprot.readMessageEnd()
|
|
if result.success is not None:
|
|
return result.success
|
|
if result.e is not None:
|
|
raise result.e
|
|
raise TApplicationException(TApplicationException.MISSING_RESULT, "getMid failed: unknown result")
|
|
|
|
def getPrimaryClientForChannel(self):
|
|
self.send_getPrimaryClientForChannel()
|
|
return self.recv_getPrimaryClientForChannel()
|
|
|
|
def send_getPrimaryClientForChannel(self):
|
|
self._oprot.writeMessageBegin('getPrimaryClientForChannel', TMessageType.CALL, self._seqid)
|
|
args = getPrimaryClientForChannel_args()
|
|
args.write(self._oprot)
|
|
self._oprot.writeMessageEnd()
|
|
self._oprot.trans.flush()
|
|
|
|
def recv_getPrimaryClientForChannel(self):
|
|
iprot = self._iprot
|
|
(fname, mtype, rseqid) = iprot.readMessageBegin()
|
|
if mtype == TMessageType.EXCEPTION:
|
|
x = TApplicationException()
|
|
x.read(iprot)
|
|
iprot.readMessageEnd()
|
|
raise x
|
|
result = getPrimaryClientForChannel_result()
|
|
result.read(iprot)
|
|
iprot.readMessageEnd()
|
|
if result.success is not None:
|
|
return result.success
|
|
if result.e is not None:
|
|
raise result.e
|
|
raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrimaryClientForChannel failed: unknown result")
|
|
|
|
def getProfileForChannel(self):
|
|
self.send_getProfileForChannel()
|
|
return self.recv_getProfileForChannel()
|
|
|
|
def send_getProfileForChannel(self):
|
|
self._oprot.writeMessageBegin('getProfileForChannel', TMessageType.CALL, self._seqid)
|
|
args = getProfileForChannel_args()
|
|
args.write(self._oprot)
|
|
self._oprot.writeMessageEnd()
|
|
self._oprot.trans.flush()
|
|
|
|
def recv_getProfileForChannel(self):
|
|
iprot = self._iprot
|
|
(fname, mtype, rseqid) = iprot.readMessageBegin()
|
|
if mtype == TMessageType.EXCEPTION:
|
|
x = TApplicationException()
|
|
x.read(iprot)
|
|
iprot.readMessageEnd()
|
|
raise x
|
|
result = getProfileForChannel_result()
|
|
result.read(iprot)
|
|
iprot.readMessageEnd()
|
|
if result.success is not None:
|
|
return result.success
|
|
if result.e is not None:
|
|
raise result.e
|
|
raise TApplicationException(TApplicationException.MISSING_RESULT, "getProfileForChannel failed: unknown result")
|
|
|
|
def getSimpleChannelContacts(self, ids):
|
|
"""
|
|
Parameters:
|
|
- ids
|
|
|
|
"""
|
|
self.send_getSimpleChannelContacts(ids)
|
|
return self.recv_getSimpleChannelContacts()
|
|
|
|
def send_getSimpleChannelContacts(self, ids):
|
|
self._oprot.writeMessageBegin('getSimpleChannelContacts', TMessageType.CALL, self._seqid)
|
|
args = getSimpleChannelContacts_args()
|
|
args.ids = ids
|
|
args.write(self._oprot)
|
|
self._oprot.writeMessageEnd()
|
|
self._oprot.trans.flush()
|
|
|
|
def recv_getSimpleChannelContacts(self):
|
|
iprot = self._iprot
|
|
(fname, mtype, rseqid) = iprot.readMessageBegin()
|
|
if mtype == TMessageType.EXCEPTION:
|
|
x = TApplicationException()
|
|
x.read(iprot)
|
|
iprot.readMessageEnd()
|
|
raise x
|
|
result = getSimpleChannelContacts_result()
|
|
result.read(iprot)
|
|
iprot.readMessageEnd()
|
|
if result.success is not None:
|
|
return result.success
|
|
if result.e is not None:
|
|
raise result.e
|
|
raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimpleChannelContacts failed: unknown result")
|
|
|
|
def getUserCountryForBilling(self, country, remoteIp):
|
|
"""
|
|
Parameters:
|
|
- country
|
|
- remoteIp
|
|
|
|
"""
|
|
self.send_getUserCountryForBilling(country, remoteIp)
|
|
return self.recv_getUserCountryForBilling()
|
|
|
|
def send_getUserCountryForBilling(self, country, remoteIp):
|
|
self._oprot.writeMessageBegin('getUserCountryForBilling', TMessageType.CALL, self._seqid)
|
|
args = getUserCountryForBilling_args()
|
|
args.country = country
|
|
args.remoteIp = remoteIp
|
|
args.write(self._oprot)
|
|
self._oprot.writeMessageEnd()
|
|
self._oprot.trans.flush()
|
|
|
|
def recv_getUserCountryForBilling(self):
|
|
iprot = self._iprot
|
|
(fname, mtype, rseqid) = iprot.readMessageBegin()
|
|
if mtype == TMessageType.EXCEPTION:
|
|
x = TApplicationException()
|
|
x.read(iprot)
|
|
iprot.readMessageEnd()
|
|
raise x
|
|
result = getUserCountryForBilling_result()
|
|
result.read(iprot)
|
|
iprot.readMessageEnd()
|
|
if result.success is not None:
|
|
return result.success
|
|
if result.e is not None:
|
|
raise result.e
|
|
raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCountryForBilling failed: unknown result")
|
|
|
|
def getUserCreateTime(self):
|
|
self.send_getUserCreateTime()
|
|
return self.recv_getUserCreateTime()
|
|
|
|
def send_getUserCreateTime(self):
|
|
self._oprot.writeMessageBegin('getUserCreateTime', TMessageType.CALL, self._seqid)
|
|
args = getUserCreateTime_args()
|
|
args.write(self._oprot)
|
|
self._oprot.writeMessageEnd()
|
|
self._oprot.trans.flush()
|
|
|
|
def recv_getUserCreateTime(self):
|
|
iprot = self._iprot
|
|
(fname, mtype, rseqid) = iprot.readMessageBegin()
|
|
if mtype == TMessageType.EXCEPTION:
|
|
x = TApplicationException()
|
|
x.read(iprot)
|
|
iprot.readMessageEnd()
|
|
raise x
|
|
result = getUserCreateTime_result()
|
|
result.read(iprot)
|
|
iprot.readMessageEnd()
|
|
if result.success is not None:
|
|
return result.success
|
|
if result.e is not None:
|
|
raise result.e
|
|
raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCreateTime failed: unknown result")
|
|
|
|
def getUserIdentities(self):
|
|
self.send_getUserIdentities()
|
|
return self.recv_getUserIdentities()
|
|
|
|
def send_getUserIdentities(self):
|
|
self._oprot.writeMessageBegin('getUserIdentities', TMessageType.CALL, self._seqid)
|
|
args = getUserIdentities_args()
|
|
args.write(self._oprot)
|
|
self._oprot.writeMessageEnd()
|
|
self._oprot.trans.flush()
|
|
|
|
def recv_getUserIdentities(self):
|
|
iprot = self._iprot
|
|
(fname, mtype, rseqid) = iprot.readMessageBegin()
|
|
if mtype == TMessageType.EXCEPTION:
|
|
x = TApplicationException()
|
|
x.read(iprot)
|
|
iprot.readMessageEnd()
|
|
raise x
|
|
result = getUserIdentities_result()
|
|
result.read(iprot)
|
|
iprot.readMessageEnd()
|
|
if result.success is not None:
|
|
return result.success
|
|
if result.e is not None:
|
|
raise result.e
|
|
raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserIdentities failed: unknown result")
|
|
|
|
def getUserLanguage(self):
|
|
self.send_getUserLanguage()
|
|
return self.recv_getUserLanguage()
|
|
|
|
def send_getUserLanguage(self):
|
|
self._oprot.writeMessageBegin('getUserLanguage', TMessageType.CALL, self._seqid)
|
|
args = getUserLanguage_args()
|
|
args.write(self._oprot)
|
|
self._oprot.writeMessageEnd()
|
|
self._oprot.trans.flush()
|
|
|
|
def recv_getUserLanguage(self):
|
|
iprot = self._iprot
|
|
(fname, mtype, rseqid) = iprot.readMessageBegin()
|
|
if mtype == TMessageType.EXCEPTION:
|
|
x = TApplicationException()
|
|
x.read(iprot)
|
|
iprot.readMessageEnd()
|
|
raise x
|
|
result = getUserLanguage_result()
|
|
result.read(iprot)
|
|
iprot.readMessageEnd()
|
|
if result.success is not None:
|
|
return result.success
|
|
if result.e is not None:
|
|
raise result.e
|
|
raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserLanguage failed: unknown result")
|
|
|
|
def getUserMidsWhoAddedMe(self):
|
|
self.send_getUserMidsWhoAddedMe()
|
|
return self.recv_getUserMidsWhoAddedMe()
|
|
|
|
def send_getUserMidsWhoAddedMe(self):
|
|
self._oprot.writeMessageBegin('getUserMidsWhoAddedMe', TMessageType.CALL, self._seqid)
|
|
args = getUserMidsWhoAddedMe_args()
|
|
args.write(self._oprot)
|
|
self._oprot.writeMessageEnd()
|
|
self._oprot.trans.flush()
|
|
|
|
def recv_getUserMidsWhoAddedMe(self):
|
|
iprot = self._iprot
|
|
(fname, mtype, rseqid) = iprot.readMessageBegin()
|
|
if mtype == TMessageType.EXCEPTION:
|
|
x = TApplicationException()
|
|
x.read(iprot)
|
|
iprot.readMessageEnd()
|
|
raise x
|
|
result = getUserMidsWhoAddedMe_result()
|
|
result.read(iprot)
|
|
iprot.readMessageEnd()
|
|
if result.success is not None:
|
|
return result.success
|
|
if result.e is not None:
|
|
raise result.e
|
|
raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserMidsWhoAddedMe failed: unknown result")
|
|
|
|
def isGroupMember(self, groupId):
|
|
"""
|
|
Parameters:
|
|
- groupId
|
|
|
|
"""
|
|
self.send_isGroupMember(groupId)
|
|
return self.recv_isGroupMember()
|
|
|
|
def send_isGroupMember(self, groupId):
|
|
self._oprot.writeMessageBegin('isGroupMember', TMessageType.CALL, self._seqid)
|
|
args = isGroupMember_args()
|
|
args.groupId = groupId
|
|
args.write(self._oprot)
|
|
self._oprot.writeMessageEnd()
|
|
self._oprot.trans.flush()
|
|
|
|
def recv_isGroupMember(self):
|
|
iprot = self._iprot
|
|
(fname, mtype, rseqid) = iprot.readMessageBegin()
|
|
if mtype == TMessageType.EXCEPTION:
|
|
x = TApplicationException()
|
|
x.read(iprot)
|
|
iprot.readMessageEnd()
|
|
raise x
|
|
result = isGroupMember_result()
|
|
result.read(iprot)
|
|
iprot.readMessageEnd()
|
|
if result.success is not None:
|
|
return result.success
|
|
if result.e is not None:
|
|
raise result.e
|
|
raise TApplicationException(TApplicationException.MISSING_RESULT, "isGroupMember failed: unknown result")
|
|
|
|
def isInContact(self, mid):
|
|
"""
|
|
Parameters:
|
|
- mid
|
|
|
|
"""
|
|
self.send_isInContact(mid)
|
|
return self.recv_isInContact()
|
|
|
|
def send_isInContact(self, mid):
|
|
self._oprot.writeMessageBegin('isInContact', TMessageType.CALL, self._seqid)
|
|
args = isInContact_args()
|
|
args.mid = mid
|
|
args.write(self._oprot)
|
|
self._oprot.writeMessageEnd()
|
|
self._oprot.trans.flush()
|
|
|
|
def recv_isInContact(self):
|
|
iprot = self._iprot
|
|
(fname, mtype, rseqid) = iprot.readMessageBegin()
|
|
if mtype == TMessageType.EXCEPTION:
|
|
x = TApplicationException()
|
|
x.read(iprot)
|
|
iprot.readMessageEnd()
|
|
raise x
|
|
result = isInContact_result()
|
|
result.read(iprot)
|
|
iprot.readMessageEnd()
|
|
if result.success is not None:
|
|
return result.success
|
|
if result.e is not None:
|
|
raise result.e
|
|
raise TApplicationException(TApplicationException.MISSING_RESULT, "isInContact failed: unknown result")
|
|
|
|
def registerChannelCP(self, cpId, registerPassword):
|
|
"""
|
|
Parameters:
|
|
- cpId
|
|
- registerPassword
|
|
|
|
"""
|
|
self.send_registerChannelCP(cpId, registerPassword)
|
|
return self.recv_registerChannelCP()
|
|
|
|
def send_registerChannelCP(self, cpId, registerPassword):
|
|
self._oprot.writeMessageBegin('registerChannelCP', TMessageType.CALL, self._seqid)
|
|
args = registerChannelCP_args()
|
|
args.cpId = cpId
|
|
args.registerPassword = registerPassword
|
|
args.write(self._oprot)
|
|
self._oprot.writeMessageEnd()
|
|
self._oprot.trans.flush()
|
|
|
|
def recv_registerChannelCP(self):
|
|
iprot = self._iprot
|
|
(fname, mtype, rseqid) = iprot.readMessageBegin()
|
|
if mtype == TMessageType.EXCEPTION:
|
|
x = TApplicationException()
|
|
x.read(iprot)
|
|
iprot.readMessageEnd()
|
|
raise x
|
|
result = registerChannelCP_result()
|
|
result.read(iprot)
|
|
iprot.readMessageEnd()
|
|
if result.success is not None:
|
|
return result.success
|
|
if result.e is not None:
|
|
raise result.e
|
|
raise TApplicationException(TApplicationException.MISSING_RESULT, "registerChannelCP failed: unknown result")
|
|
|
|
def removeNotificationStatus(self, notificationStatus):
|
|
"""
|
|
Parameters:
|
|
- notificationStatus
|
|
|
|
"""
|
|
self.send_removeNotificationStatus(notificationStatus)
|
|
self.recv_removeNotificationStatus()
|
|
|
|
def send_removeNotificationStatus(self, notificationStatus):
|
|
self._oprot.writeMessageBegin('removeNotificationStatus', TMessageType.CALL, self._seqid)
|
|
args = removeNotificationStatus_args()
|
|
args.notificationStatus = notificationStatus
|
|
args.write(self._oprot)
|
|
self._oprot.writeMessageEnd()
|
|
self._oprot.trans.flush()
|
|
|
|
def recv_removeNotificationStatus(self):
|
|
iprot = self._iprot
|
|
(fname, mtype, rseqid) = iprot.readMessageBegin()
|
|
if mtype == TMessageType.EXCEPTION:
|
|
x = TApplicationException()
|
|
x.read(iprot)
|
|
iprot.readMessageEnd()
|
|
raise x
|
|
result = removeNotificationStatus_result()
|
|
result.read(iprot)
|
|
iprot.readMessageEnd()
|
|
if result.e is not None:
|
|
raise result.e
|
|
return
|
|
|
|
def sendMessageForChannel(self, message):
|
|
"""
|
|
Parameters:
|
|
- message
|
|
|
|
"""
|
|
self.send_sendMessageForChannel(message)
|
|
return self.recv_sendMessageForChannel()
|
|
|
|
def send_sendMessageForChannel(self, message):
|
|
self._oprot.writeMessageBegin('sendMessageForChannel', TMessageType.CALL, self._seqid)
|
|
args = sendMessageForChannel_args()
|
|
args.message = message
|
|
args.write(self._oprot)
|
|
self._oprot.writeMessageEnd()
|
|
self._oprot.trans.flush()
|
|
|
|
def recv_sendMessageForChannel(self):
|
|
iprot = self._iprot
|
|
(fname, mtype, rseqid) = iprot.readMessageBegin()
|
|
if mtype == TMessageType.EXCEPTION:
|
|
x = TApplicationException()
|
|
x.read(iprot)
|
|
iprot.readMessageEnd()
|
|
raise x
|
|
result = sendMessageForChannel_result()
|
|
result.read(iprot)
|
|
iprot.readMessageEnd()
|
|
if result.success is not None:
|
|
return result.success
|
|
if result.e is not None:
|
|
raise result.e
|
|
raise TApplicationException(TApplicationException.MISSING_RESULT, "sendMessageForChannel failed: unknown result")
|
|
|
|
def sendPinCodeOperation(self, verifier):
|
|
"""
|
|
Parameters:
|
|
- verifier
|
|
|
|
"""
|
|
self.send_sendPinCodeOperation(verifier)
|
|
self.recv_sendPinCodeOperation()
|
|
|
|
def send_sendPinCodeOperation(self, verifier):
|
|
self._oprot.writeMessageBegin('sendPinCodeOperation', TMessageType.CALL, self._seqid)
|
|
args = sendPinCodeOperation_args()
|
|
args.verifier = verifier
|
|
args.write(self._oprot)
|
|
self._oprot.writeMessageEnd()
|
|
self._oprot.trans.flush()
|
|
|
|
def recv_sendPinCodeOperation(self):
|
|
iprot = self._iprot
|
|
(fname, mtype, rseqid) = iprot.readMessageBegin()
|
|
if mtype == TMessageType.EXCEPTION:
|
|
x = TApplicationException()
|
|
x.read(iprot)
|
|
iprot.readMessageEnd()
|
|
raise x
|
|
result = sendPinCodeOperation_result()
|
|
result.read(iprot)
|
|
iprot.readMessageEnd()
|
|
if result.e is not None:
|
|
raise result.e
|
|
return
|
|
|
|
def updateProfileAttributeForChannel(self, profileAttribute, value):
|
|
"""
|
|
Parameters:
|
|
- profileAttribute
|
|
- value
|
|
|
|
"""
|
|
self.send_updateProfileAttributeForChannel(profileAttribute, value)
|
|
self.recv_updateProfileAttributeForChannel()
|
|
|
|
def send_updateProfileAttributeForChannel(self, profileAttribute, value):
|
|
self._oprot.writeMessageBegin('updateProfileAttributeForChannel', TMessageType.CALL, self._seqid)
|
|
args = updateProfileAttributeForChannel_args()
|
|
args.profileAttribute = profileAttribute
|
|
args.value = value
|
|
args.write(self._oprot)
|
|
self._oprot.writeMessageEnd()
|
|
self._oprot.trans.flush()
|
|
|
|
def recv_updateProfileAttributeForChannel(self):
|
|
iprot = self._iprot
|
|
(fname, mtype, rseqid) = iprot.readMessageBegin()
|
|
if mtype == TMessageType.EXCEPTION:
|
|
x = TApplicationException()
|
|
x.read(iprot)
|
|
iprot.readMessageEnd()
|
|
raise x
|
|
result = updateProfileAttributeForChannel_result()
|
|
result.read(iprot)
|
|
iprot.readMessageEnd()
|
|
if result.e is not None:
|
|
raise result.e
|
|
return
|
|
|
|
|
|
class Processor(Iface, TProcessor):
|
|
def __init__(self, handler):
|
|
self._handler = handler
|
|
self._processMap = {}
|
|
self._processMap["activeBuddySubscriberCount"] = Processor.process_activeBuddySubscriberCount
|
|
self._processMap["addOperationForChannel"] = Processor.process_addOperationForChannel
|
|
self._processMap["displayBuddySubscriberCount"] = Processor.process_displayBuddySubscriberCount
|
|
self._processMap["findContactByUseridWithoutAbuseBlockForChannel"] = Processor.process_findContactByUseridWithoutAbuseBlockForChannel
|
|
self._processMap["getAllContactIdsForChannel"] = Processor.process_getAllContactIdsForChannel
|
|
self._processMap["getCompactContacts"] = Processor.process_getCompactContacts
|
|
self._processMap["getContactsForChannel"] = Processor.process_getContactsForChannel
|
|
self._processMap["getDisplayName"] = Processor.process_getDisplayName
|
|
self._processMap["getFavoriteMidsForChannel"] = Processor.process_getFavoriteMidsForChannel
|
|
self._processMap["getFriendMids"] = Processor.process_getFriendMids
|
|
self._processMap["getGroupMemberMids"] = Processor.process_getGroupMemberMids
|
|
self._processMap["getGroupsForChannel"] = Processor.process_getGroupsForChannel
|
|
self._processMap["getIdentityCredential"] = Processor.process_getIdentityCredential
|
|
self._processMap["getJoinedGroupIdsForChannel"] = Processor.process_getJoinedGroupIdsForChannel
|
|
self._processMap["getMetaProfile"] = Processor.process_getMetaProfile
|
|
self._processMap["getMid"] = Processor.process_getMid
|
|
self._processMap["getPrimaryClientForChannel"] = Processor.process_getPrimaryClientForChannel
|
|
self._processMap["getProfileForChannel"] = Processor.process_getProfileForChannel
|
|
self._processMap["getSimpleChannelContacts"] = Processor.process_getSimpleChannelContacts
|
|
self._processMap["getUserCountryForBilling"] = Processor.process_getUserCountryForBilling
|
|
self._processMap["getUserCreateTime"] = Processor.process_getUserCreateTime
|
|
self._processMap["getUserIdentities"] = Processor.process_getUserIdentities
|
|
self._processMap["getUserLanguage"] = Processor.process_getUserLanguage
|
|
self._processMap["getUserMidsWhoAddedMe"] = Processor.process_getUserMidsWhoAddedMe
|
|
self._processMap["isGroupMember"] = Processor.process_isGroupMember
|
|
self._processMap["isInContact"] = Processor.process_isInContact
|
|
self._processMap["registerChannelCP"] = Processor.process_registerChannelCP
|
|
self._processMap["removeNotificationStatus"] = Processor.process_removeNotificationStatus
|
|
self._processMap["sendMessageForChannel"] = Processor.process_sendMessageForChannel
|
|
self._processMap["sendPinCodeOperation"] = Processor.process_sendPinCodeOperation
|
|
self._processMap["updateProfileAttributeForChannel"] = Processor.process_updateProfileAttributeForChannel
|
|
self._on_message_begin = None
|
|
|
|
def on_message_begin(self, func):
|
|
self._on_message_begin = func
|
|
|
|
def process(self, iprot, oprot):
|
|
(name, type, seqid) = iprot.readMessageBegin()
|
|
if self._on_message_begin:
|
|
self._on_message_begin(name, type, seqid)
|
|
if name not in self._processMap:
|
|
iprot.skip(TType.STRUCT)
|
|
iprot.readMessageEnd()
|
|
x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
|
|
oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
|
|
x.write(oprot)
|
|
oprot.writeMessageEnd()
|
|
oprot.trans.flush()
|
|
return
|
|
else:
|
|
self._processMap[name](self, seqid, iprot, oprot)
|
|
return True
|
|
|
|
def process_activeBuddySubscriberCount(self, seqid, iprot, oprot):
|
|
args = activeBuddySubscriberCount_args()
|
|
args.read(iprot)
|
|
iprot.readMessageEnd()
|
|
result = activeBuddySubscriberCount_result()
|
|
try:
|
|
result.success = self._handler.activeBuddySubscriberCount()
|
|
msg_type = TMessageType.REPLY
|
|
except TTransport.TTransportException:
|
|
raise
|
|
except TalkException as e:
|
|
msg_type = TMessageType.REPLY
|
|
result.e = e
|
|
except TApplicationException as ex:
|
|
logging.exception('TApplication exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = ex
|
|
except Exception:
|
|
logging.exception('Unexpected exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
|
|
oprot.writeMessageBegin("activeBuddySubscriberCount", msg_type, seqid)
|
|
result.write(oprot)
|
|
oprot.writeMessageEnd()
|
|
oprot.trans.flush()
|
|
|
|
def process_addOperationForChannel(self, seqid, iprot, oprot):
|
|
args = addOperationForChannel_args()
|
|
args.read(iprot)
|
|
iprot.readMessageEnd()
|
|
result = addOperationForChannel_result()
|
|
try:
|
|
self._handler.addOperationForChannel(args.opType, args.param1, args.param2, args.param3)
|
|
msg_type = TMessageType.REPLY
|
|
except TTransport.TTransportException:
|
|
raise
|
|
except TalkException as e:
|
|
msg_type = TMessageType.REPLY
|
|
result.e = e
|
|
except TApplicationException as ex:
|
|
logging.exception('TApplication exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = ex
|
|
except Exception:
|
|
logging.exception('Unexpected exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
|
|
oprot.writeMessageBegin("addOperationForChannel", msg_type, seqid)
|
|
result.write(oprot)
|
|
oprot.writeMessageEnd()
|
|
oprot.trans.flush()
|
|
|
|
def process_displayBuddySubscriberCount(self, seqid, iprot, oprot):
|
|
args = displayBuddySubscriberCount_args()
|
|
args.read(iprot)
|
|
iprot.readMessageEnd()
|
|
result = displayBuddySubscriberCount_result()
|
|
try:
|
|
result.success = self._handler.displayBuddySubscriberCount()
|
|
msg_type = TMessageType.REPLY
|
|
except TTransport.TTransportException:
|
|
raise
|
|
except TalkException as e:
|
|
msg_type = TMessageType.REPLY
|
|
result.e = e
|
|
except TApplicationException as ex:
|
|
logging.exception('TApplication exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = ex
|
|
except Exception:
|
|
logging.exception('Unexpected exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
|
|
oprot.writeMessageBegin("displayBuddySubscriberCount", msg_type, seqid)
|
|
result.write(oprot)
|
|
oprot.writeMessageEnd()
|
|
oprot.trans.flush()
|
|
|
|
def process_findContactByUseridWithoutAbuseBlockForChannel(self, seqid, iprot, oprot):
|
|
args = findContactByUseridWithoutAbuseBlockForChannel_args()
|
|
args.read(iprot)
|
|
iprot.readMessageEnd()
|
|
result = findContactByUseridWithoutAbuseBlockForChannel_result()
|
|
try:
|
|
result.success = self._handler.findContactByUseridWithoutAbuseBlockForChannel(args.userid)
|
|
msg_type = TMessageType.REPLY
|
|
except TTransport.TTransportException:
|
|
raise
|
|
except TalkException as e:
|
|
msg_type = TMessageType.REPLY
|
|
result.e = e
|
|
except TApplicationException as ex:
|
|
logging.exception('TApplication exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = ex
|
|
except Exception:
|
|
logging.exception('Unexpected exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
|
|
oprot.writeMessageBegin("findContactByUseridWithoutAbuseBlockForChannel", msg_type, seqid)
|
|
result.write(oprot)
|
|
oprot.writeMessageEnd()
|
|
oprot.trans.flush()
|
|
|
|
def process_getAllContactIdsForChannel(self, seqid, iprot, oprot):
|
|
args = getAllContactIdsForChannel_args()
|
|
args.read(iprot)
|
|
iprot.readMessageEnd()
|
|
result = getAllContactIdsForChannel_result()
|
|
try:
|
|
result.success = self._handler.getAllContactIdsForChannel()
|
|
msg_type = TMessageType.REPLY
|
|
except TTransport.TTransportException:
|
|
raise
|
|
except TalkException as e:
|
|
msg_type = TMessageType.REPLY
|
|
result.e = e
|
|
except TApplicationException as ex:
|
|
logging.exception('TApplication exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = ex
|
|
except Exception:
|
|
logging.exception('Unexpected exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
|
|
oprot.writeMessageBegin("getAllContactIdsForChannel", msg_type, seqid)
|
|
result.write(oprot)
|
|
oprot.writeMessageEnd()
|
|
oprot.trans.flush()
|
|
|
|
def process_getCompactContacts(self, seqid, iprot, oprot):
|
|
args = getCompactContacts_args()
|
|
args.read(iprot)
|
|
iprot.readMessageEnd()
|
|
result = getCompactContacts_result()
|
|
try:
|
|
result.success = self._handler.getCompactContacts(args.lastModifiedTimestamp)
|
|
msg_type = TMessageType.REPLY
|
|
except TTransport.TTransportException:
|
|
raise
|
|
except TalkException as e:
|
|
msg_type = TMessageType.REPLY
|
|
result.e = e
|
|
except TApplicationException as ex:
|
|
logging.exception('TApplication exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = ex
|
|
except Exception:
|
|
logging.exception('Unexpected exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
|
|
oprot.writeMessageBegin("getCompactContacts", msg_type, seqid)
|
|
result.write(oprot)
|
|
oprot.writeMessageEnd()
|
|
oprot.trans.flush()
|
|
|
|
def process_getContactsForChannel(self, seqid, iprot, oprot):
|
|
args = getContactsForChannel_args()
|
|
args.read(iprot)
|
|
iprot.readMessageEnd()
|
|
result = getContactsForChannel_result()
|
|
try:
|
|
result.success = self._handler.getContactsForChannel(args.ids)
|
|
msg_type = TMessageType.REPLY
|
|
except TTransport.TTransportException:
|
|
raise
|
|
except TalkException as e:
|
|
msg_type = TMessageType.REPLY
|
|
result.e = e
|
|
except TApplicationException as ex:
|
|
logging.exception('TApplication exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = ex
|
|
except Exception:
|
|
logging.exception('Unexpected exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
|
|
oprot.writeMessageBegin("getContactsForChannel", msg_type, seqid)
|
|
result.write(oprot)
|
|
oprot.writeMessageEnd()
|
|
oprot.trans.flush()
|
|
|
|
def process_getDisplayName(self, seqid, iprot, oprot):
|
|
args = getDisplayName_args()
|
|
args.read(iprot)
|
|
iprot.readMessageEnd()
|
|
result = getDisplayName_result()
|
|
try:
|
|
result.success = self._handler.getDisplayName(args.mid)
|
|
msg_type = TMessageType.REPLY
|
|
except TTransport.TTransportException:
|
|
raise
|
|
except TalkException as e:
|
|
msg_type = TMessageType.REPLY
|
|
result.e = e
|
|
except TApplicationException as ex:
|
|
logging.exception('TApplication exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = ex
|
|
except Exception:
|
|
logging.exception('Unexpected exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
|
|
oprot.writeMessageBegin("getDisplayName", msg_type, seqid)
|
|
result.write(oprot)
|
|
oprot.writeMessageEnd()
|
|
oprot.trans.flush()
|
|
|
|
def process_getFavoriteMidsForChannel(self, seqid, iprot, oprot):
|
|
args = getFavoriteMidsForChannel_args()
|
|
args.read(iprot)
|
|
iprot.readMessageEnd()
|
|
result = getFavoriteMidsForChannel_result()
|
|
try:
|
|
result.success = self._handler.getFavoriteMidsForChannel()
|
|
msg_type = TMessageType.REPLY
|
|
except TTransport.TTransportException:
|
|
raise
|
|
except TalkException as e:
|
|
msg_type = TMessageType.REPLY
|
|
result.e = e
|
|
except TApplicationException as ex:
|
|
logging.exception('TApplication exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = ex
|
|
except Exception:
|
|
logging.exception('Unexpected exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
|
|
oprot.writeMessageBegin("getFavoriteMidsForChannel", msg_type, seqid)
|
|
result.write(oprot)
|
|
oprot.writeMessageEnd()
|
|
oprot.trans.flush()
|
|
|
|
def process_getFriendMids(self, seqid, iprot, oprot):
|
|
args = getFriendMids_args()
|
|
args.read(iprot)
|
|
iprot.readMessageEnd()
|
|
result = getFriendMids_result()
|
|
try:
|
|
result.success = self._handler.getFriendMids()
|
|
msg_type = TMessageType.REPLY
|
|
except TTransport.TTransportException:
|
|
raise
|
|
except TalkException as e:
|
|
msg_type = TMessageType.REPLY
|
|
result.e = e
|
|
except TApplicationException as ex:
|
|
logging.exception('TApplication exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = ex
|
|
except Exception:
|
|
logging.exception('Unexpected exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
|
|
oprot.writeMessageBegin("getFriendMids", msg_type, seqid)
|
|
result.write(oprot)
|
|
oprot.writeMessageEnd()
|
|
oprot.trans.flush()
|
|
|
|
def process_getGroupMemberMids(self, seqid, iprot, oprot):
|
|
args = getGroupMemberMids_args()
|
|
args.read(iprot)
|
|
iprot.readMessageEnd()
|
|
result = getGroupMemberMids_result()
|
|
try:
|
|
result.success = self._handler.getGroupMemberMids(args.groupId)
|
|
msg_type = TMessageType.REPLY
|
|
except TTransport.TTransportException:
|
|
raise
|
|
except TalkException as e:
|
|
msg_type = TMessageType.REPLY
|
|
result.e = e
|
|
except TApplicationException as ex:
|
|
logging.exception('TApplication exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = ex
|
|
except Exception:
|
|
logging.exception('Unexpected exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
|
|
oprot.writeMessageBegin("getGroupMemberMids", msg_type, seqid)
|
|
result.write(oprot)
|
|
oprot.writeMessageEnd()
|
|
oprot.trans.flush()
|
|
|
|
def process_getGroupsForChannel(self, seqid, iprot, oprot):
|
|
args = getGroupsForChannel_args()
|
|
args.read(iprot)
|
|
iprot.readMessageEnd()
|
|
result = getGroupsForChannel_result()
|
|
try:
|
|
result.success = self._handler.getGroupsForChannel(args.groupIds)
|
|
msg_type = TMessageType.REPLY
|
|
except TTransport.TTransportException:
|
|
raise
|
|
except TalkException as e:
|
|
msg_type = TMessageType.REPLY
|
|
result.e = e
|
|
except TApplicationException as ex:
|
|
logging.exception('TApplication exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = ex
|
|
except Exception:
|
|
logging.exception('Unexpected exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
|
|
oprot.writeMessageBegin("getGroupsForChannel", msg_type, seqid)
|
|
result.write(oprot)
|
|
oprot.writeMessageEnd()
|
|
oprot.trans.flush()
|
|
|
|
def process_getIdentityCredential(self, seqid, iprot, oprot):
|
|
args = getIdentityCredential_args()
|
|
args.read(iprot)
|
|
iprot.readMessageEnd()
|
|
result = getIdentityCredential_result()
|
|
try:
|
|
result.success = self._handler.getIdentityCredential()
|
|
msg_type = TMessageType.REPLY
|
|
except TTransport.TTransportException:
|
|
raise
|
|
except TalkException as e:
|
|
msg_type = TMessageType.REPLY
|
|
result.e = e
|
|
except TApplicationException as ex:
|
|
logging.exception('TApplication exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = ex
|
|
except Exception:
|
|
logging.exception('Unexpected exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
|
|
oprot.writeMessageBegin("getIdentityCredential", msg_type, seqid)
|
|
result.write(oprot)
|
|
oprot.writeMessageEnd()
|
|
oprot.trans.flush()
|
|
|
|
def process_getJoinedGroupIdsForChannel(self, seqid, iprot, oprot):
|
|
args = getJoinedGroupIdsForChannel_args()
|
|
args.read(iprot)
|
|
iprot.readMessageEnd()
|
|
result = getJoinedGroupIdsForChannel_result()
|
|
try:
|
|
result.success = self._handler.getJoinedGroupIdsForChannel()
|
|
msg_type = TMessageType.REPLY
|
|
except TTransport.TTransportException:
|
|
raise
|
|
except TalkException as e:
|
|
msg_type = TMessageType.REPLY
|
|
result.e = e
|
|
except TApplicationException as ex:
|
|
logging.exception('TApplication exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = ex
|
|
except Exception:
|
|
logging.exception('Unexpected exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
|
|
oprot.writeMessageBegin("getJoinedGroupIdsForChannel", msg_type, seqid)
|
|
result.write(oprot)
|
|
oprot.writeMessageEnd()
|
|
oprot.trans.flush()
|
|
|
|
def process_getMetaProfile(self, seqid, iprot, oprot):
|
|
args = getMetaProfile_args()
|
|
args.read(iprot)
|
|
iprot.readMessageEnd()
|
|
result = getMetaProfile_result()
|
|
try:
|
|
result.success = self._handler.getMetaProfile()
|
|
msg_type = TMessageType.REPLY
|
|
except TTransport.TTransportException:
|
|
raise
|
|
except TalkException as e:
|
|
msg_type = TMessageType.REPLY
|
|
result.e = e
|
|
except TApplicationException as ex:
|
|
logging.exception('TApplication exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = ex
|
|
except Exception:
|
|
logging.exception('Unexpected exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
|
|
oprot.writeMessageBegin("getMetaProfile", msg_type, seqid)
|
|
result.write(oprot)
|
|
oprot.writeMessageEnd()
|
|
oprot.trans.flush()
|
|
|
|
def process_getMid(self, seqid, iprot, oprot):
|
|
args = getMid_args()
|
|
args.read(iprot)
|
|
iprot.readMessageEnd()
|
|
result = getMid_result()
|
|
try:
|
|
result.success = self._handler.getMid()
|
|
msg_type = TMessageType.REPLY
|
|
except TTransport.TTransportException:
|
|
raise
|
|
except TalkException as e:
|
|
msg_type = TMessageType.REPLY
|
|
result.e = e
|
|
except TApplicationException as ex:
|
|
logging.exception('TApplication exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = ex
|
|
except Exception:
|
|
logging.exception('Unexpected exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
|
|
oprot.writeMessageBegin("getMid", msg_type, seqid)
|
|
result.write(oprot)
|
|
oprot.writeMessageEnd()
|
|
oprot.trans.flush()
|
|
|
|
def process_getPrimaryClientForChannel(self, seqid, iprot, oprot):
|
|
args = getPrimaryClientForChannel_args()
|
|
args.read(iprot)
|
|
iprot.readMessageEnd()
|
|
result = getPrimaryClientForChannel_result()
|
|
try:
|
|
result.success = self._handler.getPrimaryClientForChannel()
|
|
msg_type = TMessageType.REPLY
|
|
except TTransport.TTransportException:
|
|
raise
|
|
except TalkException as e:
|
|
msg_type = TMessageType.REPLY
|
|
result.e = e
|
|
except TApplicationException as ex:
|
|
logging.exception('TApplication exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = ex
|
|
except Exception:
|
|
logging.exception('Unexpected exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
|
|
oprot.writeMessageBegin("getPrimaryClientForChannel", msg_type, seqid)
|
|
result.write(oprot)
|
|
oprot.writeMessageEnd()
|
|
oprot.trans.flush()
|
|
|
|
def process_getProfileForChannel(self, seqid, iprot, oprot):
|
|
args = getProfileForChannel_args()
|
|
args.read(iprot)
|
|
iprot.readMessageEnd()
|
|
result = getProfileForChannel_result()
|
|
try:
|
|
result.success = self._handler.getProfileForChannel()
|
|
msg_type = TMessageType.REPLY
|
|
except TTransport.TTransportException:
|
|
raise
|
|
except TalkException as e:
|
|
msg_type = TMessageType.REPLY
|
|
result.e = e
|
|
except TApplicationException as ex:
|
|
logging.exception('TApplication exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = ex
|
|
except Exception:
|
|
logging.exception('Unexpected exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
|
|
oprot.writeMessageBegin("getProfileForChannel", msg_type, seqid)
|
|
result.write(oprot)
|
|
oprot.writeMessageEnd()
|
|
oprot.trans.flush()
|
|
|
|
def process_getSimpleChannelContacts(self, seqid, iprot, oprot):
|
|
args = getSimpleChannelContacts_args()
|
|
args.read(iprot)
|
|
iprot.readMessageEnd()
|
|
result = getSimpleChannelContacts_result()
|
|
try:
|
|
result.success = self._handler.getSimpleChannelContacts(args.ids)
|
|
msg_type = TMessageType.REPLY
|
|
except TTransport.TTransportException:
|
|
raise
|
|
except TalkException as e:
|
|
msg_type = TMessageType.REPLY
|
|
result.e = e
|
|
except TApplicationException as ex:
|
|
logging.exception('TApplication exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = ex
|
|
except Exception:
|
|
logging.exception('Unexpected exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
|
|
oprot.writeMessageBegin("getSimpleChannelContacts", msg_type, seqid)
|
|
result.write(oprot)
|
|
oprot.writeMessageEnd()
|
|
oprot.trans.flush()
|
|
|
|
def process_getUserCountryForBilling(self, seqid, iprot, oprot):
|
|
args = getUserCountryForBilling_args()
|
|
args.read(iprot)
|
|
iprot.readMessageEnd()
|
|
result = getUserCountryForBilling_result()
|
|
try:
|
|
result.success = self._handler.getUserCountryForBilling(args.country, args.remoteIp)
|
|
msg_type = TMessageType.REPLY
|
|
except TTransport.TTransportException:
|
|
raise
|
|
except TalkException as e:
|
|
msg_type = TMessageType.REPLY
|
|
result.e = e
|
|
except TApplicationException as ex:
|
|
logging.exception('TApplication exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = ex
|
|
except Exception:
|
|
logging.exception('Unexpected exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
|
|
oprot.writeMessageBegin("getUserCountryForBilling", msg_type, seqid)
|
|
result.write(oprot)
|
|
oprot.writeMessageEnd()
|
|
oprot.trans.flush()
|
|
|
|
def process_getUserCreateTime(self, seqid, iprot, oprot):
|
|
args = getUserCreateTime_args()
|
|
args.read(iprot)
|
|
iprot.readMessageEnd()
|
|
result = getUserCreateTime_result()
|
|
try:
|
|
result.success = self._handler.getUserCreateTime()
|
|
msg_type = TMessageType.REPLY
|
|
except TTransport.TTransportException:
|
|
raise
|
|
except TalkException as e:
|
|
msg_type = TMessageType.REPLY
|
|
result.e = e
|
|
except TApplicationException as ex:
|
|
logging.exception('TApplication exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = ex
|
|
except Exception:
|
|
logging.exception('Unexpected exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
|
|
oprot.writeMessageBegin("getUserCreateTime", msg_type, seqid)
|
|
result.write(oprot)
|
|
oprot.writeMessageEnd()
|
|
oprot.trans.flush()
|
|
|
|
def process_getUserIdentities(self, seqid, iprot, oprot):
|
|
args = getUserIdentities_args()
|
|
args.read(iprot)
|
|
iprot.readMessageEnd()
|
|
result = getUserIdentities_result()
|
|
try:
|
|
result.success = self._handler.getUserIdentities()
|
|
msg_type = TMessageType.REPLY
|
|
except TTransport.TTransportException:
|
|
raise
|
|
except TalkException as e:
|
|
msg_type = TMessageType.REPLY
|
|
result.e = e
|
|
except TApplicationException as ex:
|
|
logging.exception('TApplication exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = ex
|
|
except Exception:
|
|
logging.exception('Unexpected exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
|
|
oprot.writeMessageBegin("getUserIdentities", msg_type, seqid)
|
|
result.write(oprot)
|
|
oprot.writeMessageEnd()
|
|
oprot.trans.flush()
|
|
|
|
def process_getUserLanguage(self, seqid, iprot, oprot):
|
|
args = getUserLanguage_args()
|
|
args.read(iprot)
|
|
iprot.readMessageEnd()
|
|
result = getUserLanguage_result()
|
|
try:
|
|
result.success = self._handler.getUserLanguage()
|
|
msg_type = TMessageType.REPLY
|
|
except TTransport.TTransportException:
|
|
raise
|
|
except TalkException as e:
|
|
msg_type = TMessageType.REPLY
|
|
result.e = e
|
|
except TApplicationException as ex:
|
|
logging.exception('TApplication exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = ex
|
|
except Exception:
|
|
logging.exception('Unexpected exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
|
|
oprot.writeMessageBegin("getUserLanguage", msg_type, seqid)
|
|
result.write(oprot)
|
|
oprot.writeMessageEnd()
|
|
oprot.trans.flush()
|
|
|
|
def process_getUserMidsWhoAddedMe(self, seqid, iprot, oprot):
|
|
args = getUserMidsWhoAddedMe_args()
|
|
args.read(iprot)
|
|
iprot.readMessageEnd()
|
|
result = getUserMidsWhoAddedMe_result()
|
|
try:
|
|
result.success = self._handler.getUserMidsWhoAddedMe()
|
|
msg_type = TMessageType.REPLY
|
|
except TTransport.TTransportException:
|
|
raise
|
|
except TalkException as e:
|
|
msg_type = TMessageType.REPLY
|
|
result.e = e
|
|
except TApplicationException as ex:
|
|
logging.exception('TApplication exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = ex
|
|
except Exception:
|
|
logging.exception('Unexpected exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
|
|
oprot.writeMessageBegin("getUserMidsWhoAddedMe", msg_type, seqid)
|
|
result.write(oprot)
|
|
oprot.writeMessageEnd()
|
|
oprot.trans.flush()
|
|
|
|
def process_isGroupMember(self, seqid, iprot, oprot):
|
|
args = isGroupMember_args()
|
|
args.read(iprot)
|
|
iprot.readMessageEnd()
|
|
result = isGroupMember_result()
|
|
try:
|
|
result.success = self._handler.isGroupMember(args.groupId)
|
|
msg_type = TMessageType.REPLY
|
|
except TTransport.TTransportException:
|
|
raise
|
|
except TalkException as e:
|
|
msg_type = TMessageType.REPLY
|
|
result.e = e
|
|
except TApplicationException as ex:
|
|
logging.exception('TApplication exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = ex
|
|
except Exception:
|
|
logging.exception('Unexpected exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
|
|
oprot.writeMessageBegin("isGroupMember", msg_type, seqid)
|
|
result.write(oprot)
|
|
oprot.writeMessageEnd()
|
|
oprot.trans.flush()
|
|
|
|
def process_isInContact(self, seqid, iprot, oprot):
|
|
args = isInContact_args()
|
|
args.read(iprot)
|
|
iprot.readMessageEnd()
|
|
result = isInContact_result()
|
|
try:
|
|
result.success = self._handler.isInContact(args.mid)
|
|
msg_type = TMessageType.REPLY
|
|
except TTransport.TTransportException:
|
|
raise
|
|
except TalkException as e:
|
|
msg_type = TMessageType.REPLY
|
|
result.e = e
|
|
except TApplicationException as ex:
|
|
logging.exception('TApplication exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = ex
|
|
except Exception:
|
|
logging.exception('Unexpected exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
|
|
oprot.writeMessageBegin("isInContact", msg_type, seqid)
|
|
result.write(oprot)
|
|
oprot.writeMessageEnd()
|
|
oprot.trans.flush()
|
|
|
|
def process_registerChannelCP(self, seqid, iprot, oprot):
|
|
args = registerChannelCP_args()
|
|
args.read(iprot)
|
|
iprot.readMessageEnd()
|
|
result = registerChannelCP_result()
|
|
try:
|
|
result.success = self._handler.registerChannelCP(args.cpId, args.registerPassword)
|
|
msg_type = TMessageType.REPLY
|
|
except TTransport.TTransportException:
|
|
raise
|
|
except TalkException as e:
|
|
msg_type = TMessageType.REPLY
|
|
result.e = e
|
|
except TApplicationException as ex:
|
|
logging.exception('TApplication exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = ex
|
|
except Exception:
|
|
logging.exception('Unexpected exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
|
|
oprot.writeMessageBegin("registerChannelCP", msg_type, seqid)
|
|
result.write(oprot)
|
|
oprot.writeMessageEnd()
|
|
oprot.trans.flush()
|
|
|
|
def process_removeNotificationStatus(self, seqid, iprot, oprot):
|
|
args = removeNotificationStatus_args()
|
|
args.read(iprot)
|
|
iprot.readMessageEnd()
|
|
result = removeNotificationStatus_result()
|
|
try:
|
|
self._handler.removeNotificationStatus(args.notificationStatus)
|
|
msg_type = TMessageType.REPLY
|
|
except TTransport.TTransportException:
|
|
raise
|
|
except TalkException as e:
|
|
msg_type = TMessageType.REPLY
|
|
result.e = e
|
|
except TApplicationException as ex:
|
|
logging.exception('TApplication exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = ex
|
|
except Exception:
|
|
logging.exception('Unexpected exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
|
|
oprot.writeMessageBegin("removeNotificationStatus", msg_type, seqid)
|
|
result.write(oprot)
|
|
oprot.writeMessageEnd()
|
|
oprot.trans.flush()
|
|
|
|
def process_sendMessageForChannel(self, seqid, iprot, oprot):
|
|
args = sendMessageForChannel_args()
|
|
args.read(iprot)
|
|
iprot.readMessageEnd()
|
|
result = sendMessageForChannel_result()
|
|
try:
|
|
result.success = self._handler.sendMessageForChannel(args.message)
|
|
msg_type = TMessageType.REPLY
|
|
except TTransport.TTransportException:
|
|
raise
|
|
except TalkException as e:
|
|
msg_type = TMessageType.REPLY
|
|
result.e = e
|
|
except TApplicationException as ex:
|
|
logging.exception('TApplication exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = ex
|
|
except Exception:
|
|
logging.exception('Unexpected exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
|
|
oprot.writeMessageBegin("sendMessageForChannel", msg_type, seqid)
|
|
result.write(oprot)
|
|
oprot.writeMessageEnd()
|
|
oprot.trans.flush()
|
|
|
|
def process_sendPinCodeOperation(self, seqid, iprot, oprot):
|
|
args = sendPinCodeOperation_args()
|
|
args.read(iprot)
|
|
iprot.readMessageEnd()
|
|
result = sendPinCodeOperation_result()
|
|
try:
|
|
self._handler.sendPinCodeOperation(args.verifier)
|
|
msg_type = TMessageType.REPLY
|
|
except TTransport.TTransportException:
|
|
raise
|
|
except TalkException as e:
|
|
msg_type = TMessageType.REPLY
|
|
result.e = e
|
|
except TApplicationException as ex:
|
|
logging.exception('TApplication exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = ex
|
|
except Exception:
|
|
logging.exception('Unexpected exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
|
|
oprot.writeMessageBegin("sendPinCodeOperation", msg_type, seqid)
|
|
result.write(oprot)
|
|
oprot.writeMessageEnd()
|
|
oprot.trans.flush()
|
|
|
|
def process_updateProfileAttributeForChannel(self, seqid, iprot, oprot):
|
|
args = updateProfileAttributeForChannel_args()
|
|
args.read(iprot)
|
|
iprot.readMessageEnd()
|
|
result = updateProfileAttributeForChannel_result()
|
|
try:
|
|
self._handler.updateProfileAttributeForChannel(args.profileAttribute, args.value)
|
|
msg_type = TMessageType.REPLY
|
|
except TTransport.TTransportException:
|
|
raise
|
|
except TalkException as e:
|
|
msg_type = TMessageType.REPLY
|
|
result.e = e
|
|
except TApplicationException as ex:
|
|
logging.exception('TApplication exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = ex
|
|
except Exception:
|
|
logging.exception('Unexpected exception in handler')
|
|
msg_type = TMessageType.EXCEPTION
|
|
result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
|
|
oprot.writeMessageBegin("updateProfileAttributeForChannel", msg_type, seqid)
|
|
result.write(oprot)
|
|
oprot.writeMessageEnd()
|
|
oprot.trans.flush()
|
|
|
|
# HELPER FUNCTIONS AND STRUCTURES
|
|
|
|
|
|
class activeBuddySubscriberCount_args(object):
|
|
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('activeBuddySubscriberCount_args')
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(activeBuddySubscriberCount_args)
|
|
activeBuddySubscriberCount_args.thrift_spec = (
|
|
)
|
|
|
|
|
|
class activeBuddySubscriberCount_result(object):
|
|
"""
|
|
Attributes:
|
|
- success
|
|
- e
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, success=None, e=None,):
|
|
self.success = success
|
|
self.e = e
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 0:
|
|
if ftype == TType.I64:
|
|
self.success = iprot.readI64()
|
|
else:
|
|
iprot.skip(ftype)
|
|
elif fid == 1:
|
|
if ftype == TType.STRUCT:
|
|
self.e = TalkException()
|
|
self.e.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('activeBuddySubscriberCount_result')
|
|
if self.success is not None:
|
|
oprot.writeFieldBegin('success', TType.I64, 0)
|
|
oprot.writeI64(self.success)
|
|
oprot.writeFieldEnd()
|
|
if self.e is not None:
|
|
oprot.writeFieldBegin('e', TType.STRUCT, 1)
|
|
self.e.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(activeBuddySubscriberCount_result)
|
|
activeBuddySubscriberCount_result.thrift_spec = (
|
|
(0, TType.I64, 'success', None, None, ), # 0
|
|
(1, TType.STRUCT, 'e', [TalkException, None], None, ), # 1
|
|
)
|
|
|
|
|
|
class addOperationForChannel_args(object):
|
|
"""
|
|
Attributes:
|
|
- opType
|
|
- param1
|
|
- param2
|
|
- param3
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, opType=None, param1=None, param2=None, param3=None,):
|
|
self.opType = opType
|
|
self.param1 = param1
|
|
self.param2 = param2
|
|
self.param3 = param3
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 1:
|
|
if ftype == TType.I32:
|
|
self.opType = iprot.readI32()
|
|
else:
|
|
iprot.skip(ftype)
|
|
elif fid == 2:
|
|
if ftype == TType.STRING:
|
|
self.param1 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
|
|
else:
|
|
iprot.skip(ftype)
|
|
elif fid == 3:
|
|
if ftype == TType.STRING:
|
|
self.param2 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
|
|
else:
|
|
iprot.skip(ftype)
|
|
elif fid == 4:
|
|
if ftype == TType.STRING:
|
|
self.param3 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('addOperationForChannel_args')
|
|
if self.opType is not None:
|
|
oprot.writeFieldBegin('opType', TType.I32, 1)
|
|
oprot.writeI32(self.opType)
|
|
oprot.writeFieldEnd()
|
|
if self.param1 is not None:
|
|
oprot.writeFieldBegin('param1', TType.STRING, 2)
|
|
oprot.writeString(self.param1.encode('utf-8') if sys.version_info[0] == 2 else self.param1)
|
|
oprot.writeFieldEnd()
|
|
if self.param2 is not None:
|
|
oprot.writeFieldBegin('param2', TType.STRING, 3)
|
|
oprot.writeString(self.param2.encode('utf-8') if sys.version_info[0] == 2 else self.param2)
|
|
oprot.writeFieldEnd()
|
|
if self.param3 is not None:
|
|
oprot.writeFieldBegin('param3', TType.STRING, 4)
|
|
oprot.writeString(self.param3.encode('utf-8') if sys.version_info[0] == 2 else self.param3)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(addOperationForChannel_args)
|
|
addOperationForChannel_args.thrift_spec = (
|
|
None, # 0
|
|
(1, TType.I32, 'opType', None, None, ), # 1
|
|
(2, TType.STRING, 'param1', 'UTF8', None, ), # 2
|
|
(3, TType.STRING, 'param2', 'UTF8', None, ), # 3
|
|
(4, TType.STRING, 'param3', 'UTF8', None, ), # 4
|
|
)
|
|
|
|
|
|
class addOperationForChannel_result(object):
|
|
"""
|
|
Attributes:
|
|
- e
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, e=None,):
|
|
self.e = e
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 1:
|
|
if ftype == TType.STRUCT:
|
|
self.e = TalkException()
|
|
self.e.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('addOperationForChannel_result')
|
|
if self.e is not None:
|
|
oprot.writeFieldBegin('e', TType.STRUCT, 1)
|
|
self.e.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(addOperationForChannel_result)
|
|
addOperationForChannel_result.thrift_spec = (
|
|
None, # 0
|
|
(1, TType.STRUCT, 'e', [TalkException, None], None, ), # 1
|
|
)
|
|
|
|
|
|
class displayBuddySubscriberCount_args(object):
|
|
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('displayBuddySubscriberCount_args')
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(displayBuddySubscriberCount_args)
|
|
displayBuddySubscriberCount_args.thrift_spec = (
|
|
)
|
|
|
|
|
|
class displayBuddySubscriberCount_result(object):
|
|
"""
|
|
Attributes:
|
|
- success
|
|
- e
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, success=None, e=None,):
|
|
self.success = success
|
|
self.e = e
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 0:
|
|
if ftype == TType.I64:
|
|
self.success = iprot.readI64()
|
|
else:
|
|
iprot.skip(ftype)
|
|
elif fid == 1:
|
|
if ftype == TType.STRUCT:
|
|
self.e = TalkException()
|
|
self.e.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('displayBuddySubscriberCount_result')
|
|
if self.success is not None:
|
|
oprot.writeFieldBegin('success', TType.I64, 0)
|
|
oprot.writeI64(self.success)
|
|
oprot.writeFieldEnd()
|
|
if self.e is not None:
|
|
oprot.writeFieldBegin('e', TType.STRUCT, 1)
|
|
self.e.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(displayBuddySubscriberCount_result)
|
|
displayBuddySubscriberCount_result.thrift_spec = (
|
|
(0, TType.I64, 'success', None, None, ), # 0
|
|
(1, TType.STRUCT, 'e', [TalkException, None], None, ), # 1
|
|
)
|
|
|
|
|
|
class findContactByUseridWithoutAbuseBlockForChannel_args(object):
|
|
"""
|
|
Attributes:
|
|
- userid
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, userid=None,):
|
|
self.userid = userid
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 2:
|
|
if ftype == TType.STRING:
|
|
self.userid = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('findContactByUseridWithoutAbuseBlockForChannel_args')
|
|
if self.userid is not None:
|
|
oprot.writeFieldBegin('userid', TType.STRING, 2)
|
|
oprot.writeString(self.userid.encode('utf-8') if sys.version_info[0] == 2 else self.userid)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(findContactByUseridWithoutAbuseBlockForChannel_args)
|
|
findContactByUseridWithoutAbuseBlockForChannel_args.thrift_spec = (
|
|
None, # 0
|
|
None, # 1
|
|
(2, TType.STRING, 'userid', 'UTF8', None, ), # 2
|
|
)
|
|
|
|
|
|
class findContactByUseridWithoutAbuseBlockForChannel_result(object):
|
|
"""
|
|
Attributes:
|
|
- success
|
|
- e
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, success=None, e=None,):
|
|
self.success = success
|
|
self.e = e
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 0:
|
|
if ftype == TType.STRUCT:
|
|
self.success = Contact()
|
|
self.success.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
elif fid == 1:
|
|
if ftype == TType.STRUCT:
|
|
self.e = TalkException()
|
|
self.e.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('findContactByUseridWithoutAbuseBlockForChannel_result')
|
|
if self.success is not None:
|
|
oprot.writeFieldBegin('success', TType.STRUCT, 0)
|
|
self.success.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
if self.e is not None:
|
|
oprot.writeFieldBegin('e', TType.STRUCT, 1)
|
|
self.e.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(findContactByUseridWithoutAbuseBlockForChannel_result)
|
|
findContactByUseridWithoutAbuseBlockForChannel_result.thrift_spec = (
|
|
(0, TType.STRUCT, 'success', [Contact, None], None, ), # 0
|
|
(1, TType.STRUCT, 'e', [TalkException, None], None, ), # 1
|
|
)
|
|
|
|
|
|
class getAllContactIdsForChannel_args(object):
|
|
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getAllContactIdsForChannel_args')
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getAllContactIdsForChannel_args)
|
|
getAllContactIdsForChannel_args.thrift_spec = (
|
|
)
|
|
|
|
|
|
class getAllContactIdsForChannel_result(object):
|
|
"""
|
|
Attributes:
|
|
- success
|
|
- e
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, success=None, e=None,):
|
|
self.success = success
|
|
self.e = e
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 0:
|
|
if ftype == TType.LIST:
|
|
self.success = []
|
|
(_etype538, _size535) = iprot.readListBegin()
|
|
for _i539 in range(_size535):
|
|
_elem540 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
|
|
self.success.append(_elem540)
|
|
iprot.readListEnd()
|
|
else:
|
|
iprot.skip(ftype)
|
|
elif fid == 1:
|
|
if ftype == TType.STRUCT:
|
|
self.e = TalkException()
|
|
self.e.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getAllContactIdsForChannel_result')
|
|
if self.success is not None:
|
|
oprot.writeFieldBegin('success', TType.LIST, 0)
|
|
oprot.writeListBegin(TType.STRING, len(self.success))
|
|
for iter541 in self.success:
|
|
oprot.writeString(iter541.encode('utf-8') if sys.version_info[0] == 2 else iter541)
|
|
oprot.writeListEnd()
|
|
oprot.writeFieldEnd()
|
|
if self.e is not None:
|
|
oprot.writeFieldBegin('e', TType.STRUCT, 1)
|
|
self.e.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getAllContactIdsForChannel_result)
|
|
getAllContactIdsForChannel_result.thrift_spec = (
|
|
(0, TType.LIST, 'success', (TType.STRING, 'UTF8', False), None, ), # 0
|
|
(1, TType.STRUCT, 'e', [TalkException, None], None, ), # 1
|
|
)
|
|
|
|
|
|
class getCompactContacts_args(object):
|
|
"""
|
|
Attributes:
|
|
- lastModifiedTimestamp
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, lastModifiedTimestamp=None,):
|
|
self.lastModifiedTimestamp = lastModifiedTimestamp
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 2:
|
|
if ftype == TType.I64:
|
|
self.lastModifiedTimestamp = iprot.readI64()
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getCompactContacts_args')
|
|
if self.lastModifiedTimestamp is not None:
|
|
oprot.writeFieldBegin('lastModifiedTimestamp', TType.I64, 2)
|
|
oprot.writeI64(self.lastModifiedTimestamp)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getCompactContacts_args)
|
|
getCompactContacts_args.thrift_spec = (
|
|
None, # 0
|
|
None, # 1
|
|
(2, TType.I64, 'lastModifiedTimestamp', None, None, ), # 2
|
|
)
|
|
|
|
|
|
class getCompactContacts_result(object):
|
|
"""
|
|
Attributes:
|
|
- success
|
|
- e
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, success=None, e=None,):
|
|
self.success = success
|
|
self.e = e
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 0:
|
|
if ftype == TType.LIST:
|
|
self.success = []
|
|
(_etype545, _size542) = iprot.readListBegin()
|
|
for _i546 in range(_size542):
|
|
_elem547 = CompactContact()
|
|
_elem547.read(iprot)
|
|
self.success.append(_elem547)
|
|
iprot.readListEnd()
|
|
else:
|
|
iprot.skip(ftype)
|
|
elif fid == 1:
|
|
if ftype == TType.STRUCT:
|
|
self.e = TalkException()
|
|
self.e.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getCompactContacts_result')
|
|
if self.success is not None:
|
|
oprot.writeFieldBegin('success', TType.LIST, 0)
|
|
oprot.writeListBegin(TType.STRUCT, len(self.success))
|
|
for iter548 in self.success:
|
|
iter548.write(oprot)
|
|
oprot.writeListEnd()
|
|
oprot.writeFieldEnd()
|
|
if self.e is not None:
|
|
oprot.writeFieldBegin('e', TType.STRUCT, 1)
|
|
self.e.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getCompactContacts_result)
|
|
getCompactContacts_result.thrift_spec = (
|
|
(0, TType.LIST, 'success', (TType.STRUCT, [CompactContact, None], False), None, ), # 0
|
|
(1, TType.STRUCT, 'e', [TalkException, None], None, ), # 1
|
|
)
|
|
|
|
|
|
class getContactsForChannel_args(object):
|
|
"""
|
|
Attributes:
|
|
- ids
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, ids=None,):
|
|
self.ids = ids
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 2:
|
|
if ftype == TType.LIST:
|
|
self.ids = []
|
|
(_etype552, _size549) = iprot.readListBegin()
|
|
for _i553 in range(_size549):
|
|
_elem554 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
|
|
self.ids.append(_elem554)
|
|
iprot.readListEnd()
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getContactsForChannel_args')
|
|
if self.ids is not None:
|
|
oprot.writeFieldBegin('ids', TType.LIST, 2)
|
|
oprot.writeListBegin(TType.STRING, len(self.ids))
|
|
for iter555 in self.ids:
|
|
oprot.writeString(iter555.encode('utf-8') if sys.version_info[0] == 2 else iter555)
|
|
oprot.writeListEnd()
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getContactsForChannel_args)
|
|
getContactsForChannel_args.thrift_spec = (
|
|
None, # 0
|
|
None, # 1
|
|
(2, TType.LIST, 'ids', (TType.STRING, 'UTF8', False), None, ), # 2
|
|
)
|
|
|
|
|
|
class getContactsForChannel_result(object):
|
|
"""
|
|
Attributes:
|
|
- success
|
|
- e
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, success=None, e=None,):
|
|
self.success = success
|
|
self.e = e
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 0:
|
|
if ftype == TType.LIST:
|
|
self.success = []
|
|
(_etype559, _size556) = iprot.readListBegin()
|
|
for _i560 in range(_size556):
|
|
_elem561 = Contact()
|
|
_elem561.read(iprot)
|
|
self.success.append(_elem561)
|
|
iprot.readListEnd()
|
|
else:
|
|
iprot.skip(ftype)
|
|
elif fid == 1:
|
|
if ftype == TType.STRUCT:
|
|
self.e = TalkException()
|
|
self.e.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getContactsForChannel_result')
|
|
if self.success is not None:
|
|
oprot.writeFieldBegin('success', TType.LIST, 0)
|
|
oprot.writeListBegin(TType.STRUCT, len(self.success))
|
|
for iter562 in self.success:
|
|
iter562.write(oprot)
|
|
oprot.writeListEnd()
|
|
oprot.writeFieldEnd()
|
|
if self.e is not None:
|
|
oprot.writeFieldBegin('e', TType.STRUCT, 1)
|
|
self.e.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getContactsForChannel_result)
|
|
getContactsForChannel_result.thrift_spec = (
|
|
(0, TType.LIST, 'success', (TType.STRUCT, [Contact, None], False), None, ), # 0
|
|
(1, TType.STRUCT, 'e', [TalkException, None], None, ), # 1
|
|
)
|
|
|
|
|
|
class getDisplayName_args(object):
|
|
"""
|
|
Attributes:
|
|
- mid
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, mid=None,):
|
|
self.mid = mid
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 2:
|
|
if ftype == TType.STRING:
|
|
self.mid = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getDisplayName_args')
|
|
if self.mid is not None:
|
|
oprot.writeFieldBegin('mid', TType.STRING, 2)
|
|
oprot.writeString(self.mid.encode('utf-8') if sys.version_info[0] == 2 else self.mid)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getDisplayName_args)
|
|
getDisplayName_args.thrift_spec = (
|
|
None, # 0
|
|
None, # 1
|
|
(2, TType.STRING, 'mid', 'UTF8', None, ), # 2
|
|
)
|
|
|
|
|
|
class getDisplayName_result(object):
|
|
"""
|
|
Attributes:
|
|
- success
|
|
- e
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, success=None, e=None,):
|
|
self.success = success
|
|
self.e = e
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 0:
|
|
if ftype == TType.STRING:
|
|
self.success = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
|
|
else:
|
|
iprot.skip(ftype)
|
|
elif fid == 1:
|
|
if ftype == TType.STRUCT:
|
|
self.e = TalkException()
|
|
self.e.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getDisplayName_result')
|
|
if self.success is not None:
|
|
oprot.writeFieldBegin('success', TType.STRING, 0)
|
|
oprot.writeString(self.success.encode('utf-8') if sys.version_info[0] == 2 else self.success)
|
|
oprot.writeFieldEnd()
|
|
if self.e is not None:
|
|
oprot.writeFieldBegin('e', TType.STRUCT, 1)
|
|
self.e.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getDisplayName_result)
|
|
getDisplayName_result.thrift_spec = (
|
|
(0, TType.STRING, 'success', 'UTF8', None, ), # 0
|
|
(1, TType.STRUCT, 'e', [TalkException, None], None, ), # 1
|
|
)
|
|
|
|
|
|
class getFavoriteMidsForChannel_args(object):
|
|
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getFavoriteMidsForChannel_args')
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getFavoriteMidsForChannel_args)
|
|
getFavoriteMidsForChannel_args.thrift_spec = (
|
|
)
|
|
|
|
|
|
class getFavoriteMidsForChannel_result(object):
|
|
"""
|
|
Attributes:
|
|
- success
|
|
- e
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, success=None, e=None,):
|
|
self.success = success
|
|
self.e = e
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 0:
|
|
if ftype == TType.LIST:
|
|
self.success = []
|
|
(_etype566, _size563) = iprot.readListBegin()
|
|
for _i567 in range(_size563):
|
|
_elem568 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
|
|
self.success.append(_elem568)
|
|
iprot.readListEnd()
|
|
else:
|
|
iprot.skip(ftype)
|
|
elif fid == 1:
|
|
if ftype == TType.STRUCT:
|
|
self.e = TalkException()
|
|
self.e.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getFavoriteMidsForChannel_result')
|
|
if self.success is not None:
|
|
oprot.writeFieldBegin('success', TType.LIST, 0)
|
|
oprot.writeListBegin(TType.STRING, len(self.success))
|
|
for iter569 in self.success:
|
|
oprot.writeString(iter569.encode('utf-8') if sys.version_info[0] == 2 else iter569)
|
|
oprot.writeListEnd()
|
|
oprot.writeFieldEnd()
|
|
if self.e is not None:
|
|
oprot.writeFieldBegin('e', TType.STRUCT, 1)
|
|
self.e.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getFavoriteMidsForChannel_result)
|
|
getFavoriteMidsForChannel_result.thrift_spec = (
|
|
(0, TType.LIST, 'success', (TType.STRING, 'UTF8', False), None, ), # 0
|
|
(1, TType.STRUCT, 'e', [TalkException, None], None, ), # 1
|
|
)
|
|
|
|
|
|
class getFriendMids_args(object):
|
|
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getFriendMids_args')
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getFriendMids_args)
|
|
getFriendMids_args.thrift_spec = (
|
|
)
|
|
|
|
|
|
class getFriendMids_result(object):
|
|
"""
|
|
Attributes:
|
|
- success
|
|
- e
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, success=None, e=None,):
|
|
self.success = success
|
|
self.e = e
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 0:
|
|
if ftype == TType.LIST:
|
|
self.success = []
|
|
(_etype573, _size570) = iprot.readListBegin()
|
|
for _i574 in range(_size570):
|
|
_elem575 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
|
|
self.success.append(_elem575)
|
|
iprot.readListEnd()
|
|
else:
|
|
iprot.skip(ftype)
|
|
elif fid == 1:
|
|
if ftype == TType.STRUCT:
|
|
self.e = TalkException()
|
|
self.e.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getFriendMids_result')
|
|
if self.success is not None:
|
|
oprot.writeFieldBegin('success', TType.LIST, 0)
|
|
oprot.writeListBegin(TType.STRING, len(self.success))
|
|
for iter576 in self.success:
|
|
oprot.writeString(iter576.encode('utf-8') if sys.version_info[0] == 2 else iter576)
|
|
oprot.writeListEnd()
|
|
oprot.writeFieldEnd()
|
|
if self.e is not None:
|
|
oprot.writeFieldBegin('e', TType.STRUCT, 1)
|
|
self.e.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getFriendMids_result)
|
|
getFriendMids_result.thrift_spec = (
|
|
(0, TType.LIST, 'success', (TType.STRING, 'UTF8', False), None, ), # 0
|
|
(1, TType.STRUCT, 'e', [TalkException, None], None, ), # 1
|
|
)
|
|
|
|
|
|
class getGroupMemberMids_args(object):
|
|
"""
|
|
Attributes:
|
|
- groupId
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, groupId=None,):
|
|
self.groupId = groupId
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 1:
|
|
if ftype == TType.STRING:
|
|
self.groupId = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getGroupMemberMids_args')
|
|
if self.groupId is not None:
|
|
oprot.writeFieldBegin('groupId', TType.STRING, 1)
|
|
oprot.writeString(self.groupId.encode('utf-8') if sys.version_info[0] == 2 else self.groupId)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getGroupMemberMids_args)
|
|
getGroupMemberMids_args.thrift_spec = (
|
|
None, # 0
|
|
(1, TType.STRING, 'groupId', 'UTF8', None, ), # 1
|
|
)
|
|
|
|
|
|
class getGroupMemberMids_result(object):
|
|
"""
|
|
Attributes:
|
|
- success
|
|
- e
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, success=None, e=None,):
|
|
self.success = success
|
|
self.e = e
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 0:
|
|
if ftype == TType.LIST:
|
|
self.success = []
|
|
(_etype580, _size577) = iprot.readListBegin()
|
|
for _i581 in range(_size577):
|
|
_elem582 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
|
|
self.success.append(_elem582)
|
|
iprot.readListEnd()
|
|
else:
|
|
iprot.skip(ftype)
|
|
elif fid == 1:
|
|
if ftype == TType.STRUCT:
|
|
self.e = TalkException()
|
|
self.e.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getGroupMemberMids_result')
|
|
if self.success is not None:
|
|
oprot.writeFieldBegin('success', TType.LIST, 0)
|
|
oprot.writeListBegin(TType.STRING, len(self.success))
|
|
for iter583 in self.success:
|
|
oprot.writeString(iter583.encode('utf-8') if sys.version_info[0] == 2 else iter583)
|
|
oprot.writeListEnd()
|
|
oprot.writeFieldEnd()
|
|
if self.e is not None:
|
|
oprot.writeFieldBegin('e', TType.STRUCT, 1)
|
|
self.e.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getGroupMemberMids_result)
|
|
getGroupMemberMids_result.thrift_spec = (
|
|
(0, TType.LIST, 'success', (TType.STRING, 'UTF8', False), None, ), # 0
|
|
(1, TType.STRUCT, 'e', [TalkException, None], None, ), # 1
|
|
)
|
|
|
|
|
|
class getGroupsForChannel_args(object):
|
|
"""
|
|
Attributes:
|
|
- groupIds
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, groupIds=None,):
|
|
self.groupIds = groupIds
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 1:
|
|
if ftype == TType.LIST:
|
|
self.groupIds = []
|
|
(_etype587, _size584) = iprot.readListBegin()
|
|
for _i588 in range(_size584):
|
|
_elem589 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
|
|
self.groupIds.append(_elem589)
|
|
iprot.readListEnd()
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getGroupsForChannel_args')
|
|
if self.groupIds is not None:
|
|
oprot.writeFieldBegin('groupIds', TType.LIST, 1)
|
|
oprot.writeListBegin(TType.STRING, len(self.groupIds))
|
|
for iter590 in self.groupIds:
|
|
oprot.writeString(iter590.encode('utf-8') if sys.version_info[0] == 2 else iter590)
|
|
oprot.writeListEnd()
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getGroupsForChannel_args)
|
|
getGroupsForChannel_args.thrift_spec = (
|
|
None, # 0
|
|
(1, TType.LIST, 'groupIds', (TType.STRING, 'UTF8', False), None, ), # 1
|
|
)
|
|
|
|
|
|
class getGroupsForChannel_result(object):
|
|
"""
|
|
Attributes:
|
|
- success
|
|
- e
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, success=None, e=None,):
|
|
self.success = success
|
|
self.e = e
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 0:
|
|
if ftype == TType.LIST:
|
|
self.success = []
|
|
(_etype594, _size591) = iprot.readListBegin()
|
|
for _i595 in range(_size591):
|
|
_elem596 = Group()
|
|
_elem596.read(iprot)
|
|
self.success.append(_elem596)
|
|
iprot.readListEnd()
|
|
else:
|
|
iprot.skip(ftype)
|
|
elif fid == 1:
|
|
if ftype == TType.STRUCT:
|
|
self.e = TalkException()
|
|
self.e.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getGroupsForChannel_result')
|
|
if self.success is not None:
|
|
oprot.writeFieldBegin('success', TType.LIST, 0)
|
|
oprot.writeListBegin(TType.STRUCT, len(self.success))
|
|
for iter597 in self.success:
|
|
iter597.write(oprot)
|
|
oprot.writeListEnd()
|
|
oprot.writeFieldEnd()
|
|
if self.e is not None:
|
|
oprot.writeFieldBegin('e', TType.STRUCT, 1)
|
|
self.e.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getGroupsForChannel_result)
|
|
getGroupsForChannel_result.thrift_spec = (
|
|
(0, TType.LIST, 'success', (TType.STRUCT, [Group, None], False), None, ), # 0
|
|
(1, TType.STRUCT, 'e', [TalkException, None], None, ), # 1
|
|
)
|
|
|
|
|
|
class getIdentityCredential_args(object):
|
|
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getIdentityCredential_args')
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getIdentityCredential_args)
|
|
getIdentityCredential_args.thrift_spec = (
|
|
)
|
|
|
|
|
|
class getIdentityCredential_result(object):
|
|
"""
|
|
Attributes:
|
|
- success
|
|
- e
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, success=None, e=None,):
|
|
self.success = success
|
|
self.e = e
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 0:
|
|
if ftype == TType.STRUCT:
|
|
self.success = IdentityCredential()
|
|
self.success.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
elif fid == 1:
|
|
if ftype == TType.STRUCT:
|
|
self.e = TalkException()
|
|
self.e.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getIdentityCredential_result')
|
|
if self.success is not None:
|
|
oprot.writeFieldBegin('success', TType.STRUCT, 0)
|
|
self.success.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
if self.e is not None:
|
|
oprot.writeFieldBegin('e', TType.STRUCT, 1)
|
|
self.e.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getIdentityCredential_result)
|
|
getIdentityCredential_result.thrift_spec = (
|
|
(0, TType.STRUCT, 'success', [IdentityCredential, None], None, ), # 0
|
|
(1, TType.STRUCT, 'e', [TalkException, None], None, ), # 1
|
|
)
|
|
|
|
|
|
class getJoinedGroupIdsForChannel_args(object):
|
|
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getJoinedGroupIdsForChannel_args')
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getJoinedGroupIdsForChannel_args)
|
|
getJoinedGroupIdsForChannel_args.thrift_spec = (
|
|
)
|
|
|
|
|
|
class getJoinedGroupIdsForChannel_result(object):
|
|
"""
|
|
Attributes:
|
|
- success
|
|
- e
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, success=None, e=None,):
|
|
self.success = success
|
|
self.e = e
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 0:
|
|
if ftype == TType.LIST:
|
|
self.success = []
|
|
(_etype601, _size598) = iprot.readListBegin()
|
|
for _i602 in range(_size598):
|
|
_elem603 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
|
|
self.success.append(_elem603)
|
|
iprot.readListEnd()
|
|
else:
|
|
iprot.skip(ftype)
|
|
elif fid == 1:
|
|
if ftype == TType.STRUCT:
|
|
self.e = TalkException()
|
|
self.e.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getJoinedGroupIdsForChannel_result')
|
|
if self.success is not None:
|
|
oprot.writeFieldBegin('success', TType.LIST, 0)
|
|
oprot.writeListBegin(TType.STRING, len(self.success))
|
|
for iter604 in self.success:
|
|
oprot.writeString(iter604.encode('utf-8') if sys.version_info[0] == 2 else iter604)
|
|
oprot.writeListEnd()
|
|
oprot.writeFieldEnd()
|
|
if self.e is not None:
|
|
oprot.writeFieldBegin('e', TType.STRUCT, 1)
|
|
self.e.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getJoinedGroupIdsForChannel_result)
|
|
getJoinedGroupIdsForChannel_result.thrift_spec = (
|
|
(0, TType.LIST, 'success', (TType.STRING, 'UTF8', False), None, ), # 0
|
|
(1, TType.STRUCT, 'e', [TalkException, None], None, ), # 1
|
|
)
|
|
|
|
|
|
class getMetaProfile_args(object):
|
|
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getMetaProfile_args')
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getMetaProfile_args)
|
|
getMetaProfile_args.thrift_spec = (
|
|
)
|
|
|
|
|
|
class getMetaProfile_result(object):
|
|
"""
|
|
Attributes:
|
|
- success
|
|
- e
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, success=None, e=None,):
|
|
self.success = success
|
|
self.e = e
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 0:
|
|
if ftype == TType.STRUCT:
|
|
self.success = MetaProfile()
|
|
self.success.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
elif fid == 1:
|
|
if ftype == TType.STRUCT:
|
|
self.e = TalkException()
|
|
self.e.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getMetaProfile_result')
|
|
if self.success is not None:
|
|
oprot.writeFieldBegin('success', TType.STRUCT, 0)
|
|
self.success.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
if self.e is not None:
|
|
oprot.writeFieldBegin('e', TType.STRUCT, 1)
|
|
self.e.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getMetaProfile_result)
|
|
getMetaProfile_result.thrift_spec = (
|
|
(0, TType.STRUCT, 'success', [MetaProfile, None], None, ), # 0
|
|
(1, TType.STRUCT, 'e', [TalkException, None], None, ), # 1
|
|
)
|
|
|
|
|
|
class getMid_args(object):
|
|
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getMid_args')
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getMid_args)
|
|
getMid_args.thrift_spec = (
|
|
)
|
|
|
|
|
|
class getMid_result(object):
|
|
"""
|
|
Attributes:
|
|
- success
|
|
- e
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, success=None, e=None,):
|
|
self.success = success
|
|
self.e = e
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 0:
|
|
if ftype == TType.STRING:
|
|
self.success = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
|
|
else:
|
|
iprot.skip(ftype)
|
|
elif fid == 1:
|
|
if ftype == TType.STRUCT:
|
|
self.e = TalkException()
|
|
self.e.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getMid_result')
|
|
if self.success is not None:
|
|
oprot.writeFieldBegin('success', TType.STRING, 0)
|
|
oprot.writeString(self.success.encode('utf-8') if sys.version_info[0] == 2 else self.success)
|
|
oprot.writeFieldEnd()
|
|
if self.e is not None:
|
|
oprot.writeFieldBegin('e', TType.STRUCT, 1)
|
|
self.e.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getMid_result)
|
|
getMid_result.thrift_spec = (
|
|
(0, TType.STRING, 'success', 'UTF8', None, ), # 0
|
|
(1, TType.STRUCT, 'e', [TalkException, None], None, ), # 1
|
|
)
|
|
|
|
|
|
class getPrimaryClientForChannel_args(object):
|
|
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getPrimaryClientForChannel_args')
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getPrimaryClientForChannel_args)
|
|
getPrimaryClientForChannel_args.thrift_spec = (
|
|
)
|
|
|
|
|
|
class getPrimaryClientForChannel_result(object):
|
|
"""
|
|
Attributes:
|
|
- success
|
|
- e
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, success=None, e=None,):
|
|
self.success = success
|
|
self.e = e
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 0:
|
|
if ftype == TType.STRUCT:
|
|
self.success = SimpleChannelClient()
|
|
self.success.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
elif fid == 1:
|
|
if ftype == TType.STRUCT:
|
|
self.e = TalkException()
|
|
self.e.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getPrimaryClientForChannel_result')
|
|
if self.success is not None:
|
|
oprot.writeFieldBegin('success', TType.STRUCT, 0)
|
|
self.success.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
if self.e is not None:
|
|
oprot.writeFieldBegin('e', TType.STRUCT, 1)
|
|
self.e.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getPrimaryClientForChannel_result)
|
|
getPrimaryClientForChannel_result.thrift_spec = (
|
|
(0, TType.STRUCT, 'success', [SimpleChannelClient, None], None, ), # 0
|
|
(1, TType.STRUCT, 'e', [TalkException, None], None, ), # 1
|
|
)
|
|
|
|
|
|
class getProfileForChannel_args(object):
|
|
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getProfileForChannel_args')
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getProfileForChannel_args)
|
|
getProfileForChannel_args.thrift_spec = (
|
|
)
|
|
|
|
|
|
class getProfileForChannel_result(object):
|
|
"""
|
|
Attributes:
|
|
- success
|
|
- e
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, success=None, e=None,):
|
|
self.success = success
|
|
self.e = e
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 0:
|
|
if ftype == TType.STRUCT:
|
|
self.success = Profile()
|
|
self.success.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
elif fid == 1:
|
|
if ftype == TType.STRUCT:
|
|
self.e = TalkException()
|
|
self.e.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getProfileForChannel_result')
|
|
if self.success is not None:
|
|
oprot.writeFieldBegin('success', TType.STRUCT, 0)
|
|
self.success.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
if self.e is not None:
|
|
oprot.writeFieldBegin('e', TType.STRUCT, 1)
|
|
self.e.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getProfileForChannel_result)
|
|
getProfileForChannel_result.thrift_spec = (
|
|
(0, TType.STRUCT, 'success', [Profile, None], None, ), # 0
|
|
(1, TType.STRUCT, 'e', [TalkException, None], None, ), # 1
|
|
)
|
|
|
|
|
|
class getSimpleChannelContacts_args(object):
|
|
"""
|
|
Attributes:
|
|
- ids
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, ids=None,):
|
|
self.ids = ids
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 1:
|
|
if ftype == TType.LIST:
|
|
self.ids = []
|
|
(_etype608, _size605) = iprot.readListBegin()
|
|
for _i609 in range(_size605):
|
|
_elem610 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
|
|
self.ids.append(_elem610)
|
|
iprot.readListEnd()
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getSimpleChannelContacts_args')
|
|
if self.ids is not None:
|
|
oprot.writeFieldBegin('ids', TType.LIST, 1)
|
|
oprot.writeListBegin(TType.STRING, len(self.ids))
|
|
for iter611 in self.ids:
|
|
oprot.writeString(iter611.encode('utf-8') if sys.version_info[0] == 2 else iter611)
|
|
oprot.writeListEnd()
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getSimpleChannelContacts_args)
|
|
getSimpleChannelContacts_args.thrift_spec = (
|
|
None, # 0
|
|
(1, TType.LIST, 'ids', (TType.STRING, 'UTF8', False), None, ), # 1
|
|
)
|
|
|
|
|
|
class getSimpleChannelContacts_result(object):
|
|
"""
|
|
Attributes:
|
|
- success
|
|
- e
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, success=None, e=None,):
|
|
self.success = success
|
|
self.e = e
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 0:
|
|
if ftype == TType.LIST:
|
|
self.success = []
|
|
(_etype615, _size612) = iprot.readListBegin()
|
|
for _i616 in range(_size612):
|
|
_elem617 = SimpleChannelContact()
|
|
_elem617.read(iprot)
|
|
self.success.append(_elem617)
|
|
iprot.readListEnd()
|
|
else:
|
|
iprot.skip(ftype)
|
|
elif fid == 1:
|
|
if ftype == TType.STRUCT:
|
|
self.e = TalkException()
|
|
self.e.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getSimpleChannelContacts_result')
|
|
if self.success is not None:
|
|
oprot.writeFieldBegin('success', TType.LIST, 0)
|
|
oprot.writeListBegin(TType.STRUCT, len(self.success))
|
|
for iter618 in self.success:
|
|
iter618.write(oprot)
|
|
oprot.writeListEnd()
|
|
oprot.writeFieldEnd()
|
|
if self.e is not None:
|
|
oprot.writeFieldBegin('e', TType.STRUCT, 1)
|
|
self.e.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getSimpleChannelContacts_result)
|
|
getSimpleChannelContacts_result.thrift_spec = (
|
|
(0, TType.LIST, 'success', (TType.STRUCT, [SimpleChannelContact, None], False), None, ), # 0
|
|
(1, TType.STRUCT, 'e', [TalkException, None], None, ), # 1
|
|
)
|
|
|
|
|
|
class getUserCountryForBilling_args(object):
|
|
"""
|
|
Attributes:
|
|
- country
|
|
- remoteIp
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, country=None, remoteIp=None,):
|
|
self.country = country
|
|
self.remoteIp = remoteIp
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 2:
|
|
if ftype == TType.STRING:
|
|
self.country = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
|
|
else:
|
|
iprot.skip(ftype)
|
|
elif fid == 3:
|
|
if ftype == TType.STRING:
|
|
self.remoteIp = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getUserCountryForBilling_args')
|
|
if self.country is not None:
|
|
oprot.writeFieldBegin('country', TType.STRING, 2)
|
|
oprot.writeString(self.country.encode('utf-8') if sys.version_info[0] == 2 else self.country)
|
|
oprot.writeFieldEnd()
|
|
if self.remoteIp is not None:
|
|
oprot.writeFieldBegin('remoteIp', TType.STRING, 3)
|
|
oprot.writeString(self.remoteIp.encode('utf-8') if sys.version_info[0] == 2 else self.remoteIp)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getUserCountryForBilling_args)
|
|
getUserCountryForBilling_args.thrift_spec = (
|
|
None, # 0
|
|
None, # 1
|
|
(2, TType.STRING, 'country', 'UTF8', None, ), # 2
|
|
(3, TType.STRING, 'remoteIp', 'UTF8', None, ), # 3
|
|
)
|
|
|
|
|
|
class getUserCountryForBilling_result(object):
|
|
"""
|
|
Attributes:
|
|
- success
|
|
- e
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, success=None, e=None,):
|
|
self.success = success
|
|
self.e = e
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 0:
|
|
if ftype == TType.STRING:
|
|
self.success = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
|
|
else:
|
|
iprot.skip(ftype)
|
|
elif fid == 1:
|
|
if ftype == TType.STRUCT:
|
|
self.e = TalkException()
|
|
self.e.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getUserCountryForBilling_result')
|
|
if self.success is not None:
|
|
oprot.writeFieldBegin('success', TType.STRING, 0)
|
|
oprot.writeString(self.success.encode('utf-8') if sys.version_info[0] == 2 else self.success)
|
|
oprot.writeFieldEnd()
|
|
if self.e is not None:
|
|
oprot.writeFieldBegin('e', TType.STRUCT, 1)
|
|
self.e.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getUserCountryForBilling_result)
|
|
getUserCountryForBilling_result.thrift_spec = (
|
|
(0, TType.STRING, 'success', 'UTF8', None, ), # 0
|
|
(1, TType.STRUCT, 'e', [TalkException, None], None, ), # 1
|
|
)
|
|
|
|
|
|
class getUserCreateTime_args(object):
|
|
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getUserCreateTime_args')
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getUserCreateTime_args)
|
|
getUserCreateTime_args.thrift_spec = (
|
|
)
|
|
|
|
|
|
class getUserCreateTime_result(object):
|
|
"""
|
|
Attributes:
|
|
- success
|
|
- e
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, success=None, e=None,):
|
|
self.success = success
|
|
self.e = e
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 0:
|
|
if ftype == TType.I64:
|
|
self.success = iprot.readI64()
|
|
else:
|
|
iprot.skip(ftype)
|
|
elif fid == 1:
|
|
if ftype == TType.STRUCT:
|
|
self.e = TalkException()
|
|
self.e.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getUserCreateTime_result')
|
|
if self.success is not None:
|
|
oprot.writeFieldBegin('success', TType.I64, 0)
|
|
oprot.writeI64(self.success)
|
|
oprot.writeFieldEnd()
|
|
if self.e is not None:
|
|
oprot.writeFieldBegin('e', TType.STRUCT, 1)
|
|
self.e.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getUserCreateTime_result)
|
|
getUserCreateTime_result.thrift_spec = (
|
|
(0, TType.I64, 'success', None, None, ), # 0
|
|
(1, TType.STRUCT, 'e', [TalkException, None], None, ), # 1
|
|
)
|
|
|
|
|
|
class getUserIdentities_args(object):
|
|
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getUserIdentities_args')
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getUserIdentities_args)
|
|
getUserIdentities_args.thrift_spec = (
|
|
)
|
|
|
|
|
|
class getUserIdentities_result(object):
|
|
"""
|
|
Attributes:
|
|
- success
|
|
- e
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, success=None, e=None,):
|
|
self.success = success
|
|
self.e = e
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 0:
|
|
if ftype == TType.MAP:
|
|
self.success = {}
|
|
(_ktype620, _vtype621, _size619) = iprot.readMapBegin()
|
|
for _i623 in range(_size619):
|
|
_key624 = iprot.readI32()
|
|
_val625 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
|
|
self.success[_key624] = _val625
|
|
iprot.readMapEnd()
|
|
else:
|
|
iprot.skip(ftype)
|
|
elif fid == 1:
|
|
if ftype == TType.STRUCT:
|
|
self.e = TalkException()
|
|
self.e.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getUserIdentities_result')
|
|
if self.success is not None:
|
|
oprot.writeFieldBegin('success', TType.MAP, 0)
|
|
oprot.writeMapBegin(TType.I32, TType.STRING, len(self.success))
|
|
for kiter626, viter627 in self.success.items():
|
|
oprot.writeI32(kiter626)
|
|
oprot.writeString(viter627.encode('utf-8') if sys.version_info[0] == 2 else viter627)
|
|
oprot.writeMapEnd()
|
|
oprot.writeFieldEnd()
|
|
if self.e is not None:
|
|
oprot.writeFieldBegin('e', TType.STRUCT, 1)
|
|
self.e.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getUserIdentities_result)
|
|
getUserIdentities_result.thrift_spec = (
|
|
(0, TType.MAP, 'success', (TType.I32, None, TType.STRING, 'UTF8', False), None, ), # 0
|
|
(1, TType.STRUCT, 'e', [TalkException, None], None, ), # 1
|
|
)
|
|
|
|
|
|
class getUserLanguage_args(object):
|
|
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getUserLanguage_args')
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getUserLanguage_args)
|
|
getUserLanguage_args.thrift_spec = (
|
|
)
|
|
|
|
|
|
class getUserLanguage_result(object):
|
|
"""
|
|
Attributes:
|
|
- success
|
|
- e
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, success=None, e=None,):
|
|
self.success = success
|
|
self.e = e
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 0:
|
|
if ftype == TType.STRING:
|
|
self.success = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
|
|
else:
|
|
iprot.skip(ftype)
|
|
elif fid == 1:
|
|
if ftype == TType.STRUCT:
|
|
self.e = TalkException()
|
|
self.e.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getUserLanguage_result')
|
|
if self.success is not None:
|
|
oprot.writeFieldBegin('success', TType.STRING, 0)
|
|
oprot.writeString(self.success.encode('utf-8') if sys.version_info[0] == 2 else self.success)
|
|
oprot.writeFieldEnd()
|
|
if self.e is not None:
|
|
oprot.writeFieldBegin('e', TType.STRUCT, 1)
|
|
self.e.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getUserLanguage_result)
|
|
getUserLanguage_result.thrift_spec = (
|
|
(0, TType.STRING, 'success', 'UTF8', None, ), # 0
|
|
(1, TType.STRUCT, 'e', [TalkException, None], None, ), # 1
|
|
)
|
|
|
|
|
|
class getUserMidsWhoAddedMe_args(object):
|
|
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getUserMidsWhoAddedMe_args')
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getUserMidsWhoAddedMe_args)
|
|
getUserMidsWhoAddedMe_args.thrift_spec = (
|
|
)
|
|
|
|
|
|
class getUserMidsWhoAddedMe_result(object):
|
|
"""
|
|
Attributes:
|
|
- success
|
|
- e
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, success=None, e=None,):
|
|
self.success = success
|
|
self.e = e
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 0:
|
|
if ftype == TType.LIST:
|
|
self.success = []
|
|
(_etype631, _size628) = iprot.readListBegin()
|
|
for _i632 in range(_size628):
|
|
_elem633 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
|
|
self.success.append(_elem633)
|
|
iprot.readListEnd()
|
|
else:
|
|
iprot.skip(ftype)
|
|
elif fid == 1:
|
|
if ftype == TType.STRUCT:
|
|
self.e = TalkException()
|
|
self.e.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('getUserMidsWhoAddedMe_result')
|
|
if self.success is not None:
|
|
oprot.writeFieldBegin('success', TType.LIST, 0)
|
|
oprot.writeListBegin(TType.STRING, len(self.success))
|
|
for iter634 in self.success:
|
|
oprot.writeString(iter634.encode('utf-8') if sys.version_info[0] == 2 else iter634)
|
|
oprot.writeListEnd()
|
|
oprot.writeFieldEnd()
|
|
if self.e is not None:
|
|
oprot.writeFieldBegin('e', TType.STRUCT, 1)
|
|
self.e.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(getUserMidsWhoAddedMe_result)
|
|
getUserMidsWhoAddedMe_result.thrift_spec = (
|
|
(0, TType.LIST, 'success', (TType.STRING, 'UTF8', False), None, ), # 0
|
|
(1, TType.STRUCT, 'e', [TalkException, None], None, ), # 1
|
|
)
|
|
|
|
|
|
class isGroupMember_args(object):
|
|
"""
|
|
Attributes:
|
|
- groupId
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, groupId=None,):
|
|
self.groupId = groupId
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 1:
|
|
if ftype == TType.STRING:
|
|
self.groupId = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('isGroupMember_args')
|
|
if self.groupId is not None:
|
|
oprot.writeFieldBegin('groupId', TType.STRING, 1)
|
|
oprot.writeString(self.groupId.encode('utf-8') if sys.version_info[0] == 2 else self.groupId)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(isGroupMember_args)
|
|
isGroupMember_args.thrift_spec = (
|
|
None, # 0
|
|
(1, TType.STRING, 'groupId', 'UTF8', None, ), # 1
|
|
)
|
|
|
|
|
|
class isGroupMember_result(object):
|
|
"""
|
|
Attributes:
|
|
- success
|
|
- e
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, success=None, e=None,):
|
|
self.success = success
|
|
self.e = e
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 0:
|
|
if ftype == TType.BOOL:
|
|
self.success = iprot.readBool()
|
|
else:
|
|
iprot.skip(ftype)
|
|
elif fid == 1:
|
|
if ftype == TType.STRUCT:
|
|
self.e = TalkException()
|
|
self.e.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('isGroupMember_result')
|
|
if self.success is not None:
|
|
oprot.writeFieldBegin('success', TType.BOOL, 0)
|
|
oprot.writeBool(self.success)
|
|
oprot.writeFieldEnd()
|
|
if self.e is not None:
|
|
oprot.writeFieldBegin('e', TType.STRUCT, 1)
|
|
self.e.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(isGroupMember_result)
|
|
isGroupMember_result.thrift_spec = (
|
|
(0, TType.BOOL, 'success', None, None, ), # 0
|
|
(1, TType.STRUCT, 'e', [TalkException, None], None, ), # 1
|
|
)
|
|
|
|
|
|
class isInContact_args(object):
|
|
"""
|
|
Attributes:
|
|
- mid
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, mid=None,):
|
|
self.mid = mid
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 2:
|
|
if ftype == TType.STRING:
|
|
self.mid = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('isInContact_args')
|
|
if self.mid is not None:
|
|
oprot.writeFieldBegin('mid', TType.STRING, 2)
|
|
oprot.writeString(self.mid.encode('utf-8') if sys.version_info[0] == 2 else self.mid)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(isInContact_args)
|
|
isInContact_args.thrift_spec = (
|
|
None, # 0
|
|
None, # 1
|
|
(2, TType.STRING, 'mid', 'UTF8', None, ), # 2
|
|
)
|
|
|
|
|
|
class isInContact_result(object):
|
|
"""
|
|
Attributes:
|
|
- success
|
|
- e
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, success=None, e=None,):
|
|
self.success = success
|
|
self.e = e
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 0:
|
|
if ftype == TType.BOOL:
|
|
self.success = iprot.readBool()
|
|
else:
|
|
iprot.skip(ftype)
|
|
elif fid == 1:
|
|
if ftype == TType.STRUCT:
|
|
self.e = TalkException()
|
|
self.e.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('isInContact_result')
|
|
if self.success is not None:
|
|
oprot.writeFieldBegin('success', TType.BOOL, 0)
|
|
oprot.writeBool(self.success)
|
|
oprot.writeFieldEnd()
|
|
if self.e is not None:
|
|
oprot.writeFieldBegin('e', TType.STRUCT, 1)
|
|
self.e.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(isInContact_result)
|
|
isInContact_result.thrift_spec = (
|
|
(0, TType.BOOL, 'success', None, None, ), # 0
|
|
(1, TType.STRUCT, 'e', [TalkException, None], None, ), # 1
|
|
)
|
|
|
|
|
|
class registerChannelCP_args(object):
|
|
"""
|
|
Attributes:
|
|
- cpId
|
|
- registerPassword
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, cpId=None, registerPassword=None,):
|
|
self.cpId = cpId
|
|
self.registerPassword = registerPassword
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 2:
|
|
if ftype == TType.STRING:
|
|
self.cpId = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
|
|
else:
|
|
iprot.skip(ftype)
|
|
elif fid == 3:
|
|
if ftype == TType.STRING:
|
|
self.registerPassword = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('registerChannelCP_args')
|
|
if self.cpId is not None:
|
|
oprot.writeFieldBegin('cpId', TType.STRING, 2)
|
|
oprot.writeString(self.cpId.encode('utf-8') if sys.version_info[0] == 2 else self.cpId)
|
|
oprot.writeFieldEnd()
|
|
if self.registerPassword is not None:
|
|
oprot.writeFieldBegin('registerPassword', TType.STRING, 3)
|
|
oprot.writeString(self.registerPassword.encode('utf-8') if sys.version_info[0] == 2 else self.registerPassword)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(registerChannelCP_args)
|
|
registerChannelCP_args.thrift_spec = (
|
|
None, # 0
|
|
None, # 1
|
|
(2, TType.STRING, 'cpId', 'UTF8', None, ), # 2
|
|
(3, TType.STRING, 'registerPassword', 'UTF8', None, ), # 3
|
|
)
|
|
|
|
|
|
class registerChannelCP_result(object):
|
|
"""
|
|
Attributes:
|
|
- success
|
|
- e
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, success=None, e=None,):
|
|
self.success = success
|
|
self.e = e
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 0:
|
|
if ftype == TType.STRING:
|
|
self.success = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
|
|
else:
|
|
iprot.skip(ftype)
|
|
elif fid == 1:
|
|
if ftype == TType.STRUCT:
|
|
self.e = TalkException()
|
|
self.e.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('registerChannelCP_result')
|
|
if self.success is not None:
|
|
oprot.writeFieldBegin('success', TType.STRING, 0)
|
|
oprot.writeString(self.success.encode('utf-8') if sys.version_info[0] == 2 else self.success)
|
|
oprot.writeFieldEnd()
|
|
if self.e is not None:
|
|
oprot.writeFieldBegin('e', TType.STRUCT, 1)
|
|
self.e.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(registerChannelCP_result)
|
|
registerChannelCP_result.thrift_spec = (
|
|
(0, TType.STRING, 'success', 'UTF8', None, ), # 0
|
|
(1, TType.STRUCT, 'e', [TalkException, None], None, ), # 1
|
|
)
|
|
|
|
|
|
class removeNotificationStatus_args(object):
|
|
"""
|
|
Attributes:
|
|
- notificationStatus
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, notificationStatus=None,):
|
|
self.notificationStatus = notificationStatus
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 2:
|
|
if ftype == TType.I32:
|
|
self.notificationStatus = iprot.readI32()
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('removeNotificationStatus_args')
|
|
if self.notificationStatus is not None:
|
|
oprot.writeFieldBegin('notificationStatus', TType.I32, 2)
|
|
oprot.writeI32(self.notificationStatus)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(removeNotificationStatus_args)
|
|
removeNotificationStatus_args.thrift_spec = (
|
|
None, # 0
|
|
None, # 1
|
|
(2, TType.I32, 'notificationStatus', None, None, ), # 2
|
|
)
|
|
|
|
|
|
class removeNotificationStatus_result(object):
|
|
"""
|
|
Attributes:
|
|
- e
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, e=None,):
|
|
self.e = e
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 1:
|
|
if ftype == TType.STRUCT:
|
|
self.e = TalkException()
|
|
self.e.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('removeNotificationStatus_result')
|
|
if self.e is not None:
|
|
oprot.writeFieldBegin('e', TType.STRUCT, 1)
|
|
self.e.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(removeNotificationStatus_result)
|
|
removeNotificationStatus_result.thrift_spec = (
|
|
None, # 0
|
|
(1, TType.STRUCT, 'e', [TalkException, None], None, ), # 1
|
|
)
|
|
|
|
|
|
class sendMessageForChannel_args(object):
|
|
"""
|
|
Attributes:
|
|
- message
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, message=None,):
|
|
self.message = message
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 2:
|
|
if ftype == TType.STRUCT:
|
|
self.message = Message()
|
|
self.message.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('sendMessageForChannel_args')
|
|
if self.message is not None:
|
|
oprot.writeFieldBegin('message', TType.STRUCT, 2)
|
|
self.message.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(sendMessageForChannel_args)
|
|
sendMessageForChannel_args.thrift_spec = (
|
|
None, # 0
|
|
None, # 1
|
|
(2, TType.STRUCT, 'message', [Message, None], None, ), # 2
|
|
)
|
|
|
|
|
|
class sendMessageForChannel_result(object):
|
|
"""
|
|
Attributes:
|
|
- success
|
|
- e
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, success=None, e=None,):
|
|
self.success = success
|
|
self.e = e
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 0:
|
|
if ftype == TType.STRUCT:
|
|
self.success = Message()
|
|
self.success.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
elif fid == 1:
|
|
if ftype == TType.STRUCT:
|
|
self.e = TalkException()
|
|
self.e.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('sendMessageForChannel_result')
|
|
if self.success is not None:
|
|
oprot.writeFieldBegin('success', TType.STRUCT, 0)
|
|
self.success.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
if self.e is not None:
|
|
oprot.writeFieldBegin('e', TType.STRUCT, 1)
|
|
self.e.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(sendMessageForChannel_result)
|
|
sendMessageForChannel_result.thrift_spec = (
|
|
(0, TType.STRUCT, 'success', [Message, None], None, ), # 0
|
|
(1, TType.STRUCT, 'e', [TalkException, None], None, ), # 1
|
|
)
|
|
|
|
|
|
class sendPinCodeOperation_args(object):
|
|
"""
|
|
Attributes:
|
|
- verifier
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, verifier=None,):
|
|
self.verifier = verifier
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 1:
|
|
if ftype == TType.STRING:
|
|
self.verifier = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('sendPinCodeOperation_args')
|
|
if self.verifier is not None:
|
|
oprot.writeFieldBegin('verifier', TType.STRING, 1)
|
|
oprot.writeString(self.verifier.encode('utf-8') if sys.version_info[0] == 2 else self.verifier)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(sendPinCodeOperation_args)
|
|
sendPinCodeOperation_args.thrift_spec = (
|
|
None, # 0
|
|
(1, TType.STRING, 'verifier', 'UTF8', None, ), # 1
|
|
)
|
|
|
|
|
|
class sendPinCodeOperation_result(object):
|
|
"""
|
|
Attributes:
|
|
- e
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, e=None,):
|
|
self.e = e
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 1:
|
|
if ftype == TType.STRUCT:
|
|
self.e = TalkException()
|
|
self.e.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('sendPinCodeOperation_result')
|
|
if self.e is not None:
|
|
oprot.writeFieldBegin('e', TType.STRUCT, 1)
|
|
self.e.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(sendPinCodeOperation_result)
|
|
sendPinCodeOperation_result.thrift_spec = (
|
|
None, # 0
|
|
(1, TType.STRUCT, 'e', [TalkException, None], None, ), # 1
|
|
)
|
|
|
|
|
|
class updateProfileAttributeForChannel_args(object):
|
|
"""
|
|
Attributes:
|
|
- profileAttribute
|
|
- value
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, profileAttribute=None, value=None,):
|
|
self.profileAttribute = profileAttribute
|
|
self.value = value
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 2:
|
|
if ftype == TType.I32:
|
|
self.profileAttribute = iprot.readI32()
|
|
else:
|
|
iprot.skip(ftype)
|
|
elif fid == 3:
|
|
if ftype == TType.STRING:
|
|
self.value = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('updateProfileAttributeForChannel_args')
|
|
if self.profileAttribute is not None:
|
|
oprot.writeFieldBegin('profileAttribute', TType.I32, 2)
|
|
oprot.writeI32(self.profileAttribute)
|
|
oprot.writeFieldEnd()
|
|
if self.value is not None:
|
|
oprot.writeFieldBegin('value', TType.STRING, 3)
|
|
oprot.writeString(self.value.encode('utf-8') if sys.version_info[0] == 2 else self.value)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(updateProfileAttributeForChannel_args)
|
|
updateProfileAttributeForChannel_args.thrift_spec = (
|
|
None, # 0
|
|
None, # 1
|
|
(2, TType.I32, 'profileAttribute', None, None, ), # 2
|
|
(3, TType.STRING, 'value', 'UTF8', None, ), # 3
|
|
)
|
|
|
|
|
|
class updateProfileAttributeForChannel_result(object):
|
|
"""
|
|
Attributes:
|
|
- e
|
|
|
|
"""
|
|
|
|
|
|
def __init__(self, e=None,):
|
|
self.e = e
|
|
|
|
def read(self, iprot):
|
|
if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
|
|
iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
|
|
return
|
|
iprot.readStructBegin()
|
|
while True:
|
|
(fname, ftype, fid) = iprot.readFieldBegin()
|
|
if ftype == TType.STOP:
|
|
break
|
|
if fid == 1:
|
|
if ftype == TType.STRUCT:
|
|
self.e = TalkException()
|
|
self.e.read(iprot)
|
|
else:
|
|
iprot.skip(ftype)
|
|
else:
|
|
iprot.skip(ftype)
|
|
iprot.readFieldEnd()
|
|
iprot.readStructEnd()
|
|
|
|
def write(self, oprot):
|
|
if oprot._fast_encode is not None and self.thrift_spec is not None:
|
|
oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
|
|
return
|
|
oprot.writeStructBegin('updateProfileAttributeForChannel_result')
|
|
if self.e is not None:
|
|
oprot.writeFieldBegin('e', TType.STRUCT, 1)
|
|
self.e.write(oprot)
|
|
oprot.writeFieldEnd()
|
|
oprot.writeFieldStop()
|
|
oprot.writeStructEnd()
|
|
|
|
def validate(self):
|
|
return
|
|
|
|
def __repr__(self):
|
|
L = ['%s=%r' % (key, value)
|
|
for key, value in self.__dict__.items()]
|
|
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
|
|
|
|
def __eq__(self, other):
|
|
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
|
|
|
|
def __ne__(self, other):
|
|
return not (self == other)
|
|
all_structs.append(updateProfileAttributeForChannel_result)
|
|
updateProfileAttributeForChannel_result.thrift_spec = (
|
|
None, # 0
|
|
(1, TType.STRUCT, 'e', [TalkException, None], None, ), # 1
|
|
)
|
|
fix_spec(all_structs)
|
|
del all_structs
|
|
|