emdee/toxygen_wrapper
1
0
Fork 0
Code Issues Pull Requests Actions Projects Releases Wiki Activity

bugfixes

Browse Source
This commit is contained in:
emdee 2023-12-10 15:59:53 +00:00
parent aedf36cda2
commit d034bafd4a
3 changed files with 161 additions and 229 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

175
wrapper/tox.py
View File

@ -186,9 +186,7 @@ class Tox:
else: else:
LOG_DEBUG(f"tox.kill") LOG_DEBUG(f"tox.kill")
# -----------------------------------------------------------------------------------------------------------------
# Startup options # Startup options
# -----------------------------------------------------------------------------------------------------------------
@staticmethod @staticmethod
def options_default(tox_options): def options_default(tox_options):
@ -240,9 +238,7 @@ class Tox:
LOG_DEBUG(f"tox.options_free") LOG_DEBUG(f"tox.options_free")
Tox.libtoxcore.tox_options_free(tox_options) Tox.libtoxcore.tox_options_free(tox_options)
# -----------------------------------------------------------------------------------------------------------------
# Creation and destruction # Creation and destruction
# -----------------------------------------------------------------------------------------------------------------
def get_savedata_size(self): def get_savedata_size(self):
""" """
@ -269,9 +265,7 @@ class Tox:
Tox.libtoxcore.tox_get_savedata(self._tox_pointer, savedata) Tox.libtoxcore.tox_get_savedata(self._tox_pointer, savedata)
return savedata[:] return savedata[:]
# -----------------------------------------------------------------------------------------------------------------
# Connection lifecycle and event loop # Connection lifecycle and event loop
# -----------------------------------------------------------------------------------------------------------------
def bootstrap(self, address, port, public_key): def bootstrap(self, address, port, public_key):
"""Sends a "get nodes" request to the given bootstrap node with IP, port, and public key to setup connections. """Sends a "get nodes" request to the given bootstrap node with IP, port, and public key to setup connections.
@ -414,9 +408,7 @@ class Tox:
else: else:
LOG_TRACE(f"iterate") LOG_TRACE(f"iterate")
# -----------------------------------------------------------------------------------------------------------------
# Internal client information (Tox address/id) # Internal client information (Tox address/id)
# -----------------------------------------------------------------------------------------------------------------
def self_get_toxid(self, address=None): def self_get_toxid(self, address=None):
return self.self_get_address(address) return self.self_get_address(address)
@ -481,9 +473,7 @@ class Tox:
Tox.libtoxcore.tox_self_get_secret_key(self._tox_pointer, secret_key) Tox.libtoxcore.tox_self_get_secret_key(self._tox_pointer, secret_key)
return bin_to_string(secret_key, TOX_SECRET_KEY_SIZE) return bin_to_string(secret_key, TOX_SECRET_KEY_SIZE)
# -----------------------------------------------------------------------------------------------------------------
# User-visible client information (nickname/status) # User-visible client information (nickname/status)
# -----------------------------------------------------------------------------------------------------------------
def self_set_name(self, name): def self_set_name(self, name):
""" """
@ -620,9 +610,7 @@ class Tox:
result = Tox.libtoxcore.tox_self_get_status(self._tox_pointer) result = Tox.libtoxcore.tox_self_get_status(self._tox_pointer)
return int(result) return int(result)
# -----------------------------------------------------------------------------------------------------------------
# Friend list management # Friend list management
# -----------------------------------------------------------------------------------------------------------------
def friend_add(self, address, message): def friend_add(self, address, message):
"""Add a friend to the friend list and send a friend request. """Add a friend to the friend list and send a friend request.
@ -658,7 +646,7 @@ class Tox:
byref(tox_err_friend_add)) byref(tox_err_friend_add))
tox_err_friend_add = tox_err_friend_add.value tox_err_friend_add = tox_err_friend_add.value
if tox_err_friend_add == TOX_ERR_FRIEND_ADD['OK']: if tox_err_friend_add == TOX_ERR_FRIEND_ADD['OK']:
return result return int(result)
if tox_err_friend_add == TOX_ERR_FRIEND_ADD['NULL']: if tox_err_friend_add == TOX_ERR_FRIEND_ADD['NULL']:
raise ArgumentError('One of the arguments to the function was NULL when it was not expected.') raise ArgumentError('One of the arguments to the function was NULL when it was not expected.')
@ -705,7 +693,7 @@ class Tox:
byref(tox_err_friend_add)) byref(tox_err_friend_add))
tox_err_friend_add = tox_err_friend_add.value tox_err_friend_add = tox_err_friend_add.value
if tox_err_friend_add == TOX_ERR_FRIEND_ADD['OK']: if tox_err_friend_add == TOX_ERR_FRIEND_ADD['OK']:
return result return int(result)
if tox_err_friend_add == TOX_ERR_FRIEND_ADD['NULL']: if tox_err_friend_add == TOX_ERR_FRIEND_ADD['NULL']:
raise ArgumentError('One of the arguments to the function was NULL when it was not expected.') raise ArgumentError('One of the arguments to the function was NULL when it was not expected.')
if tox_err_friend_add == TOX_ERR_FRIEND_ADD['TOO_LONG']: if tox_err_friend_add == TOX_ERR_FRIEND_ADD['TOO_LONG']:
@ -747,9 +735,7 @@ class Tox:
elif tox_err_friend_delete == TOX_ERR_FRIEND_DELETE['FRIEND_NOT_FOUND']: elif tox_err_friend_delete == TOX_ERR_FRIEND_DELETE['FRIEND_NOT_FOUND']:
raise ArgumentError('There was no friend with the given friend number. No friends were deleted.') raise ArgumentError('There was no friend with the given friend number. No friends were deleted.')
# -----------------------------------------------------------------------------------------------------------------
# Friend list queries # Friend list queries
# -----------------------------------------------------------------------------------------------------------------
def friend_by_public_key(self, public_key): def friend_by_public_key(self, public_key):
""" """
@ -765,7 +751,7 @@ class Tox:
byref(tox_err_friend_by_public_key)) byref(tox_err_friend_by_public_key))
tox_err_friend_by_public_key = tox_err_friend_by_public_key.value tox_err_friend_by_public_key = tox_err_friend_by_public_key.value
if tox_err_friend_by_public_key == TOX_ERR_FRIEND_BY_PUBLIC_KEY['OK']: if tox_err_friend_by_public_key == TOX_ERR_FRIEND_BY_PUBLIC_KEY['OK']:
return result return int(result)
if tox_err_friend_by_public_key == TOX_ERR_FRIEND_BY_PUBLIC_KEY['NULL']: if tox_err_friend_by_public_key == TOX_ERR_FRIEND_BY_PUBLIC_KEY['NULL']:
raise ArgumentError('One of the arguments to the function was NULL when it was not expected.') raise ArgumentError('One of the arguments to the function was NULL when it was not expected.')
if tox_err_friend_by_public_key == TOX_ERR_FRIEND_BY_PUBLIC_KEY['NOT_FOUND']: if tox_err_friend_by_public_key == TOX_ERR_FRIEND_BY_PUBLIC_KEY['NOT_FOUND']:
@ -844,14 +830,12 @@ class Tox:
byref(tox_err_last_online)) byref(tox_err_last_online))
tox_err_last_online = tox_err_last_online.value tox_err_last_online = tox_err_last_online.value
if tox_err_last_online == TOX_ERR_FRIEND_GET_LAST_ONLINE['OK']: if tox_err_last_online == TOX_ERR_FRIEND_GET_LAST_ONLINE['OK']:
return result return int(result)
elif tox_err_last_online == TOX_ERR_FRIEND_GET_LAST_ONLINE['FRIEND_NOT_FOUND']: elif tox_err_last_online == TOX_ERR_FRIEND_GET_LAST_ONLINE['FRIEND_NOT_FOUND']:
raise ArgumentError('No friend with the given number exists on the friend list.') raise ArgumentError('No friend with the given number exists on the friend list.')
raise ToxError('The function did not return OK') raise ToxError('The function did not return OK')
# -----------------------------------------------------------------------------------------------------------------
# Friend-specific state queries (can also be received through callbacks) # Friend-specific state queries (can also be received through callbacks)
# -----------------------------------------------------------------------------------------------------------------
def friend_get_name_size(self, friend_number): def friend_get_name_size(self, friend_number):
""" """
@ -866,7 +850,7 @@ class Tox:
byref(tox_err_friend_query)) byref(tox_err_friend_query))
tox_err_friend_query = tox_err_friend_query.value tox_err_friend_query = tox_err_friend_query.value
if tox_err_friend_query == TOX_ERR_FRIEND_QUERY['OK']: if tox_err_friend_query == TOX_ERR_FRIEND_QUERY['OK']:
return result return int(result)
elif tox_err_friend_query == TOX_ERR_FRIEND_QUERY['NULL']: elif tox_err_friend_query == TOX_ERR_FRIEND_QUERY['NULL']:
raise ArgumentError('The pointer parameter for storing the query result (name, message) was NULL. Unlike' raise ArgumentError('The pointer parameter for storing the query result (name, message) was NULL. Unlike'
' the `_self_` variants of these functions, which have no effect when a parameter is' ' the `_self_` variants of these functions, which have no effect when a parameter is'
@ -941,7 +925,7 @@ class Tox:
byref(tox_err_friend_query)) byref(tox_err_friend_query))
tox_err_friend_query = tox_err_friend_query.value tox_err_friend_query = tox_err_friend_query.value
if tox_err_friend_query == TOX_ERR_FRIEND_QUERY['OK']: if tox_err_friend_query == TOX_ERR_FRIEND_QUERY['OK']:
return result return int(result)
elif tox_err_friend_query == TOX_ERR_FRIEND_QUERY['NULL']: elif tox_err_friend_query == TOX_ERR_FRIEND_QUERY['NULL']:
raise ArgumentError('The pointer parameter for storing the query result (name, message) was NULL. Unlike' raise ArgumentError('The pointer parameter for storing the query result (name, message) was NULL. Unlike'
' the `_self_` variants of these functions, which have no effect when a parameter is' ' the `_self_` variants of these functions, which have no effect when a parameter is'
@ -1150,9 +1134,7 @@ class Tox:
LOG_DEBUG(f"tox.callback_friend_typing") LOG_DEBUG(f"tox.callback_friend_typing")
Tox.libtoxcore.tox_callback_friend_typing(self._tox_pointer, self.friend_typing_cb) Tox.libtoxcore.tox_callback_friend_typing(self._tox_pointer, self.friend_typing_cb)
# -----------------------------------------------------------------------------------------------------------------
# Sending private messages # Sending private messages
# -----------------------------------------------------------------------------------------------------------------
def self_set_typing(self, friend_number, typing): def self_set_typing(self, friend_number, typing):
""" """
@ -1249,9 +1231,7 @@ class Tox:
Tox.libtoxcore.tox_callback_friend_read_receipt(self._tox_pointer, Tox.libtoxcore.tox_callback_friend_read_receipt(self._tox_pointer,
self.friend_read_receipt_cb) self.friend_read_receipt_cb)
# -----------------------------------------------------------------------------------------------------------------
# Receiving private messages and friend requests # Receiving private messages and friend requests
# -----------------------------------------------------------------------------------------------------------------
def callback_friend_request(self, callback): def callback_friend_request(self, callback):
""" """
@ -1302,9 +1282,7 @@ class Tox:
LOG_DEBUG(f"tox.callback_friend_message") LOG_DEBUG(f"tox.callback_friend_message")
Tox.libtoxcore.tox_callback_friend_message(self._tox_pointer, self.friend_message_cb) Tox.libtoxcore.tox_callback_friend_message(self._tox_pointer, self.friend_message_cb)
# -----------------------------------------------------------------------------------------------------------------
# File transmission: common between sending and receiving # File transmission: common between sending and receiving
# -----------------------------------------------------------------------------------------------------------------
@staticmethod @staticmethod
def hash(data, hash=None): def hash(data, hash=None):
@ -1454,9 +1432,7 @@ class Tox:
if err_val == TOX_ERR_FILE_GET['NOT_FOUND']: if err_val == TOX_ERR_FILE_GET['NOT_FOUND']:
raise ArgumentError('No file transfer with the given file number was found for the given friend.') raise ArgumentError('No file transfer with the given file number was found for the given friend.')
# -----------------------------------------------------------------------------------------------------------------
# File transmission: sending # File transmission: sending
# -----------------------------------------------------------------------------------------------------------------
def file_send(self, friend_number, kind, file_size, file_id, filename): def file_send(self, friend_number, kind, file_size, file_id, filename):
"""Send a file transmission request. """Send a file transmission request.
@ -1618,9 +1594,7 @@ class Tox:
self.file_chunk_request_cb = c_callback(callback) self.file_chunk_request_cb = c_callback(callback)
self.libtoxcore.tox_callback_file_chunk_request(self._tox_pointer, self.file_chunk_request_cb) self.libtoxcore.tox_callback_file_chunk_request(self._tox_pointer, self.file_chunk_request_cb)
# -----------------------------------------------------------------------------------------------------------------
# File transmission: receiving # File transmission: receiving
# -----------------------------------------------------------------------------------------------------------------
def callback_file_recv(self, callback): def callback_file_recv(self, callback):
""" """
@ -1687,9 +1661,7 @@ class Tox:
self.file_recv_chunk_cb = c_callback(callback) self.file_recv_chunk_cb = c_callback(callback)
self.libtoxcore.tox_callback_file_recv_chunk(self._tox_pointer, self.file_recv_chunk_cb) self.libtoxcore.tox_callback_file_recv_chunk(self._tox_pointer, self.file_recv_chunk_cb)
# -----------------------------------------------------------------------------------------------------------------
# Low-level custom packet sending and receiving # Low-level custom packet sending and receiving
# -----------------------------------------------------------------------------------------------------------------
def friend_send_lossy_packet(self, friend_number, data): def friend_send_lossy_packet(self, friend_number, data):
""" """
@ -1811,9 +1783,7 @@ class Tox:
self.friend_lossless_packet_cb = c_callback(callback) self.friend_lossless_packet_cb = c_callback(callback)
self.libtoxcore.tox_callback_friend_lossless_packet(self._tox_pointer, self.friend_lossless_packet_cb) self.libtoxcore.tox_callback_friend_lossless_packet(self._tox_pointer, self.friend_lossless_packet_cb)
# -----------------------------------------------------------------------------------------------------------------
# Low-level network information # Low-level network information
# -----------------------------------------------------------------------------------------------------------------
# def self_get_keys(self): pass # def self_get_keys(self): pass
def self_get_dht_id(self, dht_id=None): def self_get_dht_id(self, dht_id=None):
@ -1867,9 +1837,7 @@ class Tox:
raise ToxError('The instance was not bound to any port.') raise ToxError('The instance was not bound to any port.')
raise ToxError('The function did not return OK') raise ToxError('The function did not return OK')
# -----------------------------------------------------------------------------------------------------------------
# Group chat instance management # Group chat instance management
# -----------------------------------------------------------------------------------------------------------------
def group_new(self, privacy_state, group_name, nick, status=''): def group_new(self, privacy_state, group_name, nick, status=''):
"""Creates a new group chat. """Creates a new group chat.
@ -1918,7 +1886,7 @@ class Tox:
if error.value: if error.value:
s = sGetError(error.value, TOX_ERR_GROUP_NEW) s = sGetError(error.value, TOX_ERR_GROUP_NEW)
LOG_ERROR(f"group_new {error.value} {s}") LOG_ERROR(f"group_new {error.value} {s}")
raise ToxError(f"group_new {s} {error.value}") raise ToxError(f"group_new {s} err={error.value}")
# TypeError: '<' not supported between instances of 'c_uint' and 'int' # TypeError: '<' not supported between instances of 'c_uint' and 'int'
return int(result) return int(result)
@ -1999,7 +1967,7 @@ class Tox:
if error.value: if error.value:
s = sGetError(error.value, TOX_ERR_GROUP_RECONNECT) s = sGetError(error.value, TOX_ERR_GROUP_RECONNECT)
LOG_ERROR(f"group_new {error.value} {s}") LOG_ERROR(f"group_new {error.value} {s}")
raise ToxError(f"group_new {s} {error.value}") raise ToxError(f"group_new {s} err={error.value}")
return bool(result) return bool(result)
def group_is_connected(self, group_number): def group_is_connected(self, group_number):
@ -2025,7 +1993,7 @@ class Tox:
if error.value: if error.value:
s = sGetError(error.value, TOX_ERR_GROUP_DISCONNECT) s = sGetError(error.value, TOX_ERR_GROUP_DISCONNECT)
LOG_ERROR(f"group_disconnect {error.value} {s}") LOG_ERROR(f"group_disconnect {error.value} {s}")
raise ToxError(f"group_disconnect {s} {error.value}") raise ToxError(f"group_disconnect {s} err={error.value}")
return bool(result) return bool(result)
def group_leave(self, group_number, message=None): def group_leave(self, group_number, message=None):
@ -2055,13 +2023,11 @@ class Tox:
result = f(self._tox_pointer, c_uint32(group_number), message, result = f(self._tox_pointer, c_uint32(group_number), message,
c_size_t(len(message)) if message else 0, byref(error)) c_size_t(len(message)) if message else 0, byref(error))
if error.value: if error.value:
LOG_ERROR(f"group_leave {error.value}") LOG_ERROR(f"group_leave err={error.value}")
raise ToxError("group_leave {error.value}") raise ToxError("group_leave err={error.value}")
return bool(result) return bool(result)
# -----------------------------------------------------------------------------------------------------------------
# Group user-visible client information (nickname/status/role/public key) # Group user-visible client information (nickname/status/role/public key)
# -----------------------------------------------------------------------------------------------------------------
def group_self_set_name(self, group_number, name): def group_self_set_name(self, group_number, name):
"""Set the client's nickname for the group instance designated by the given group number. """Set the client's nickname for the group instance designated by the given group number.
@ -2084,8 +2050,8 @@ class Tox:
LOG_DEBUG(f"tox.group_self_set_name") LOG_DEBUG(f"tox.group_self_set_name")
result = Tox.libtoxcore.tox_group_self_set_name(self._tox_pointer, c_uint32(group_number), name, c_size_t(len(name)), byref(error)) result = Tox.libtoxcore.tox_group_self_set_name(self._tox_pointer, c_uint32(group_number), name, c_size_t(len(name)), byref(error))
if error.value: if error.value:
LOG_ERROR(f"group_self_set_name {error.value}") LOG_ERROR(f"group_self_set_name err={error.value}")
raise ToxError("group_self_set_name {error.value}") raise ToxError("group_self_set_name err={error.value}")
return bool(result) return bool(result)
def group_self_get_name_size(self, group_number): def group_self_get_name_size(self, group_number):
@ -2105,8 +2071,8 @@ class Tox:
c_uint32(group_number), c_uint32(group_number),
byref(error)) byref(error))
if error.value: if error.value:
LOG_ERROR(f"group_self_get_name_size {error.value}") LOG_ERROR(f"group_self_get_name_size err={error.value}")
raise ToxError("group_self_get_name_size {error.value}") raise ToxError("group_self_get_name_size err={error.value}")
return int(result) return int(result)
def group_self_get_name(self, group_number): def group_self_get_name(self, group_number):
@ -2125,7 +2091,7 @@ class Tox:
raise ToxError(f"tox_group_ group_number < 0 {group_number}") raise ToxError(f"tox_group_ group_number < 0 {group_number}")
error = c_int() error = c_int()
size = self.group_self_get_name_size(c_uint32(group_number)) size = self.group_self_get_name_size(group_number)
name = create_string_buffer(size) name = create_string_buffer(size)
LOG_DEBUG(f"tox.group_self_get_name") LOG_DEBUG(f"tox.group_self_get_name")
result = Tox.libtoxcore.tox_group_self_get_name(self._tox_pointer, result = Tox.libtoxcore.tox_group_self_get_name(self._tox_pointer,
@ -2150,8 +2116,8 @@ class Tox:
LOG_DEBUG(f"tox.group_self_set_status") LOG_DEBUG(f"tox.group_self_set_status")
result = Tox.libtoxcore.tox_group_self_set_status(self._tox_pointer, c_uint32(group_number), status, byref(error)) result = Tox.libtoxcore.tox_group_self_set_status(self._tox_pointer, c_uint32(group_number), status, byref(error))
if error.value: if error.value:
LOG_ERROR(f"group_self_set_status {error.value}") LOG_ERROR(f"group_self_set_status err={error.value}")
raise ToxError("group_self_set_status {error.value}") raise ToxError("group_self_set_status err={error.value}")
return bool(result) return bool(result)
def group_self_get_status(self, group_number): def group_self_get_status(self, group_number):
@ -2166,7 +2132,7 @@ class Tox:
LOG_DEBUG(f"tox.group_self_get_status") LOG_DEBUG(f"tox.group_self_get_status")
result = Tox.libtoxcore.tox_group_self_get_status(self._tox_pointer, c_uint32(group_number), byref(error)) result = Tox.libtoxcore.tox_group_self_get_status(self._tox_pointer, c_uint32(group_number), byref(error))
if error.value: if error.value:
LOG_ERROR(f"group_self_get_status {error.value}") LOG_ERROR(f"group_self_get_status err={error.value}")
raise ToxError("group_self_get_status err={error.value}") raise ToxError("group_self_get_status err={error.value}")
return int(result) return int(result)
@ -2199,7 +2165,7 @@ class Tox:
result = Tox.libtoxcore.tox_group_self_get_peer_id(self._tox_pointer, c_uint32(group_number), byref(error)) result = Tox.libtoxcore.tox_group_self_get_peer_id(self._tox_pointer, c_uint32(group_number), byref(error))
if error.value: if error.value:
LOG_ERROR(f"tox.group_self_get_peer_id err={error.value}") LOG_ERROR(f"tox.group_self_get_peer_id err={error.value}")
raise ToxError("tox_group_self_get_peer_id {error.value}") raise ToxError("tox_group_self_get_peer_id err={error.value}")
return int(result) return int(result)
def group_self_get_public_key(self, group_number): def group_self_get_public_key(self, group_number):
@ -2227,9 +2193,7 @@ class Tox:
raise ToxError(f"tox.group_self_get_public_key {TOX_ERR_FRIEND_GET_PUBLIC_KEY[error.value]}") raise ToxError(f"tox.group_self_get_public_key {TOX_ERR_FRIEND_GET_PUBLIC_KEY[error.value]}")
return bin_to_string(key, TOX_GROUP_PEER_PUBLIC_KEY_SIZE) return bin_to_string(key, TOX_GROUP_PEER_PUBLIC_KEY_SIZE)
# -----------------------------------------------------------------------------------------------------------------
# Peer-specific group state queries. # Peer-specific group state queries.
# -----------------------------------------------------------------------------------------------------------------
def group_peer_get_name_size(self, group_number, peer_id): def group_peer_get_name_size(self, group_number, peer_id):
""" """
@ -2245,8 +2209,8 @@ class Tox:
error = c_int() error = c_int()
result = Tox.libtoxcore.tox_group_peer_get_name_size(self._tox_pointer, c_uint32(group_number), c_uint32(peer_id), byref(error)) result = Tox.libtoxcore.tox_group_peer_get_name_size(self._tox_pointer, c_uint32(group_number), c_uint32(peer_id), byref(error))
if error.value: if error.value:
LOG_ERROR(f" {error.value}") LOG_ERROR(f" err={error.value}")
raise ToxError(f" {error.value}") raise ToxError(f" err={error.value}")
LOG_TRACE(f"tox_group_peer_get_name_size") LOG_TRACE(f"tox_group_peer_get_name_size")
return int(result) return int(result)
@ -2300,9 +2264,10 @@ class Tox:
c_uint32(peer_id), c_uint32(peer_id),
byref(error)) byref(error))
if error.value: if error.value:
LOG_ERROR(f"tox.group_peer_get_status {error.value}") # unwrapped
raise ToxError(f"tox.group_peer_get_status {error.value}") LOG_ERROR(f"tox.group_peer_get_status err={error.value}")
return result raise ToxError(f"tox.group_peer_get_status err={error.value}")
return int(result)
def group_peer_get_role(self, group_number, peer_id): def group_peer_get_role(self, group_number, peer_id):
""" """
@ -2318,12 +2283,12 @@ class Tox:
error = c_int() error = c_int()
LOG_DEBUG(f"tox.group_peer_get_role") LOG_DEBUG(f"tox.group_peer_get_role")
result = Tox.libtoxcore.tox_group_peer_get_role(self._tox_pointer, result = Tox.libtoxcore.tox_group_peer_get_role(self._tox_pointer,
c_uint32(group_number), s c_uint32(group_number),
c_uint32(peer_id), c_uint32(peer_id),
byref(error)) byref(error))
if error.value: if error.value:
LOG_ERROR(f"tox.group_peer_get_role {error.value}") LOG_ERROR(f"tox.group_peer_get_role err={error.value}")
raise ToxError(f"tox.group_peer_get_role {error.value}") raise ToxError(f"tox.group_peer_get_role err={error.value}")
return int(result) return int(result)
def group_peer_get_public_key(self, group_number, peer_id): def group_peer_get_public_key(self, group_number, peer_id):
@ -2397,9 +2362,7 @@ class Tox:
LOG_WARN(f"callback_group_peer_status Exception {e}") LOG_WARN(f"callback_group_peer_status Exception {e}")
return None return None
# -----------------------------------------------------------------------------------------------------------------
# Group chat state queries and events. # Group chat state queries and events.
# -----------------------------------------------------------------------------------------------------------------
def group_set_topic(self, group_number, topic): def group_set_topic(self, group_number, topic):
"""Set the group topic and broadcast it to the rest of the group. """Set the group topic and broadcast it to the rest of the group.
@ -2474,8 +2437,8 @@ class Tox:
LOG_DEBUG(f"tox.group_get_topic") LOG_DEBUG(f"tox.group_get_topic")
result = Tox.libtoxcore.tox_group_get_topic(self._tox_pointer, c_uint32(group_number), topic, byref(error)) result = Tox.libtoxcore.tox_group_get_topic(self._tox_pointer, c_uint32(group_number), topic, byref(error))
if error.value: if error.value:
LOG_ERROR(f" {error.value}") LOG_ERROR(f" err={error.value}")
raise ToxError(f" {error.value}") raise ToxError(f" err={error.value}")
return str(topic[:size], 'utf-8', errors='ignore') return str(topic[:size], 'utf-8', errors='ignore')
def group_get_name_size(self, group_number): def group_get_name_size(self, group_number):
@ -2490,8 +2453,8 @@ class Tox:
c_uint32(group_number), c_uint32(group_number),
byref(error)) byref(error))
if error.value: if error.value:
LOG_ERROR(f" {error.value}") LOG_ERROR(f" err={error.value}")
raise ToxError(f" {error.value}") raise ToxError(f" err={error.value}")
LOG_TRACE(f"tox_group_get_name_size") LOG_TRACE(f"tox_group_get_name_size")
return int(result) return int(result)
@ -2511,8 +2474,8 @@ class Tox:
result = Tox.libtoxcore.tox_group_get_name(self._tox_pointer, c_uint32(group_number), result = Tox.libtoxcore.tox_group_get_name(self._tox_pointer, c_uint32(group_number),
name, byref(error)) name, byref(error))
if error.value: if error.value:
LOG_ERROR(f" {error.value}") LOG_ERROR(f"group_get_name err={error.value}")
raise ToxError(f" {error.value}") raise ToxError(f"group_get_name err={error.value}")
return str(name[:size], 'utf-8', errors='ignore') return str(name[:size], 'utf-8', errors='ignore')
def group_get_chat_id(self, group_number): def group_get_chat_id(self, group_number):
@ -2587,8 +2550,8 @@ class Tox:
c_uint32(group_number), c_uint32(group_number),
byref(error)) byref(error))
if error.value: if error.value:
LOG_ERROR(f"tox.group_get_privacy_state {error.value}") LOG_ERROR(f"tox.group_get_privacy_state err={error.value}")
raise ToxError(f"tox.group_get_privacy_state {error.value}") raise ToxError(f"tox.group_get_privacy_state err={error.value}")
return int(result) return int(result)
def group_get_peer_limit(self, group_number): def group_get_peer_limit(self, group_number):
@ -2610,8 +2573,8 @@ class Tox:
c_uint(group_number), c_uint(group_number),
byref(error)) byref(error))
if error.value: if error.value:
LOG_ERROR(f"tox.group_get_peer_limit {error.value}") LOG_ERROR(f"tox.group_get_peer_limit err={error.value}")
raise ToxError(f"tox.group_get_peer_limit {error.value}") raise ToxError(f"tox.group_get_peer_limit err={error.value}")
return int(result) return int(result)
def group_get_password_size(self, group_number): def group_get_password_size(self, group_number):
@ -2627,8 +2590,8 @@ class Tox:
result = Tox.libtoxcore.tox_group_get_password_size(self._tox_pointer, result = Tox.libtoxcore.tox_group_get_password_size(self._tox_pointer,
c_uint(group_number), byref(error)) c_uint(group_number), byref(error))
if error.value: if error.value:
LOG_ERROR(f" {error.value}") LOG_ERROR(f"group_get_password_size err={error.value}")
raise ToxError(f" {error.value}") raise ToxError(f"group_get_password_size err={error.value}")
return result return result
def group_get_password(self, group_number): def group_get_password(self, group_number):
@ -2654,8 +2617,8 @@ class Tox:
result = Tox.libtoxcore.tox_group_get_password(self._tox_pointer, c_uint(group_number), result = Tox.libtoxcore.tox_group_get_password(self._tox_pointer, c_uint(group_number),
password, byref(error)) password, byref(error))
if error.value: if error.value:
LOG_ERROR(f" {error.value}") LOG_ERROR(f"group_get_password err={error.value}")
raise ToxError(f" {error.value}") raise ToxError(f"group_get_password err={error.value}")
return str(password[:size], 'utf-8', errors='ignore') return str(password[:size], 'utf-8', errors='ignore')
def callback_group_topic(self, callback, user_data): def callback_group_topic(self, callback, user_data):
@ -2734,9 +2697,7 @@ class Tox:
except Exception as e: except Exception as e:
LOG_WARN(f"tox.callback_group_password Exception {e}") LOG_WARN(f"tox.callback_group_password Exception {e}")
# -----------------------------------------------------------------------------------------------------------------
# Group message sending # Group message sending
# -----------------------------------------------------------------------------------------------------------------
def group_send_custom_packet(self, group_number, lossless, data): def group_send_custom_packet(self, group_number, lossless, data):
"""Send a custom packet to the group. """Send a custom packet to the group.
@ -2775,9 +2736,9 @@ class Tox:
c_size_t(len(data)), c_size_t(len(data)),
byref(error)) byref(error))
if error.value: if error.value:
LOG_ERROR(f" {error.value}") LOG_ERROR(f"group_send_custom_packet err={error.value}")
raise ToxError(f" {error.value}") raise ToxError(f"group_send_custom_packet err={error.value}")
return result return bool(result)
def group_send_private_message(self, group_number, peer_id, message_type, message): def group_send_private_message(self, group_number, peer_id, message_type, message):
""" """
@ -2814,7 +2775,7 @@ class Tox:
LOG_ERROR(f"group_send_private_message {error.value} {s}") LOG_ERROR(f"group_send_private_message {error.value} {s}")
raise ToxError(f"group_send_private_message {error.value} {s}") raise ToxError(f"group_send_private_message {error.value} {s}")
return result return bool(result)
def group_send_message(self, group_number, type_, message): def group_send_message(self, group_number, type_, message):
""" """
@ -2857,11 +2818,9 @@ class Tox:
LOG_ERROR(f"group_send_message {error.value} {s}") LOG_ERROR(f"group_send_message {error.value} {s}")
raise ToxError(f"group_send_message {error.value} {s}") raise ToxError(f"group_send_message {error.value} {s}")
return result return bool(result)
# -----------------------------------------------------------------------------------------------------------------
# Group message receiving # Group message receiving
# -----------------------------------------------------------------------------------------------------------------
def callback_group_message(self, callback, user_data): def callback_group_message(self, callback, user_data):
""" """
@ -2921,9 +2880,7 @@ class Tox:
LOG_DEBUG(f"tox.callback_group_custom_packet") LOG_DEBUG(f"tox.callback_group_custom_packet")
Tox.libtoxcore.tox_callback_group_custom_packet(self._tox_pointer, self.group_custom_packet_cb) Tox.libtoxcore.tox_callback_group_custom_packet(self._tox_pointer, self.group_custom_packet_cb)
# -----------------------------------------------------------------------------------------------------------------
# Group chat inviting and join/part events # Group chat inviting and join/part events
# -----------------------------------------------------------------------------------------------------------------
def group_invite_friend(self, group_number, friend_number): def group_invite_friend(self, group_number, friend_number):
""" """
@ -2946,7 +2903,7 @@ class Tox:
s = sGetError(error.value, TOX_ERR_GROUP_INVITE_FRIEND) s = sGetError(error.value, TOX_ERR_GROUP_INVITE_FRIEND)
LOG_ERROR(f"group_invite_friend {error.value} {s}") LOG_ERROR(f"group_invite_friend {error.value} {s}")
raise ToxError(f"group_invite_friend {error.value} {s}") raise ToxError(f"group_invite_friend {error.value} {s}")
return result return bool(result)
# API change - this no longer exists # API change - this no longer exists
# @staticmethod # @staticmethod
@ -3004,7 +2961,7 @@ class Tox:
if error.value: if error.value:
s = sGetError(error.value, TOX_ERR_GROUP_INVITE_ACCEPT) s = sGetError(error.value, TOX_ERR_GROUP_INVITE_ACCEPT)
LOG_ERROR(f"group_invite_friend {error.value} {s}") LOG_ERROR(f"group_invite_friend {error.value} {s}")
raise ToxError(f"group_invite_accept {s} {error.value}") raise ToxError(f"group_invite_accept {s} err={error.value}")
return result return result
def callback_group_invite(self, callback, user_data): def callback_group_invite(self, callback, user_data):
@ -3139,9 +3096,7 @@ class Tox:
except Exception as e: except Exception as e:
LOG_ERROR(f"tox.callback_group_join_fail {e}") # req LOG_ERROR(f"tox.callback_group_join_fail {e}") # req
# -----------------------------------------------------------------------------------------------------------------
# Group chat founder controls (these only work for the group founder) # Group chat founder controls (these only work for the group founder)
# -----------------------------------------------------------------------------------------------------------------
def group_founder_set_password(self, group_number, password): def group_founder_set_password(self, group_number, password):
""" """
@ -3166,8 +3121,8 @@ class Tox:
if error.value: if error.value:
s = sGetError(error.value, TOX_ERR_GROUP_FOUNDER_SET_PASSWORD) s = sGetError(error.value, TOX_ERR_GROUP_FOUNDER_SET_PASSWORD)
LOG_ERROR(f"group_founder_set_password {error.value} {s}") LOG_ERROR(f"group_founder_set_password {error.value} {s}")
raise ToxError(f"group_founder_set_password {s} {error.value}") raise ToxError(f"group_founder_set_password {s} err={error.value}")
return result return bool(result)
def group_founder_set_privacy_state(self, group_number, privacy_state): def group_founder_set_privacy_state(self, group_number, privacy_state):
""" """
@ -3192,9 +3147,9 @@ class Tox:
result = Tox.libtoxcore.tox_group_founder_set_privacy_state(self._tox_pointer, c_uint(group_number), privacy_state, result = Tox.libtoxcore.tox_group_founder_set_privacy_state(self._tox_pointer, c_uint(group_number), privacy_state,
byref(error)) byref(error))
if error.value: if error.value:
LOG_ERROR(f" {error.value}") LOG_ERROR(f"group_founder_set_privacy_state err={error.value}")
raise ToxError(f" {error.value}") raise ToxError(f"group_founder_set_privacy_state err={error.value}")
return result return bool(result)
def group_founder_set_peer_limit(self, group_number, max_peers): def group_founder_set_peer_limit(self, group_number, max_peers):
""" """
@ -3218,13 +3173,11 @@ class Tox:
max_peers, max_peers,
byref(error)) byref(error))
if error.value: if error.value:
LOG_ERROR(f" {error.value}") LOG_ERROR(f"group_founder_set_peer_limit err={error.value}")
raise ToxError(f" {error.value}") raise ToxError(f"group_founder_set_peer_limit err={error.value}")
return result return bool(result)
# -----------------------------------------------------------------------------------------------------------------
# Group chat moderation # Group chat moderation
# -----------------------------------------------------------------------------------------------------------------
def group_mod_set_role(self, group_number, peer_id, role): def group_mod_set_role(self, group_number, peer_id, role):
""" """
@ -3247,9 +3200,9 @@ class Tox:
LOG_DEBUG(f"tox.group_mod_set_role") LOG_DEBUG(f"tox.group_mod_set_role")
result = Tox.libtoxcore.tox_group_mod_set_role(self._tox_pointer, c_uint(group_number), c_uint32(peer_id), role, byref(error)) result = Tox.libtoxcore.tox_group_mod_set_role(self._tox_pointer, c_uint(group_number), c_uint32(peer_id), role, byref(error))
if error.value: if error.value:
LOG_ERROR(f" {error.value}") LOG_ERROR(f"group_mod_set_role err={error.value}")
raise ToxError(f" {error.value}") raise ToxError(f"group_mod_set_role err={error.value}")
return result return bool(result)
def callback_group_moderation(self, callback, user_data): def callback_group_moderation(self, callback, user_data):
""" """
@ -3301,6 +3254,6 @@ class Tox:
c_bool(ignore), c_bool(ignore),
byref(error)) byref(error))
if error.value: if error.value:
LOG_ERROR(f"tox.group_set_ignore {error.value}") LOG_ERROR(f"tox.group_set_ignore err={error.value}")
raise ToxError("tox_group_set_ignore {error.value}") raise ToxError("tox_group_set_ignore err={error.value}")
return result return bool(result)

16
wrapper/toxav.py
View File

@ -22,9 +22,7 @@ class ToxAV:
peers. peers.
""" """
# -----------------------------------------------------------------------------------------------------------------
# Creation and destruction # Creation and destruction
# -----------------------------------------------------------------------------------------------------------------
def __init__(self, tox_pointer): def __init__(self, tox_pointer):
""" """
@ -69,9 +67,7 @@ class ToxAV:
self.libtoxav.toxav_get_tox.restype = POINTER(c_void_p) self.libtoxav.toxav_get_tox.restype = POINTER(c_void_p)
return self.libtoxav.toxav_get_tox(self._toxav_pointer) return self.libtoxav.toxav_get_tox(self._toxav_pointer)
# -----------------------------------------------------------------------------------------------------------------
# A/V event loop # A/V event loop
# -----------------------------------------------------------------------------------------------------------------
def iteration_interval(self): def iteration_interval(self):
""" """
@ -89,9 +85,7 @@ class ToxAV:
""" """
self.libtoxav.toxav_iterate(self._toxav_pointer) self.libtoxav.toxav_iterate(self._toxav_pointer)
# -----------------------------------------------------------------------------------------------------------------
# Call setup # Call setup
# -----------------------------------------------------------------------------------------------------------------
def call(self, friend_number, audio_bit_rate, video_bit_rate): def call(self, friend_number, audio_bit_rate, video_bit_rate):
""" """
@ -181,9 +175,7 @@ class ToxAV:
elif toxav_err_answer == TOXAV_ERR_ANSWER['INVALID_BIT_RATE']: elif toxav_err_answer == TOXAV_ERR_ANSWER['INVALID_BIT_RATE']:
raise ArgumentError('Audio or video bit rate is invalid.') raise ArgumentError('Audio or video bit rate is invalid.')
# -----------------------------------------------------------------------------------------------------------------
# Call state graph # Call state graph
# -----------------------------------------------------------------------------------------------------------------
def callback_call_state(self, callback, user_data): def callback_call_state(self, callback, user_data):
""" """
@ -208,9 +200,7 @@ class ToxAV:
self.call_state_cb = c_callback(callback) self.call_state_cb = c_callback(callback)
self.libtoxav.toxav_callback_call_state(self._toxav_pointer, self.call_state_cb, user_data) self.libtoxav.toxav_callback_call_state(self._toxav_pointer, self.call_state_cb, user_data)
# -----------------------------------------------------------------------------------------------------------------
# Call control # Call control
# -----------------------------------------------------------------------------------------------------------------
def call_control(self, friend_number, control): def call_control(self, friend_number, control):
""" """
@ -238,13 +228,9 @@ class ToxAV:
raise RuntimeError('Happens if user tried to pause an already paused call or if trying to resume a call ' raise RuntimeError('Happens if user tried to pause an already paused call or if trying to resume a call '
'that is not paused.') 'that is not paused.')
# -----------------------------------------------------------------------------------------------------------------
# TODO Controlling bit rates # TODO Controlling bit rates
# -----------------------------------------------------------------------------------------------------------------
# -----------------------------------------------------------------------------------------------------------------
# A/V sending # A/V sending
# -----------------------------------------------------------------------------------------------------------------
def audio_send_frame(self, friend_number, pcm, sample_count, channels, sampling_rate): def audio_send_frame(self, friend_number, pcm, sample_count, channels, sampling_rate):
""" """
@ -331,9 +317,7 @@ class ToxAV:
elif toxav_err_send_frame == TOXAV_ERR_SEND_FRAME['RTP_FAILED']: elif toxav_err_send_frame == TOXAV_ERR_SEND_FRAME['RTP_FAILED']:
RuntimeError('Failed to push frame through rtp interface.') RuntimeError('Failed to push frame through rtp interface.')
# -----------------------------------------------------------------------------------------------------------------
# A/V receiving # A/V receiving
# -----------------------------------------------------------------------------------------------------------------
def callback_audio_receive_frame(self, callback, user_data): def callback_audio_receive_frame(self, callback, user_data):
""" """

199
wrapper_tests/tests_wrapper.py
View File

@ -423,13 +423,13 @@ class ToxSuite(unittest.TestCase):
LOG.debug(f"call_bootstrap ts.bootstrap_tcp {len(lElts)}") LOG.debug(f"call_bootstrap ts.bootstrap_tcp {len(lElts)}")
ts.bootstrap_tcp(lElts, lToxes) ts.bootstrap_tcp(lElts, lToxes)
def group_until_connected(self, group_number, num=None, iMax=THRESHOLD): def group_until_connected(self, otox, group_number, num=None, iMax=THRESHOLD):
""" """
""" """
i = 0 i = 0
bRet = None bRet = None
while i <= iMax : while i <= iMax :
iRet = self.bob.group_is_connected(group_number) iRet = otox.group_is_connected(group_number)
if iRet == True or iRet == 0: if iRet == True or iRet == 0:
bRet = True bRet = True
break break
@ -441,24 +441,24 @@ class ToxSuite(unittest.TestCase):
LOG.info(s+"group_until_connected " \ LOG.info(s+"group_until_connected " \
+" #" + str(i) \ +" #" + str(i) \
+" iRet=" +repr(iRet) \ +" iRet=" +repr(iRet) \
+f" BOBS={self.bob.mycon_status}" \ +f" BOBS={otox.mycon_status}" \
+f" last={int(self.bob.mycon_time)}" ) +f" last={int(otox.mycon_time)}" )
i += 1 i += 1
self.loop(100) self.loop(100)
else: else:
bRet = False bRet = False
if bRet: if bRet:
LOG.info(f"group_until_connected returning True {i}" \ LOG.info(f"group_until_connected True i={i}" \
+f"iMax={iMax}" \ +f" iMax={iMax}" \
+f" BOB={self.bob.self_get_connection_status()}" \ +f" BOB={otox.self_get_connection_status()}" \
+f" last={int(self.bob.mycon_time)}" ) +f" last={int(otox.mycon_time)}" )
return True return True
else: else:
LOG.warning(f"group_until_connected returning False {i}" \ LOG.warning(f"group_until_connected False i={i}" \
+f"iMax={iMax}" \ +f" iMax={iMax}" \
+f" BOB={self.bob.self_get_connection_status()}" \ +f" BOB={otox.self_get_connection_status()}" \
+f" last={int(self.bob.mycon_time)}" ) +f" last={int(otox.mycon_time)}" )
return False return False
def loop_until_connected(self, num=None): def loop_until_connected(self, num=None):
@ -466,6 +466,7 @@ class ToxSuite(unittest.TestCase):
t:on_self_connection_status t:on_self_connection_status
t:self_get_connection_status t:self_get_connection_status
""" """
global THRESHOLD
i = 0 i = 0
bRet = None bRet = None
while i <= THRESHOLD : while i <= THRESHOLD :
@ -509,6 +510,7 @@ class ToxSuite(unittest.TestCase):
+f" last={int(self.bob.mycon_time)}" ) +f" last={int(self.bob.mycon_time)}" )
return True return True
else: else:
THRESHOLD += 5
LOG.warning(f"loop_until_connected returning False {i}" \ LOG.warning(f"loop_until_connected returning False {i}" \
+f" BOB={self.bob.self_get_connection_status()}" \ +f" BOB={self.bob.self_get_connection_status()}" \
+f" ALICE={self.alice.self_get_connection_status()}" \ +f" ALICE={self.alice.self_get_connection_status()}" \
@ -516,6 +518,7 @@ class ToxSuite(unittest.TestCase):
return False return False
def wait_objs_attr(self, objs, attr): def wait_objs_attr(self, objs, attr):
global THRESHOLD
i = 0 i = 0
while i <= THRESHOLD: while i <= THRESHOLD:
if i % 5 == 0: if i % 5 == 0:
@ -529,7 +532,8 @@ class ToxSuite(unittest.TestCase):
self.loop(100) self.loop(100)
i += 1 i += 1
else: else:
LOG.error(f"wait_objs_attr for {attr} i >= {THRESHOLD}") THRESHOLD += 1
LOG.warn(f"wait_objs_attr for {attr} i >= {THRESHOLD}")
return all([getattr(obj, attr) is not None for obj in objs]) return all([getattr(obj, attr) is not None for obj in objs])
@ -830,7 +834,8 @@ class ToxSuite(unittest.TestCase):
assert otox.group_get_topic_size(iGrp) == len(topic) assert otox.group_get_topic_size(iGrp) == len(topic)
name = otox.group_get_name(iGrp) name = otox.group_get_name(iGrp)
if type(name) == bytes: name = str(name, 'utf-8') if type(name) == bytes:
name = str(name, 'utf-8')
assert name == group_name, name assert name == group_name, name
assert otox.group_get_name_size(iGrp) == len(group_name) assert otox.group_get_name_size(iGrp) == len(group_name)
@ -843,6 +848,60 @@ class ToxSuite(unittest.TestCase):
LOG.info(f"group pK={sPk} iGrp={iGrp} n={otox.group_get_number_groups()}") LOG.info(f"group pK={sPk} iGrp={iGrp} n={otox.group_get_number_groups()}")
return iGrp return iGrp
def otox_verify_group(self, otox, iGrp):
"""
group_self_get_name
group_self_get_peer_id
group_self_get_public_key
group_self_get_role
group_self_get_status
"""
group_number = iGrp
assert type(iGrp) == int, "otox_test_groups_join iGrp not an int"
assert iGrp < UINT32_MAX, "otox_test_groups_join iGrp failure UINT32_MAX"
assert iGrp >= 0, f"otox_test_groups_join iGrp={iGrp} < 0"
sGrp = otox.group_get_chat_id(iGrp)
assert len(sGrp) == enums.TOX_GROUP_CHAT_ID_SIZE * 2, \
f"group sGrp={sGrp} {len(sGrp)} != {enums.TOX_GROUP_CHAT_ID_SIZE * 2}"
sPk = otox.group_self_get_public_key(iGrp)
LOG.info(f"otox_verify_group sPk={sPk} iGrp={iGrp} n={otox.group_get_number_groups()}")
sName = otox.group_self_get_name(iGrp)
iStat = otox.group_self_get_status(iGrp)
iId = otox.group_self_get_peer_id(iGrp)
iRole = otox.group_self_get_role(iGrp)
iStat = otox.group_self_get_status(iGrp)
LOG.info(f"otox_verify_group sName={sName} iStat={iStat} iId={iId} iRole={iRole} iStat={iStat}")
try:
bRet = otox.group_is_connected(iGrp)
except Exception as e:
LOG.warn(f"group_is_connected EXCEPTION {e}")
return -1
# chat->connection_state == CS_CONNECTED || chat->connection_state == CS_CONNECTING;
if not bRet:
LOG.warn(f"group_is_connected WARN not connected iGrp={iGrp} n={otox.group_get_number_groups()}")
else:
LOG.info(f"group_is_connected SUCCESS connected iGrp={iGrp} n={otox.group_get_number_groups()}")
try:
bRet = self.group_until_connected(otox, iGrp, iMax=2*THRESHOLD)
except Exception as e:
LOG.error(f"group_until_connected EXCEPTION {e}")
return -1
# chat->connection_state == CS_CONNECTED || chat->connection_state == CS_CONNECTING;
if bRet:
LOG.warn(f"group_until_connected WARN not connected iGrp={iGrp} n={otox.group_get_number_groups()}")
else:
LOG.info(f"group_until_connected SUCCESS connected iGrp={iGrp} n={otox.group_get_number_groups()}")
message = bytes('hello', 'utf-8')
bRet = otox.group_send_message(iGrp, TOX_MESSAGE_TYPE['NORMAL'], message)
if not bRet:
LOG.warn(f"group_send_message {bRet}")
else:
LOG.debug(f"group_send_message {bRet}")
# 360497DA684BCE2A500C1AF9B3A5CE949BBB9F6FB1F91589806FB04CA039E313 # 360497DA684BCE2A500C1AF9B3A5CE949BBB9F6FB1F91589806FB04CA039E313
# 75D2163C19FEFFE51508046398202DDC321E6F9B6654E99BAE45FFEC134F05DE # 75D2163C19FEFFE51508046398202DDC321E6F9B6654E99BAE45FFEC134F05DE
def otox_test_groups_join(self, otox, def otox_test_groups_join(self, otox,
@ -854,43 +913,16 @@ class ToxSuite(unittest.TestCase):
password = '' password = ''
LOG.debug(f"group_join nick={nick} chat_id={chat_id}") LOG.debug(f"group_join nick={nick} chat_id={chat_id}")
try: try:
group_number = otox.group_join(chat_id, password, nick, status) iGrp = otox.group_join(chat_id, password, nick, status)
LOG.info(f"otox_test_groups_join SUCCESS group_number={group_number} chat_id={chat_id}") LOG.info(f"otox_test_groups_join SUCCESS iGrp={iGrp} chat_id={chat_id}")
assert type(group_number) == int, "otox_test_groups_join group_number not an int" self.otox_verify_group(otox, iGrp)
assert group_number < UINT32_MAX, "otox_test_groups_join group_number failure UINT32_MAX"
assert group_number >= 0, f"otox_test_groups_join group_number={group_number} < 0"
iGrp = group_number
sPk = otox.group_self_get_public_key(iGrp)
LOG.info(f"otox_test_groups_join pK={sPk} iGrp={iGrp} n={otox.group_get_number_groups()}")
except Exception as e: except Exception as e:
# gui # gui
LOG.error(f"otox_test_groups_join EXCEPTION {e}") LOG.error(f"otox_test_groups_join EXCEPTION {e}")
raise raise
try: return iGrp
bRet = otox.group_is_connected(group_number)
except Exception as e:
LOG.error(f"group_is_connected EXCEPTION {e}")
return -1
# chat->connection_state == CS_CONNECTED || chat->connection_state == CS_CONNECTING;
if bRet:
LOG.warn(f"group_is_connected WARN not connected group_number={group_number} n={otox.group_get_number_groups()}")
else:
LOG.info(f"group_is_connected SUCCESS connected group_number={group_number} n={otox.group_get_number_groups()}")
try:
bRet = self.group_until_connected(group_number, iMax=2*THRESHOLD)
except Exception as e:
LOG.error(f"group_until_connected EXCEPTION {e}")
return -1
# chat->connection_state == CS_CONNECTED || chat->connection_state == CS_CONNECTING;
if bRet:
LOG.warn(f"group_until_connected WARN not connected group_number={group_number} n={otox.group_get_number_groups()}")
else:
LOG.info(f"group_until_connected SUCCESS connected group_number={group_number} n={otox.group_get_number_groups()}")
return group_number
def otox_test_groups(self, def otox_test_groups(self,
otox, otox,
@ -898,54 +930,13 @@ class ToxSuite(unittest.TestCase):
nick='test_nick', nick='test_nick',
topic='Test Topic', # str topic='Test Topic', # str
): ):
iGrp = self.otox_test_groups_create(otox, group_name, nick, topic)
sGrp = otox.group_get_chat_id(iGrp)
assert len(sGrp) == enums.TOX_GROUP_CHAT_ID_SIZE * 2, \
f"group sGrp={sGrp} {len(sGrp)} != {enums.TOX_GROUP_CHAT_ID_SIZE * 2}"
LOG.info(f"group sGrp={sGrp}")
if False:
# already joined
try:
iNum = otox.group_join(sGrp, None, nick)
# :return group_number on success, UINT32_MAX on failure.
except Exception as e:
LOG.error(f"group_join ERROR {e}")
if str(e).find('2') >= 0:
iNum = iGrp
else:
LOG.debug('\n' + traceback.format_exc())
iNum = -1
if iNum < 0:
return iGrp
#?
group_number = iGrp
try:
bRet = otox.group_is_connected(group_number)
except Exception as e:
LOG.error(f"group_is_connected ERROR {e}")
return -1
try: try:
bRet = self.group_until_connected(group_number, iMax=2*THRESHOLD) iGrp = self.otox_test_groups_create(otox, group_name, nick, topic)
self.otox_verify_group(otox, iGrp)
except Exception as e: except Exception as e:
LOG.error(f"group_until_connected EXCEPTION {e}") LOG.error(f"otox_test_groups ERROR {e}")
return -1 raise
# chat->connection_state == CS_CONNECTED || chat->connection_state == CS_CONNECTING;
if bRet:
LOG.warn(f"group_until_connected WARN not connected group_number={group_number} n={otox.group_get_number_groups()}")
else:
LOG.info(f"group_until_connected SUCCESS connected group_number={group_number} n={otox.group_get_number_groups()}")
message = bytes('hello', 'utf-8')
try:
bRet = otox.group_send_message(group_number, TOX_MESSAGE_TYPE['NORMAL'], 'hello')
if not bRet:
LOG.warn(f"group_send_message {bRet}")
else:
LOG.debug(f"group_send_message {bRet}")
except Exception as e:
LOG.error(f"group_send_message ERROR {e}")
# unfinished # unfinished
# tox_group_peer_exit_cb # tox_group_peer_exit_cb
@ -1444,8 +1435,8 @@ class ToxSuite(unittest.TestCase):
LOG.error(f"bob.group_leave EXCEPTION {e}") LOG.error(f"bob.group_leave EXCEPTION {e}")
raise raise
@unittest.skip("double free or corruption (fasttop)") #? @unittest.skip("double free or corruption (fasttop)")
# @expectedFail('fails') # assertion fails on == MSG @expectedFail('fails') # assertion fails on == MSG
def test_on_friend_status_message(self): # fails def test_on_friend_status_message(self): # fails
""" """
t:self_set_status_message t:self_set_status_message
@ -1472,9 +1463,12 @@ class ToxSuite(unittest.TestCase):
setattr(self.bob, sSlot, None) setattr(self.bob, sSlot, None)
try: try:
if bUSE_NOREQUEST: if bUSE_NOREQUEST:
assert self.both_add_as_friend_norequest() assert self.bob_add_alice_as_friend_norequest()
# assert self.alice_add_bob_as_friend_norequest()
else: else:
assert self.both_add_as_friend() # no not connected error
assert self.bob_add_alice_as_friend()
# assert self.alice_add_bob_as_friend_norequest()
self.bob.callback_friend_status_message(bob_on_friend_status_message) self.bob.callback_friend_status_message(bob_on_friend_status_message)
self.warn_if_no_cb(self.bob, sSlot) self.warn_if_no_cb(self.bob, sSlot)
@ -1508,15 +1502,16 @@ class ToxSuite(unittest.TestCase):
t:on_friend_name t:on_friend_name
""" """
#: Test friend request
if bUSE_NOREQUEST:
assert self.bob_add_alice_as_friend_norequest()
assert self.alice_add_bob_as_friend_norequest()
else:
# no not connected error
assert self.bob_add_alice_as_friend()
assert self.alice_add_bob_as_friend()
try: try:
#: Test friend request
if bUSE_NOREQUEST:
assert self.bob_add_alice_as_friend_norequest()
assert self.alice_add_bob_as_friend_norequest()
else:
# no not connected error
assert self.bob_add_alice_as_friend()
assert self.alice_add_bob_as_friend_norequest()
a = self.alice.self_get_address()[:CLIENT_ID_SIZE] a = self.alice.self_get_address()[:CLIENT_ID_SIZE]
assert self.bob.friend_get_public_key(self.baid) == a, \ assert self.bob.friend_get_public_key(self.baid) == a, \
LOG.error(f"test_friend BAID {a}") LOG.error(f"test_friend BAID {a}")