import json
from enum import Enum
from typing import NewType, Tuple
class RsGxsForumGroup:
"""
RsGxsForumGroup
"""
def __init__(self, mMeta = None, mDescription = None, mAdminList = None, mPinnedPosts = None):
"""
:param mMeta: (RsGroupMetaData)
:param mDescription: (str)
:param mAdminList: (RsTlvGxsIdSet)
:param mPinnedPosts: (RsTlvGxsMsgIdSet)
:type mMeta: RsGroupMetaData
:type mDescription: str
:type mAdminList: RsTlvGxsIdSet
:type mPinnedPosts: RsTlvGxsMsgIdSet
"""
self.mMeta = mMeta
self.mDescription = mDescription
self.mAdminList = mAdminList
self.mPinnedPosts = mPinnedPosts
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
class RsGxsForumMsg:
"""
RsGxsForumMsg
"""
def __init__(self, mMeta = None, mMsg = None):
"""
:param mMeta: (RsMsgMetaData)
:param mMsg: (str)
:type mMeta: RsMsgMetaData
:type mMsg: str
"""
self.mMeta = mMeta
self.mMsg = mMsg
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
RsGxsGroupId = NewType('RsGxsGroupId', str)
RsGxsMessageId = NewType('RsGxsMessageId', str)
class RsMsgMetaData:
"""
RsMsgMetaData
"""
def __init__(self, mGroupId = None, mMsgId = None, mThreadId = None, mParentId = None, mOrigMsgId = None, mAuthorId = None, mMsgName = None, mPublishTs = None, mMsgFlags = None, mMsgStatus = None, mChildTs = None, mServiceString = None):
"""
:param mGroupId: (RsGxsGroupId)
:param mMsgId: (RsGxsMessageId)
:param mThreadId: (RsGxsMessageId)
:param mParentId: (RsGxsMessageId)
:param mOrigMsgId: (RsGxsMessageId)
:param mAuthorId: (RsGxsId)
:param mMsgName: (str)
:param mPublishTs: (rstime_t)
:param mMsgFlags: (int)
:param mMsgStatus: (int)
:param mChildTs: (rstime_t)
:param mServiceString: (str)
:type mGroupId: RsGxsGroupId
:type mMsgId: RsGxsMessageId
:type mThreadId: RsGxsMessageId
:type mParentId: RsGxsMessageId
:type mOrigMsgId: RsGxsMessageId
:type mAuthorId: RsGxsId
:type mMsgName: str
:type mPublishTs: rstime_t
:type mMsgFlags: int
:type mMsgStatus: int
:type mChildTs: rstime_t
:type mServiceString: str
"""
self.mGroupId = mGroupId
self.mMsgId = mMsgId
self.mThreadId = mThreadId
self.mParentId = mParentId
self.mOrigMsgId = mOrigMsgId
self.mAuthorId = mAuthorId
self.mMsgName = mMsgName
self.mPublishTs = mPublishTs
self.mMsgFlags = mMsgFlags
self.mMsgStatus = mMsgStatus
self.mChildTs = mChildTs
self.mServiceString = mServiceString
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
class RsGroupMetaData:
"""
RsGroupMetaData
"""
def __init__(self, mGroupId = None, mGroupName = None, mGroupFlags = None, mSignFlags = None, mPublishTs = None, mAuthorId = None, mCircleId = None, mCircleType = None, mAuthenFlags = None, mParentGrpId = None, mSubscribeFlags = None, mPop = None, mVisibleMsgCount = None, mLastPost = None, mGroupStatus = None, mServiceString = None, mOriginator = None, mInternalCircle = None):
"""
:param mGroupId: (RsGxsGroupId)
:param mGroupName: (str)
:param mGroupFlags: (int)
:param mSignFlags: (int)
:param mPublishTs: (rstime_t)
:param mAuthorId: (RsGxsId)
:param mCircleId: (RsGxsCircleId)
:param mCircleType: (int)
:param mAuthenFlags: (int)
:param mParentGrpId: (RsGxsGroupId)
:param mSubscribeFlags: (int)
:param mPop: (int)
:param mVisibleMsgCount: (int)
:param mLastPost: (rstime_t)
:param mGroupStatus: (int)
:param mServiceString: (str)
:param mOriginator: (RsPeerId)
:param mInternalCircle: (RsGxsCircleId)
:type mGroupId: RsGxsGroupId
:type mGroupName: str
:type mGroupFlags: int
:type mSignFlags: int
:type mPublishTs: rstime_t
:type mAuthorId: RsGxsId
:type mCircleId: RsGxsCircleId
:type mCircleType: int
:type mAuthenFlags: int
:type mParentGrpId: RsGxsGroupId
:type mSubscribeFlags: int
:type mPop: int
:type mVisibleMsgCount: int
:type mLastPost: rstime_t
:type mGroupStatus: int
:type mServiceString: str
:type mOriginator: RsPeerId
:type mInternalCircle: RsGxsCircleId
"""
self.mGroupId = mGroupId
self.mGroupName = mGroupName
self.mGroupFlags = mGroupFlags
self.mSignFlags = mSignFlags
self.mPublishTs = mPublishTs
self.mAuthorId = mAuthorId
self.mCircleId = mCircleId
self.mCircleType = mCircleType
self.mAuthenFlags = mAuthenFlags
self.mParentGrpId = mParentGrpId
self.mSubscribeFlags = mSubscribeFlags
self.mPop = mPop
self.mVisibleMsgCount = mVisibleMsgCount
self.mLastPost = mLastPost
self.mGroupStatus = mGroupStatus
self.mServiceString = mServiceString
self.mOriginator = mOriginator
self.mInternalCircle = mInternalCircle
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
RsGxsGrpMsgIdPair = Tuple[RsGxsGroupId,RsGxsMessageId]
RsPgpId = NewType('RsPgpId', str)
RsGxsId = NewType('RsGxsId', str)
class RsOpinion(Enum):
"""
RsOpinion
"""
NEGATIVE= 0
NEUTRAL= 1
POSITIVE= 2
class RsReputationInfo:
"""
RsReputationInfo
"""
def __init__(self, mOwnOpinion = None, mFriendsPositiveVotes = None, mFriendsNegativeVotes = None, mFriendAverageScore = None, mOverallReputationLevel = None):
"""
:param mOwnOpinion: (RsOpinion)
:param mFriendsPositiveVotes: (int)
:param mFriendsNegativeVotes: (int)
:param mFriendAverageScore: (float)
:param mOverallReputationLevel: (RsReputationLevel)
:type mOwnOpinion: RsOpinion
:type mFriendsPositiveVotes: int
:type mFriendsNegativeVotes: int
:type mFriendAverageScore: float
:type mOverallReputationLevel: RsReputationLevel
"""
self.mOwnOpinion = mOwnOpinion
self.mFriendsPositiveVotes = mFriendsPositiveVotes
self.mFriendsNegativeVotes = mFriendsNegativeVotes
self.mFriendAverageScore = mFriendAverageScore
self.mOverallReputationLevel = mOverallReputationLevel
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
class RsPeerServiceInfo:
"""
RsPeerServiceInfo
"""
def __init__(self, mPeerId = None, mServiceList = None):
"""
:param mPeerId: (RsPeerId)
:param mServiceList: (map< uint32_t, RsServiceInfo >)
:type mPeerId: RsPeerId
:type mServiceList: map< uint32_t, RsServiceInfo >
"""
self.mPeerId = mPeerId
self.mServiceList = mServiceList
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
RsPeerId = NewType('RsPeerId', str)
class RsServicePermissions:
"""
RsServicePermissions
"""
def __init__(self, mServiceId = None, mServiceName = None, mDefaultAllowed = None, mPeersAllowed = None, mPeersDenied = None):
"""
:param mServiceId: (int)
:param mServiceName: (str)
:param mDefaultAllowed: (bool)
:param mPeersAllowed: (set< RsPeerId >)
:param mPeersDenied: (set< RsPeerId >)
:type mServiceId: int
:type mServiceName: str
:type mDefaultAllowed: bool
:type mPeersAllowed: set< RsPeerId >
:type mPeersDenied: set< RsPeerId >
"""
self.mServiceId = mServiceId
self.mServiceName = mServiceName
self.mDefaultAllowed = mDefaultAllowed
self.mPeersAllowed = mPeersAllowed
self.mPeersDenied = mPeersDenied
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
class RsGxsImage:
"""
RsGxsImage
"""
def __init__(self, mSize = None, mData = None):
"""
:param mSize: (int)
:param mData: (uint8_t *)
:type mSize: int
:type mData: uint8_t *
"""
self.mSize = mSize
self.mData = mData
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
class RsGxsIdGroup:
"""
RsGxsIdGroup
"""
def __init__(self, mMeta = None, mPgpIdHash = None, mPgpIdSign = None, mRecognTags = None, mImage = None, mLastUsageTS = None, mPgpKnown = None, mIsAContact = None, mPgpId = None, mReputation = None):
"""
:param mMeta: (RsGroupMetaData)
:param mPgpIdHash: (Sha1CheckSum)
:param mPgpIdSign: (str)
:param mRecognTags: (RS_DEPRECATED std_list< std_string >)
:param mImage: (RsGxsImage)
:param mLastUsageTS: (rstime_t)
:param mPgpKnown: (bool)
:param mIsAContact: (bool)
:param mPgpId: (RsPgpId)
:param mReputation: (GxsReputation)
:type mMeta: RsGroupMetaData
:type mPgpIdHash: Sha1CheckSum
:type mPgpIdSign: str
:type mRecognTags: RS_DEPRECATED std_list< std_string >
:type mImage: RsGxsImage
:type mLastUsageTS: rstime_t
:type mPgpKnown: bool
:type mIsAContact: bool
:type mPgpId: RsPgpId
:type mReputation: GxsReputation
"""
self.mMeta = mMeta
self.mPgpIdHash = mPgpIdHash
self.mPgpIdSign = mPgpIdSign
self.mRecognTags = mRecognTags
self.mImage = mImage
self.mLastUsageTS = mLastUsageTS
self.mPgpKnown = mPgpKnown
self.mIsAContact = mIsAContact
self.mPgpId = mPgpId
self.mReputation = mReputation
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
class RsEvent:
"""
RsEvent
"""
def __init__(self, mType = None, mTimePoint = None):
"""
:param mType: (RsEventType)
:param mTimePoint: (chrono_system_clock_time_point)
:type mType: RsEventType
:type mTimePoint: chrono_system_clock_time_point
"""
self.mType = mType
self.mTimePoint = mTimePoint
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
RsEventsHandlerId_t = NewType('RsEventsHandlerId_t', int)
ChatLobbyId = NewType('ChatLobbyId', int)
class ChatId:
"""
ChatId
"""
def __init__(self, broadcast_status_peer_id = None, type = None, peer_id = None, distant_chat_id = None, lobby_id = None):
"""
:param broadcast_status_peer_id: (RsPeerId)
:param type: (Type)
:param peer_id: (RsPeerId)
:param distant_chat_id: (DistantChatPeerId)
:param lobby_id: (ChatLobbyId)
:type broadcast_status_peer_id: RsPeerId
:type type: Type
:type peer_id: RsPeerId
:type distant_chat_id: DistantChatPeerId
:type lobby_id: ChatLobbyId
"""
self.broadcast_status_peer_id = broadcast_status_peer_id
self.type = type
self.peer_id = peer_id
self.distant_chat_id = distant_chat_id
self.lobby_id = lobby_id
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
ChatLobbyFlags = NewType('ChatLobbyFlags', int)
class ChatLobbyInfo:
"""
ChatLobbyInfo
"""
def __init__(self, lobby_id = None, lobby_name = None, lobby_topic = None, participating_friends = None, gxs_id = None, lobby_flags = None, gxs_ids = None, last_activity = None):
"""
:param lobby_id: (ChatLobbyId)
:param lobby_name: (str)
:param lobby_topic: (str)
:param participating_friends: (set< RsPeerId >)
:param gxs_id: (RsGxsId)
:param lobby_flags: (ChatLobbyFlags)
:param gxs_ids: (map< RsGxsId, rstime_t >)
:param last_activity: (rstime_t)
:type lobby_id: ChatLobbyId
:type lobby_name: str
:type lobby_topic: str
:type participating_friends: set< RsPeerId >
:type gxs_id: RsGxsId
:type lobby_flags: ChatLobbyFlags
:type gxs_ids: map< RsGxsId, rstime_t >
:type last_activity: rstime_t
"""
self.lobby_id = lobby_id
self.lobby_name = lobby_name
self.lobby_topic = lobby_topic
self.participating_friends = participating_friends
self.gxs_id = gxs_id
self.lobby_flags = lobby_flags
self.gxs_ids = gxs_ids
self.last_activity = last_activity
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
class VisibleChatLobbyRecord:
"""
VisibleChatLobbyRecord
"""
def __init__(self, lobby_id = None, lobby_name = None, lobby_topic = None, participating_friends = None, total_number_of_peers = None, last_report_time = None, lobby_flags = None):
"""
:param lobby_id: (ChatLobbyId)
:param lobby_name: (str)
:param lobby_topic: (str)
:param participating_friends: (set< RsPeerId >)
:param total_number_of_peers: (int)
:param last_report_time: (rstime_t)
:param lobby_flags: (ChatLobbyFlags)
:type lobby_id: ChatLobbyId
:type lobby_name: str
:type lobby_topic: str
:type participating_friends: set< RsPeerId >
:type total_number_of_peers: int
:type last_report_time: rstime_t
:type lobby_flags: ChatLobbyFlags
"""
self.lobby_id = lobby_id
self.lobby_name = lobby_name
self.lobby_topic = lobby_topic
self.participating_friends = participating_friends
self.total_number_of_peers = total_number_of_peers
self.last_report_time = last_report_time
self.lobby_flags = lobby_flags
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
class Rs_Msgs_MessageInfo:
"""
Rs_Msgs_MessageInfo
"""
def __init__(self, msgId = None, rspeerid_srcId = None, rsgxsid_srcId = None, msgflags = None, rspeerid_msgto = None, rspeerid_msgcc = None, rspeerid_msgbcc = None, rsgxsid_msgto = None, rsgxsid_msgcc = None, rsgxsid_msgbcc = None, title = None, msg = None, attach_title = None, attach_comment = None, files = None, size = None, count = None, ts = None):
"""
:param msgId: (str)
:param rspeerid_srcId: (RsPeerId)
:param rsgxsid_srcId: (RsGxsId)
:param msgflags: (unsigned int)
:param rspeerid_msgto: (set< RsPeerId >)
:param rspeerid_msgcc: (set< RsPeerId >)
:param rspeerid_msgbcc: (set< RsPeerId >)
:param rsgxsid_msgto: (set< RsGxsId >)
:param rsgxsid_msgcc: (set< RsGxsId >)
:param rsgxsid_msgbcc: (set< RsGxsId >)
:param title: (str)
:param msg: (str)
:param attach_title: (str)
:param attach_comment: (str)
:param files: (list< FileInfo >)
:param size: (int)
:param count: (int)
:param ts: (int)
:type msgId: str
:type rspeerid_srcId: RsPeerId
:type rsgxsid_srcId: RsGxsId
:type msgflags: unsigned int
:type rspeerid_msgto: set< RsPeerId >
:type rspeerid_msgcc: set< RsPeerId >
:type rspeerid_msgbcc: set< RsPeerId >
:type rsgxsid_msgto: set< RsGxsId >
:type rsgxsid_msgcc: set< RsGxsId >
:type rsgxsid_msgbcc: set< RsGxsId >
:type title: str
:type msg: str
:type attach_title: str
:type attach_comment: str
:type files: list< FileInfo >
:type size: int
:type count: int
:type ts: int
"""
self.msgId = msgId
self.rspeerid_srcId = rspeerid_srcId
self.rsgxsid_srcId = rsgxsid_srcId
self.msgflags = msgflags
self.rspeerid_msgto = rspeerid_msgto
self.rspeerid_msgcc = rspeerid_msgcc
self.rspeerid_msgbcc = rspeerid_msgbcc
self.rsgxsid_msgto = rsgxsid_msgto
self.rsgxsid_msgcc = rsgxsid_msgcc
self.rsgxsid_msgbcc = rsgxsid_msgbcc
self.title = title
self.msg = msg
self.attach_title = attach_title
self.attach_comment = attach_comment
self.files = files
self.size = size
self.count = count
self.ts = ts
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
class Rs_Msgs_MsgInfoSummary:
"""
Rs_Msgs_MsgInfoSummary
"""
def __init__(self, msgId = None, srcId = None, msgflags = None, msgtags = None, title = None, count = None, ts = None):
"""
:param msgId: (RsMailMessageId)
:param srcId: (RsPeerId)
:param msgflags: (int)
:param msgtags: (list< uint32_t >)
:param title: (str)
:param count: (int)
:param ts: (rstime_t)
:type msgId: RsMailMessageId
:type srcId: RsPeerId
:type msgflags: int
:type msgtags: list< uint32_t >
:type title: str
:type count: int
:type ts: rstime_t
"""
self.msgId = msgId
self.srcId = srcId
self.msgflags = msgflags
self.msgtags = msgtags
self.title = title
self.count = count
self.ts = ts
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
class Rs_Msgs_MsgTagInfo:
"""
Rs_Msgs_MsgTagInfo
"""
def __init__(self, msgId = None, tagIds = None):
"""
:param msgId: (str)
:param tagIds: (list< uint32_t >)
:type msgId: str
:type tagIds: list< uint32_t >
"""
self.msgId = msgId
self.tagIds = tagIds
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
class Rs_Msgs_MsgTagType:
"""
Rs_Msgs_MsgTagType
"""
def __init__(self, types = None):
"""
:param types: (map< uint32_t, std_pair< std_string, uint32_t > >)
:type types: map< uint32_t, std_pair< std_string, uint32_t > >
"""
self.types = types
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
class ChatLobbyInvite:
"""
ChatLobbyInvite
"""
def __init__(self, lobby_id = None, peer_id = None, lobby_name = None, lobby_topic = None, lobby_flags = None):
"""
:param lobby_id: (ChatLobbyId)
:param peer_id: (RsPeerId)
:param lobby_name: (str)
:param lobby_topic: (str)
:param lobby_flags: (ChatLobbyFlags)
:type lobby_id: ChatLobbyId
:type peer_id: RsPeerId
:type lobby_name: str
:type lobby_topic: str
:type lobby_flags: ChatLobbyFlags
"""
self.lobby_id = lobby_id
self.peer_id = peer_id
self.lobby_name = lobby_name
self.lobby_topic = lobby_topic
self.lobby_flags = lobby_flags
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
RsGxsCircleId = NewType('RsGxsCircleId', str)
class RsGxsCircleGroup:
"""
RsGxsCircleGroup
"""
def __init__(self, mMeta = None, mLocalFriends = None, mInvitedMembers = None, mSubCircles = None):
"""
:param mMeta: (RsGroupMetaData)
:param mLocalFriends: (set< RsPgpId >)
:param mInvitedMembers: (set< RsGxsId >)
:param mSubCircles: (set< RsGxsCircleId >)
:type mMeta: RsGroupMetaData
:type mLocalFriends: set< RsPgpId >
:type mInvitedMembers: set< RsGxsId >
:type mSubCircles: set< RsGxsCircleId >
"""
self.mMeta = mMeta
self.mLocalFriends = mLocalFriends
self.mInvitedMembers = mInvitedMembers
self.mSubCircles = mSubCircles
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
class RsGxsCircleDetails:
"""
RsGxsCircleDetails
"""
def __init__(self, mCircleId = None, mCircleName = None, mCircleType = None, mRestrictedCircleId = None, mAmIAllowed = None, mAllowedGxsIds = None, mAllowedNodes = None, mSubscriptionFlags = None):
"""
:param mCircleId: (RsGxsCircleId)
:param mCircleName: (str)
:param mCircleType: (int)
:param mRestrictedCircleId: (RsGxsCircleId)
:param mAmIAllowed: (bool)
:param mAllowedGxsIds: (set< RsGxsId >)
:param mAllowedNodes: (set< RsPgpId >)
:param mSubscriptionFlags: (map< RsGxsId, uint32_t >)
:type mCircleId: RsGxsCircleId
:type mCircleName: str
:type mCircleType: int
:type mRestrictedCircleId: RsGxsCircleId
:type mAmIAllowed: bool
:type mAllowedGxsIds: set< RsGxsId >
:type mAllowedNodes: set< RsPgpId >
:type mSubscriptionFlags: map< RsGxsId, uint32_t >
"""
self.mCircleId = mCircleId
self.mCircleName = mCircleName
self.mCircleType = mCircleType
self.mRestrictedCircleId = mRestrictedCircleId
self.mAmIAllowed = mAmIAllowed
self.mAllowedGxsIds = mAllowedGxsIds
self.mAllowedNodes = mAllowedNodes
self.mSubscriptionFlags = mSubscriptionFlags
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
class RsGxsCircleMsg:
"""
RsGxsCircleMsg
"""
def __init__(self, mMeta = None, stuff = None):
"""
:param mMeta: (RsMsgMetaData)
:param stuff: (str)
:type mMeta: RsMsgMetaData
:type stuff: str
"""
self.mMeta = mMeta
self.stuff = stuff
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
class RsGxsChannelGroup:
"""
RsGxsChannelGroup
"""
def __init__(self, mMeta = None, mDescription = None, mImage = None, mAutoDownload = None):
"""
:param mMeta: (RsGroupMetaData)
:param mDescription: (str)
:param mImage: (RsGxsImage)
:param mAutoDownload: (bool)
:type mMeta: RsGroupMetaData
:type mDescription: str
:type mImage: RsGxsImage
:type mAutoDownload: bool
"""
self.mMeta = mMeta
self.mDescription = mDescription
self.mImage = mImage
self.mAutoDownload = mAutoDownload
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
class RsGxsCircleType(Enum):
"""
RsGxsCircleType
"""
UNKNOWN= 0
PUBLIC= 1
EXTERNAL= 2
NODES_GROUP= 3
LOCAL= 4
EXT_SELF= 5
YOUR_EYES_ONLY= 6
class RsGxsComment:
"""
RsGxsComment
"""
def __init__(self, mMeta = None, mComment = None, mUpVotes = None, mDownVotes = None, mScore = None, mOwnVote = None, mVotes = None):
"""
:param mMeta: (RsMsgMetaData)
:param mComment: (str)
:param mUpVotes: (int)
:param mDownVotes: (int)
:param mScore: (float)
:param mOwnVote: (int)
:param mVotes: (list< RsGxsVote >)
:type mMeta: RsMsgMetaData
:type mComment: str
:type mUpVotes: int
:type mDownVotes: int
:type mScore: float
:type mOwnVote: int
:type mVotes: list< RsGxsVote >
"""
self.mMeta = mMeta
self.mComment = mComment
self.mUpVotes = mUpVotes
self.mDownVotes = mDownVotes
self.mScore = mScore
self.mOwnVote = mOwnVote
self.mVotes = mVotes
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
class RsGxsChannelPost:
"""
RsGxsChannelPost
"""
def __init__(self, mMeta = None, mOlderVersions = None, mMsg = None, mFiles = None, mCount = None, mSize = None, mThumbnail = None):
"""
:param mMeta: (RsMsgMetaData)
:param mOlderVersions: (set< RsGxsMessageId >)
:param mMsg: (str)
:param mFiles: (list< RsGxsFile >)
:param mCount: (int)
:param mSize: (int)
:param mThumbnail: (RsGxsImage)
:type mMeta: RsMsgMetaData
:type mOlderVersions: set< RsGxsMessageId >
:type mMsg: str
:type mFiles: list< RsGxsFile >
:type mCount: int
:type mSize: int
:type mThumbnail: RsGxsImage
"""
self.mMeta = mMeta
self.mOlderVersions = mOlderVersions
self.mMsg = mMsg
self.mFiles = mFiles
self.mCount = mCount
self.mSize = mSize
self.mThumbnail = mThumbnail
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
class RsGxsFile:
"""
RsGxsFile
"""
def __init__(self, mName = None, mHash = None, mSize = None):
"""
:param mName: (str)
:param mHash: (RsFileHash)
:param mSize: (int)
:type mName: str
:type mHash: RsFileHash
:type mSize: int
"""
self.mName = mName
self.mHash = mHash
self.mSize = mSize
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
class RsGxsVote:
"""
RsGxsVote
"""
def __init__(self, mMeta = None, mVoteType = None):
"""
:param mMeta: (RsMsgMetaData)
:param mVoteType: (int)
:type mMeta: RsMsgMetaData
:type mVoteType: int
"""
self.mMeta = mMeta
self.mVoteType = mVoteType
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
class RsGxsVoteType(Enum):
"""
RsGxsVoteType
"""
NONE= 0
DOWN= 1
UP= 2
RsFileHash = NewType('RsFileHash', str)
class RsGxsGroupSummary:
"""
RsGxsGroupSummary
"""
def __init__(self, mGroupId = None, mGroupName = None, mAuthorId = None, mPublishTs = None, mNumberOfMessages = None, mLastMessageTs = None, mSignFlags = None, mPopularity = None, mSearchContext = None):
"""
:param mGroupId: (RsGxsGroupId)
:param mGroupName: (str)
:param mAuthorId: (RsGxsId)
:param mPublishTs: (rstime_t)
:param mNumberOfMessages: (int)
:param mLastMessageTs: (rstime_t)
:param mSignFlags: (int)
:param mPopularity: (int)
:param mSearchContext: (str)
:type mGroupId: RsGxsGroupId
:type mGroupName: str
:type mAuthorId: RsGxsId
:type mPublishTs: rstime_t
:type mNumberOfMessages: int
:type mLastMessageTs: rstime_t
:type mSignFlags: int
:type mPopularity: int
:type mSearchContext: str
"""
self.mGroupId = mGroupId
self.mGroupName = mGroupName
self.mAuthorId = mAuthorId
self.mPublishTs = mPublishTs
self.mNumberOfMessages = mNumberOfMessages
self.mLastMessageTs = mLastMessageTs
self.mSignFlags = mSignFlags
self.mPopularity = mPopularity
self.mSearchContext = mSearchContext
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
rstime_t = NewType('rstime_t', int)
class SharedDirInfo:
"""
SharedDirInfo
"""
def __init__(self, filename = None, virtualname = None, shareflags = None, parent_groups = None):
"""
:param filename: (str)
:param virtualname: (str)
:param shareflags: (FileStorageFlags)
:param parent_groups: (list< RsNodeGroupId >)
:type filename: str
:type virtualname: str
:type shareflags: FileStorageFlags
:type parent_groups: list< RsNodeGroupId >
"""
self.filename = filename
self.virtualname = virtualname
self.shareflags = shareflags
self.parent_groups = parent_groups
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
class FileInfo:
"""
FileInfo
"""
def __init__(self, storage_permission_flags = None, transfer_info_flags = None, mId = None, searchId = None, path = None, fname = None, hash = None, ext = None, size = None, avail = None, rank = None, age = None, queue_position = None, transfered = None, tfRate = None, downloadStatus = None, peers = None, priority = None, lastTS = None, parent_groups = None):
"""
:param storage_permission_flags: (FileStorageFlags)
:param transfer_info_flags: (TransferRequestFlags)
:param mId: (unsigned int)
:param searchId: (int)
:param path: (str)
:param fname: (str)
:param hash: (RsFileHash)
:param ext: (str)
:param size: (int)
:param avail: (int)
:param rank: (float)
:param age: (int)
:param queue_position: (int)
:param transfered: (int)
:param tfRate: (float)
:param downloadStatus: (int)
:param peers: (vector< TransferInfo >)
:param priority: (DwlSpeed)
:param lastTS: (rstime_t)
:param parent_groups: (list< RsNodeGroupId >)
:type storage_permission_flags: FileStorageFlags
:type transfer_info_flags: TransferRequestFlags
:type mId: unsigned int
:type searchId: int
:type path: str
:type fname: str
:type hash: RsFileHash
:type ext: str
:type size: int
:type avail: int
:type rank: float
:type age: int
:type queue_position: int
:type transfered: int
:type tfRate: float
:type downloadStatus: int
:type peers: vector< TransferInfo >
:type priority: DwlSpeed
:type lastTS: rstime_t
:type parent_groups: list< RsNodeGroupId >
"""
self.storage_permission_flags = storage_permission_flags
self.transfer_info_flags = transfer_info_flags
self.mId = mId
self.searchId = searchId
self.path = path
self.fname = fname
self.hash = hash
self.ext = ext
self.size = size
self.avail = avail
self.rank = rank
self.age = age
self.queue_position = queue_position
self.transfered = transfered
self.tfRate = tfRate
self.downloadStatus = downloadStatus
self.peers = peers
self.priority = priority
self.lastTS = lastTS
self.parent_groups = parent_groups
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
FileSearchFlags = NewType('FileSearchFlags', int)
class FileChunksInfo:
"""
FileChunksInfo
"""
def __init__(self, file_size = None, chunk_size = None, strategy = None, chunks = None, compressed_peer_availability_maps = None, active_chunks = None, pending_slices = None):
"""
:param file_size: (int)
:param chunk_size: (int)
:param strategy: (ChunkStrategy)
:param chunks: (vector< ChunkState >)
:param compressed_peer_availability_maps: (map< RsPeerId, CompressedChunkMap >)
:param active_chunks: (vector< std_pair< uint32_t, uint32_t > >)
:param pending_slices: (map< uint32_t, std_vector< SliceInfo > >)
:type file_size: int
:type chunk_size: int
:type strategy: ChunkStrategy
:type chunks: vector< ChunkState >
:type compressed_peer_availability_maps: map< RsPeerId, CompressedChunkMap >
:type active_chunks: vector< std_pair< uint32_t, uint32_t > >
:type pending_slices: map< uint32_t, std_vector< SliceInfo > >
"""
self.file_size = file_size
self.chunk_size = chunk_size
self.strategy = strategy
self.chunks = chunks
self.compressed_peer_availability_maps = compressed_peer_availability_maps
self.active_chunks = active_chunks
self.pending_slices = pending_slices
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
TransferRequestFlags = NewType('TransferRequestFlags', int)
class CompressedChunkMap:
"""
CompressedChunkMap
"""
def __init__(self, _map = None):
"""
:param _map: (vector< uint32_t >)
:type _map: vector< uint32_t >
"""
self._map = _map
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
class DirDetails:
"""
DirDetails
"""
def __init__(self, parent = None, prow = None, ref = None, type = None, id = None, name = None, hash = None, path = None, count = None, mtime = None, flags = None, max_mtime = None, children = None, parent_groups = None):
"""
:param parent: (void *)
:param prow: (int)
:param ref: (void *)
:param type: (int)
:param id: (RsPeerId)
:param name: (str)
:param hash: (RsFileHash)
:param path: (str)
:param count: (int)
:param mtime: (int)
:param flags: (FileStorageFlags)
:param max_mtime: (int)
:param children: (vector< DirStub >)
:param parent_groups: (list< RsNodeGroupId >)
:type parent: void *
:type prow: int
:type ref: void *
:type type: int
:type id: RsPeerId
:type name: str
:type hash: RsFileHash
:type path: str
:type count: int
:type mtime: int
:type flags: FileStorageFlags
:type max_mtime: int
:type children: vector< DirStub >
:type parent_groups: list< RsNodeGroupId >
"""
self.parent = parent
self.prow = prow
self.ref = ref
self.type = type
self.id = id
self.name = name
self.hash = hash
self.path = path
self.count = count
self.mtime = mtime
self.flags = flags
self.max_mtime = max_mtime
self.children = children
self.parent_groups = parent_groups
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
class ChunkStrategy(Enum):
"""
ChunkStrategy
"""
class TurtleFileInfo:
"""
TurtleFileInfo
"""
def __init__(self, size = None, hash = None, name = None):
"""
:param size: (int)
:param hash: (RsFileHash)
:param name: (str)
:type size: int
:type hash: RsFileHash
:type name: str
"""
self.size = size
self.hash = hash
self.name = name
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
class RsConfigNetStatus:
"""
RsConfigNetStatus
"""
def __init__(self, ownId = None, ownName = None, localAddr = None, localPort = None, extAddr = None, extPort = None, extDynDns = None, firewalled = None, forwardPort = None, DHTActive = None, uPnPActive = None, uPnPState = None, netLocalOk = None, netUpnpOk = None, netDhtOk = None, netStunOk = None, netExtAddressOk = None, netDhtNetSize = None, netDhtRsNetSize = None):
"""
:param ownId: (RsPeerId)
:param ownName: (str)
:param localAddr: (str)
:param localPort: (int)
:param extAddr: (str)
:param extPort: (int)
:param extDynDns: (str)
:param firewalled: (bool)
:param forwardPort: (bool)
:param DHTActive: (bool)
:param uPnPActive: (bool)
:param uPnPState: (int)
:param netLocalOk: (bool)
:param netUpnpOk: (bool)
:param netDhtOk: (bool)
:param netStunOk: (bool)
:param netExtAddressOk: (bool)
:param netDhtNetSize: (int)
:param netDhtRsNetSize: (int)
:type ownId: RsPeerId
:type ownName: str
:type localAddr: str
:type localPort: int
:type extAddr: str
:type extPort: int
:type extDynDns: str
:type firewalled: bool
:type forwardPort: bool
:type DHTActive: bool
:type uPnPActive: bool
:type uPnPState: int
:type netLocalOk: bool
:type netUpnpOk: bool
:type netDhtOk: bool
:type netStunOk: bool
:type netExtAddressOk: bool
:type netDhtNetSize: int
:type netDhtRsNetSize: int
"""
self.ownId = ownId
self.ownName = ownName
self.localAddr = localAddr
self.localPort = localPort
self.extAddr = extAddr
self.extPort = extPort
self.extDynDns = extDynDns
self.firewalled = firewalled
self.forwardPort = forwardPort
self.DHTActive = DHTActive
self.uPnPActive = uPnPActive
self.uPnPState = uPnPState
self.netLocalOk = netLocalOk
self.netUpnpOk = netUpnpOk
self.netDhtOk = netDhtOk
self.netStunOk = netStunOk
self.netExtAddressOk = netExtAddressOk
self.netDhtNetSize = netDhtNetSize
self.netDhtRsNetSize = netDhtRsNetSize
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
class RsConfigDataRates:
"""
RsConfigDataRates
"""
def __init__(self, mRateIn = None, mRateMaxIn = None, mAllocIn = None, mAllocTs = None, mRateOut = None, mRateMaxOut = None, mAllowedOut = None, mAllowedTs = None, mQueueIn = None, mQueueOut = None):
"""
:param mRateIn: (float)
:param mRateMaxIn: (float)
:param mAllocIn: (float)
:param mAllocTs: (rstime_t)
:param mRateOut: (float)
:param mRateMaxOut: (float)
:param mAllowedOut: (float)
:param mAllowedTs: (rstime_t)
:param mQueueIn: (int)
:param mQueueOut: (int)
:type mRateIn: float
:type mRateMaxIn: float
:type mAllocIn: float
:type mAllocTs: rstime_t
:type mRateOut: float
:type mRateMaxOut: float
:type mAllowedOut: float
:type mAllowedTs: rstime_t
:type mQueueIn: int
:type mQueueOut: int
"""
self.mRateIn = mRateIn
self.mRateMaxIn = mRateMaxIn
self.mAllocIn = mAllocIn
self.mAllocTs = mAllocTs
self.mRateOut = mRateOut
self.mRateMaxOut = mRateMaxOut
self.mAllowedOut = mAllowedOut
self.mAllowedTs = mAllowedTs
self.mQueueIn = mQueueIn
self.mQueueOut = mQueueOut
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
class RSTrafficClue:
"""
RSTrafficClue
"""
def __init__(self, TS = None, size = None, priority = None, service_id = None, service_sub_id = None, peer_id = None, count = None):
"""
:param TS: (rstime_t)
:param size: (int)
:param priority: (int)
:param service_id: (int)
:param service_sub_id: (int)
:param peer_id: (RsPeerId)
:param count: (int)
:type TS: rstime_t
:type size: int
:type priority: int
:type service_id: int
:type service_sub_id: int
:type peer_id: RsPeerId
:type count: int
"""
self.TS = TS
self.size = size
self.priority = priority
self.service_id = service_id
self.service_sub_id = service_sub_id
self.peer_id = peer_id
self.count = count
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
ServicePermissionFlags = NewType('ServicePermissionFlags', int)
class RsGroupInfo:
"""
RsGroupInfo
"""
def __init__(self, id = None, name = None, flag = None, peerIds = None):
"""
:param id: (RsNodeGroupId)
:param name: (str)
:param flag: (int)
:param peerIds: (set< RsPgpId >)
:type id: RsNodeGroupId
:type name: str
:type flag: int
:type peerIds: set< RsPgpId >
"""
self.id = id
self.name = name
self.flag = flag
self.peerIds = peerIds
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
class RsUrl:
"""
RsUrl
"""
def __init__(self, schemeSeparator = None, ipv6WrapOpen = None, ipv6Separator = None, ipv6WrapClose = None, portSeparator = None, pathSeparator = None, querySeparator = None, queryAssign = None, queryFieldSep = None, fragmentSeparator = None, mScheme = None, mHost = None, mPort = None, mHasPort = None, mPath = None, mQuery = None, mFragment = None):
"""
:param schemeSeparator: (const std_string)
:param ipv6WrapOpen: (const std_string)
:param ipv6Separator: (const std_string)
:param ipv6WrapClose: (const std_string)
:param portSeparator: (const std_string)
:param pathSeparator: (const std_string)
:param querySeparator: (const std_string)
:param queryAssign: (const std_string)
:param queryFieldSep: (const std_string)
:param fragmentSeparator: (const std_string)
:param mScheme: (str)
:param mHost: (str)
:param mPort: (int)
:param mHasPort: (bool)
:param mPath: (str)
:param mQuery: (map< std_string, std_string >)
:param mFragment: (str)
:type schemeSeparator: const std_string
:type ipv6WrapOpen: const std_string
:type ipv6Separator: const std_string
:type ipv6WrapClose: const std_string
:type portSeparator: const std_string
:type pathSeparator: const std_string
:type querySeparator: const std_string
:type queryAssign: const std_string
:type queryFieldSep: const std_string
:type fragmentSeparator: const std_string
:type mScheme: str
:type mHost: str
:type mPort: int
:type mHasPort: bool
:type mPath: str
:type mQuery: map< std_string, std_string >
:type mFragment: str
"""
self.schemeSeparator = schemeSeparator
self.ipv6WrapOpen = ipv6WrapOpen
self.ipv6Separator = ipv6Separator
self.ipv6WrapClose = ipv6WrapClose
self.portSeparator = portSeparator
self.pathSeparator = pathSeparator
self.querySeparator = querySeparator
self.queryAssign = queryAssign
self.queryFieldSep = queryFieldSep
self.fragmentSeparator = fragmentSeparator
self.mScheme = mScheme
self.mHost = mHost
self.mPort = mPort
self.mHasPort = mHasPort
self.mPath = mPath
self.mQuery = mQuery
self.mFragment = mFragment
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
RsNodeGroupId = NewType('RsNodeGroupId', str)
class RsPeerDetails:
"""
RsPeerDetails
"""
def __init__(self, isOnlyGPGdetail = None, id = None, gpg_id = None, name = None, email = None, location = None, org = None, issuer = None, fpr = None, authcode = None, gpgSigners = None, trustLvl = None, validLvl = None, ownsign = None, hasSignedMe = None, accept_connection = None, service_perm_flags = None, state = None, actAsServer = None, connectAddr = None, connectPort = None, isHiddenNode = None, hiddenNodeAddress = None, hiddenNodePort = None, hiddenType = None, localAddr = None, localPort = None, extAddr = None, extPort = None, dyndns = None, ipAddressList = None, netMode = None, vs_disc = None, vs_dht = None, lastConnect = None, lastUsed = None, connectState = None, connectStateString = None, connectPeriod = None, foundDHT = None, wasDeniedConnection = None, deniedTS = None, linkType = None):
"""
:param isOnlyGPGdetail: (bool)
:param id: (RsPeerId)
:param gpg_id: (RsPgpId)
:param name: (str)
:param email: (str)
:param location: (str)
:param org: (str)
:param issuer: (RsPgpId)
:param fpr: (PGPFingerprintType)
:param authcode: (str)
:param gpgSigners: (list< RsPgpId >)
:param trustLvl: (int)
:param validLvl: (int)
:param ownsign: (bool)
:param hasSignedMe: (bool)
:param accept_connection: (bool)
:param service_perm_flags: (ServicePermissionFlags)
:param state: (int)
:param actAsServer: (bool)
:param connectAddr: (str)
:param connectPort: (int)
:param isHiddenNode: (bool)
:param hiddenNodeAddress: (str)
:param hiddenNodePort: (int)
:param hiddenType: (int)
:param localAddr: (str)
:param localPort: (int)
:param extAddr: (str)
:param extPort: (int)
:param dyndns: (str)
:param ipAddressList: (list< std_string >)
:param netMode: (int)
:param vs_disc: (int)
:param vs_dht: (int)
:param lastConnect: (int)
:param lastUsed: (int)
:param connectState: (int)
:param connectStateString: (str)
:param connectPeriod: (int)
:param foundDHT: (bool)
:param wasDeniedConnection: (bool)
:param deniedTS: (rstime_t)
:param linkType: (int)
:type isOnlyGPGdetail: bool
:type id: RsPeerId
:type gpg_id: RsPgpId
:type name: str
:type email: str
:type location: str
:type org: str
:type issuer: RsPgpId
:type fpr: PGPFingerprintType
:type authcode: str
:type gpgSigners: list< RsPgpId >
:type trustLvl: int
:type validLvl: int
:type ownsign: bool
:type hasSignedMe: bool
:type accept_connection: bool
:type service_perm_flags: ServicePermissionFlags
:type state: int
:type actAsServer: bool
:type connectAddr: str
:type connectPort: int
:type isHiddenNode: bool
:type hiddenNodeAddress: str
:type hiddenNodePort: int
:type hiddenType: int
:type localAddr: str
:type localPort: int
:type extAddr: str
:type extPort: int
:type dyndns: str
:type ipAddressList: list< std_string >
:type netMode: int
:type vs_disc: int
:type vs_dht: int
:type lastConnect: int
:type lastUsed: int
:type connectState: int
:type connectStateString: str
:type connectPeriod: int
:type foundDHT: bool
:type wasDeniedConnection: bool
:type deniedTS: rstime_t
:type linkType: int
"""
self.isOnlyGPGdetail = isOnlyGPGdetail
self.id = id
self.gpg_id = gpg_id
self.name = name
self.email = email
self.location = location
self.org = org
self.issuer = issuer
self.fpr = fpr
self.authcode = authcode
self.gpgSigners = gpgSigners
self.trustLvl = trustLvl
self.validLvl = validLvl
self.ownsign = ownsign
self.hasSignedMe = hasSignedMe
self.accept_connection = accept_connection
self.service_perm_flags = service_perm_flags
self.state = state
self.actAsServer = actAsServer
self.connectAddr = connectAddr
self.connectPort = connectPort
self.isHiddenNode = isHiddenNode
self.hiddenNodeAddress = hiddenNodeAddress
self.hiddenNodePort = hiddenNodePort
self.hiddenType = hiddenType
self.localAddr = localAddr
self.localPort = localPort
self.extAddr = extAddr
self.extPort = extPort
self.dyndns = dyndns
self.ipAddressList = ipAddressList
self.netMode = netMode
self.vs_disc = vs_disc
self.vs_dht = vs_dht
self.lastConnect = lastConnect
self.lastUsed = lastUsed
self.connectState = connectState
self.connectStateString = connectStateString
self.connectPeriod = connectPeriod
self.foundDHT = foundDHT
self.wasDeniedConnection = wasDeniedConnection
self.deniedTS = deniedTS
self.linkType = linkType
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
class RsLoginHelper_Location:
"""
RsLoginHelper_Location
"""
def __init__(self, mLocationId = None, mPgpId = None, mLocationName = None, mPpgName = None):
"""
:param mLocationId: (RsPeerId)
:param mPgpId: (RsPgpId)
:param mLocationName: (str)
:param mPpgName: (str)
:type mLocationId: RsPeerId
:type mPgpId: RsPgpId
:type mLocationName: str
:type mPpgName: str
"""
self.mLocationId = mLocationId
self.mPgpId = mPgpId
self.mLocationName = mLocationName
self.mPpgName = mPpgName
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
RsTlvGxsIdSet = NewType('RsTlvGxsIdSet', str)
RsTlvGxsMsgIdSet = NewType('RsTlvGxsMsgIdSet', str)
class RsReputationLevel(Enum):
"""
RsReputationLevel
"""
LOCALLY_NEGATIVE= 0x00
REMOTELY_NEGATIVE= 0x01
NEUTRAL= 0x02
REMOTELY_POSITIVE= 0x03
LOCALLY_POSITIVE= 0x04
UNKNOWN= 0x05
class RsServiceInfo:
"""
RsServiceInfo
"""
def __init__(self, mServiceName = None, mServiceType = None, mVersionMajor = None, mVersionMinor = None, mMinVersionMajor = None, mMinVersionMinor = None):
"""
:param mServiceName: (str)
:param mServiceType: (int)
:param mVersionMajor: (int)
:param mVersionMinor: (int)
:param mMinVersionMajor: (int)
:param mMinVersionMinor: (int)
:type mServiceName: str
:type mServiceType: int
:type mVersionMajor: int
:type mVersionMinor: int
:type mMinVersionMajor: int
:type mMinVersionMinor: int
"""
self.mServiceName = mServiceName
self.mServiceType = mServiceType
self.mVersionMajor = mVersionMajor
self.mVersionMinor = mVersionMinor
self.mMinVersionMajor = mMinVersionMajor
self.mMinVersionMinor = mMinVersionMinor
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
Sha1CheckSum = NewType('Sha1CheckSum', str)
class GxsReputation:
"""
GxsReputation
"""
def __init__(self, mOverallScore = None, mIdScore = None, mOwnOpinion = None, mPeerOpinion = None):
"""
:param mOverallScore: (int)
:param mIdScore: (int)
:param mOwnOpinion: (int)
:param mPeerOpinion: (int)
:type mOverallScore: int
:type mIdScore: int
:type mOwnOpinion: int
:type mPeerOpinion: int
"""
self.mOverallScore = mOverallScore
self.mIdScore = mIdScore
self.mOwnOpinion = mOwnOpinion
self.mPeerOpinion = mPeerOpinion
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
class RsEventType(Enum):
"""
RsEventType
"""
NONE= 0
BROADCAST_DISCOVERY_PEER_FOUND= 1
GOSSIP_DISCOVERY_INVITE_RECEIVED= 2
AUTHSSL_CONNECTION_AUTENTICATION= 3
REMOTE_PEER_REFUSED_CONNECTION= 4
GXS_CHANGES= 5
DistantChatPeerId = NewType('DistantChatPeerId', str)
FileStorageFlags = NewType('FileStorageFlags', int)
class TransferInfo:
"""
TransferInfo
"""
def __init__(self, peerId = None, name = None, tfRate = None, status = None, transfered = None):
"""
:param peerId: (RsPeerId)
:param name: (str)
:param tfRate: (float)
:param status: (int)
:param transfered: (int)
:type peerId: RsPeerId
:type name: str
:type tfRate: float
:type status: int
:type transfered: int
"""
self.peerId = peerId
self.name = name
self.tfRate = tfRate
self.status = status
self.transfered = transfered
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
class DwlSpeed(Enum):
"""
DwlSpeed
"""
SPEED_LOW= 0x00
SPEED_NORMAL= 0x01
SPEED_HIGH= 0x02
RsMailMessageId = NewType('RsMailMessageId', str)
class ChunkState(Enum):
"""
ChunkState
"""
CHUNK_OUTSTANDING= 0
CHUNK_ACTIVE= 1
CHUNK_DONE= 2
CHUNK_CHECKING= 3
class FileChunksInfo_SliceInfo:
"""
FileChunksInfo_SliceInfo
"""
def __init__(self, start = None, size = None, peer_id = None):
"""
:param start: (int)
:param size: (int)
:param peer_id: (RsPeerId)
:type start: int
:type size: int
:type peer_id: RsPeerId
"""
self.start = start
self.size = size
self.peer_id = peer_id
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
class DirStub:
"""
DirStub
"""
def __init__(self, type = None, name = None, ref = None):
"""
:param type: (int)
:param name: (str)
:param ref: (void *)
:type type: int
:type name: str
:type ref: void *
"""
self.type = type
self.name = name
self.ref = ref
def __repr__(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)