emdee/toxygen
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

generated wrapper without callbacks docs and errors check

Browse source
This commit is contained in:
ingvar1995 2016-06-24 14:24:28 +03:00
parent c767ebe530
commit c0601444d9
1 changed files with 913 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

913
toxygen/tox.py
View file

@ -92,6 +92,22 @@ class Tox:
self.file_recv_chunk_cb = None
self.friend_lossy_packet_cb = None
self.friend_lossless_packet_cb = None
self.group_moderation_cb = None
self.group_join_fail_cb = None
self.group_self_join_cb = None
self.group_invite_cb = None
self.group_custom_packet_cb = None
self.group_private_message_cb = None
self.group_private_message_cb = None
self.group_message_cb = None
self.group_password_cb = None
self.group_peer_limit_cb = None
self.group_privacy_state_cb = None
self.group_topic_cb = None
self.group_peer_status_cb = None
self.group_peer_name_cb = None
self.group_peer_exit_cb = None
self.group_peer_join_cb = None
self.AV = ToxAV(self._tox_pointer)
@ -1510,3 +1526,900 @@ class Tox:
return result
elif tox_err_get_port == TOX_ERR_GET_PORT['NOT_BOUND']:
raise RuntimeError('The instance was not bound to any port.')
# -----------------------------------------------------------------------------------------------------------------
# Group chat instance management
# -----------------------------------------------------------------------------------------------------------------
def group_new(self, privacy_state, group_name):
"""
Creates a new group chat.
This function creates a new group chat object and adds it to the chats array.
The client should initiate its peer list with self info after calling this function, as
the peer_join callback will not be triggered.
:param privacy_state: The privacy state of the group. If this is set to TOX_GROUP_PRIVACY_STATE_PUBLIC,
the group will attempt to announce itself to the DHT and anyone with the Chat ID may join.
Otherwise a friend invite will be required to join the group.
:param group_name: The name of the group. The name must be non-NULL.
:return groupnumber on success, UINT32_MAX on failure.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_new(self._tox_pointer, privacy_state, group_name,
len(group_name), byref(error))
return result
def group_join(self, chat_id, password):
"""
Joins a group chat with specified Chat ID.
This function creates a new group chat object, adds it to the chats array, and sends
a DHT announcement to find peers in the group associated with chat_id. Once a peer has been
found a join attempt will be initiated.
:param chat_id: The Chat ID of the group you wish to join. This must be TOX_GROUP_CHAT_ID_SIZE bytes.
:param password: The password required to join the group. Set to NULL if no password is required.
:return groupnumber on success, UINT32_MAX on failure.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_join(self._tox_pointer, chat_id, password, len(password), byref(error))
return result
def group_reconnect(self, groupnumber):
"""
Reconnects to a group.
This function disconnects from all peers in the group, then attempts to reconnect with the group.
The caller's state is not changed (i.e. name, status, role, chat public key etc.)
:param groupnumber: The group number of the group we wish to reconnect to.
:return True on success.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_reconnect(self._tox_pointer, groupnumber, byref(error))
return result
def group_leave(self, groupnumber, message):
"""
Leaves a group.
This function sends a parting packet containing a custom (non-obligatory) message to all
peers in a group, and deletes the group from the chat array. All group state information is permanently
lost, including keys and role credentials.
:param groupnumber: The group number of the group we wish to leave.
:param message: The parting message to be sent to all the peers. Set to NULL if we do not wish to
send a parting message.
:return True if the group chat instance was successfully deleted.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_leave(self._tox_pointer, groupnumber, message, len(message), byref(error))
return result
# -----------------------------------------------------------------------------------------------------------------
# Group user-visible client information (nickname/status/role/public key)
# -----------------------------------------------------------------------------------------------------------------
def group_self_set_name(self, groupnumber, name):
"""
Set the client's nickname for the group instance designated by the given group number.
Nickname length cannot exceed TOX_MAX_NAME_LENGTH. If length is equal to zero or name is a NULL
pointer, the function call will fail.
:param name: A byte array containing the new nickname.
:return True on success.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_self_set_name(self._tox_pointer, groupnumber, name, len(name), byref(error))
return result
def group_self_get_name_size(self, groupnumber):
"""
Return the length of the client's current nickname for the group instance designated
by groupnumber as passed to tox_group_self_set_name.
If no nickname was set before calling this function, the name is empty,
and this function returns 0.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_self_get_name_size(self._tox_pointer, groupnumber, byref(error))
return result
def group_self_get_name(self, groupnumber):
"""
Write the nickname set by tox_group_self_set_name to a byte array.
If no nickname was set before calling this function, the name is empty,
and this function has no effect.
Call tox_group_self_get_name_size to find out how much memory to allocate for the result.
:return nickname
"""
error = c_int()
size = self.group_self_get_name_size(groupnumber)
name = create_string_buffer(size)
result = Tox.libtoxcore.tox_group_self_get_name(self._tox_pointer, groupnumber, name, byref(error))
return str(name[:size], 'utf-8')
def group_self_set_status(self, groupnumber, status):
"""
Set the client's status for the group instance. Status must be a TOX_USER_STATUS.
:return True on success.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_self_set_status(self._tox_pointer, groupnumber, status, byref(error))
return result
def group_self_get_status(self, groupnumber):
"""
returns the client's status for the group instance on success.
return value is unspecified on failure.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_self_get_status(self._tox_pointer, groupnumber, byref(error))
return result
def group_self_get_role(self, groupnumber):
"""
returns the client's role for the group instance on success.
return value is unspecified on failure.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_self_get_role(self._tox_pointer, groupnumber, byref(error))
return result
def group_self_get_peer_id(self, groupnumber):
"""
returns the client's peer id for the group instance on success.
return value is unspecified on failure.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_self_get_peer_id(self._tox_pointer, groupnumber, byref(error))
return result
def group_self_get_public_key(self, groupnumber):
"""
Write the client's group public key designated by the given group number to a byte array.
This key will be permanently tied to the client's identity for this particular group until
the client explicitly leaves the group or gets kicked/banned. This key is the only way for
other peers to reliably identify the client across client restarts.
`public_key` should have room for at least TOX_GROUP_PEER_PUBLIC_KEY_SIZE bytes.
:return public key
"""
error = c_int()
key = create_string_buffer(TOX_GROUP_PEER_PUBLIC_KEY_SIZE)
result = Tox.libtoxcore.tox_group_self_get_public_key(self._tox_pointer, groupnumber,
key, byref(error))
return bin_to_string(key, TOX_GROUP_PEER_PUBLIC_KEY_SIZE)
# -----------------------------------------------------------------------------------------------------------------
# Peer-specific group state queries.
# -----------------------------------------------------------------------------------------------------------------
def group_peer_get_name_size(self, groupnumber, peer_id):
"""
Return the length of the peer's name. If the group number or ID is invalid, the
return value is unspecified.
The return value is equal to the `length` argument received by the last
`group_peer_name` callback.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_peer_get_name_size(self._tox_pointer, groupnumber, peer_id, byref(error))
return result
def group_peer_get_name(self, groupnumber, peer_id):
"""
Write the name of the peer designated by the given ID to a byte
array.
Call tox_group_peer_get_name_size to determine the allocation size for the `name` parameter.
The data written to `name` is equal to the data received by the last
`group_peer_name` callback.
:param groupnumber: The group number of the group we wish to query.
:param peer_id: The ID of the peer whose name we want to retrieve.
:return name.
"""
error = c_int()
size = self.group_peer_get_name_size(groupnumber, peer_id)
name = create_string_buffer(size)
result = Tox.libtoxcore.tox_group_peer_get_name(self._tox_pointer, groupnumber, peer_id, name, byref(error))
return str(name[:], 'utf-8')
def group_peer_get_status(self, groupnumber, peer_id):
"""
Return the peer's user status (away/busy/...). If the ID or group number is
invalid, the return value is unspecified.
The status returned is equal to the last status received through the
`group_peer_status` callback.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_peer_get_status(self._tox_pointer, groupnumber, peer_id, byref(error))
return result
def group_peer_get_role(self, groupnumber, peer_id):
"""
Return the peer's role (user/moderator/founder...). If the ID or group number is
invalid, the return value is unspecified.
The role returned is equal to the last role received through the
`group_moderation` callback.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_peer_get_role(self._tox_pointer, groupnumber, peer_id, byref(error))
return result
def group_peer_get_public_key(self, groupnumber, peer_id):
"""
Write the group public key with the designated peer_id for the designated group number to public_key.
This key will be parmanently tied to a particular peer until they explicitly leave the group or
get kicked/banned, and is the only way to reliably identify the same peer across client restarts.
`public_key` should have room for at least TOX_GROUP_PEER_PUBLIC_KEY_SIZE bytes.
:return public key
"""
error = c_int()
key = create_string_buffer(TOX_GROUP_PEER_PUBLIC_KEY_SIZE)
result = Tox.libtoxcore.tox_group_peer_get_public_key(self._tox_pointer, groupnumber, peer_id,
key, byref(error))
return bin_to_string(key, TOX_GROUP_PEER_PUBLIC_KEY_SIZE)
def callback_group_peer_name(self, callback, user_data):
"""
Set the callback for the `group_peer_name` event. Pass NULL to unset.
This event is triggered when a peer changes their nickname.
"""
c_callback = CFUNCTYPE(None, c_void_p, c_uint32, c_uint32, c_char_p, c_size_t, c_void_p)
self.group_peer_name_cb = c_callback(callback)
Tox.libtoxcore.tox_callback_group_peer_name(self._tox_pointer, self.group_peer_name_cb, user_data)
def callback_group_peer_status(self, callback, user_data):
"""
Set the callback for the `group_peer_status` event. Pass NULL to unset.
This event is triggered when a peer changes their status.
"""
c_callback = CFUNCTYPE(None, c_void_p, c_uint32, c_uint32, c_int, c_void_p)
self.group_peer_status_cb = c_callback(callback)
Tox.libtoxcore.tox_callback_group_peer_status(self._tox_pointer, self.group_peer_status_cb, user_data)
# -----------------------------------------------------------------------------------------------------------------
# Group chat state queries and events.
# -----------------------------------------------------------------------------------------------------------------
def group_set_topic(self, groupnumber, topic):
"""
Set the group topic and broadcast it to the rest of the group.
topic length cannot be longer than TOX_GROUP_MAX_TOPIC_LENGTH. If length is equal to zero or
topic is set to NULL, the topic will be unset.
:return True on success.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_set_topic(self._tox_pointer, groupnumber, topic, len(topic), byref(error))
return result
def group_get_topic_size(self, groupnumber):
"""
Return the length of the group topic. If the group number is invalid, the
return value is unspecified.
The return value is equal to the `length` argument received by the last
`group_topic` callback.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_get_topic_size(self._tox_pointer, groupnumber, byref(error))
return result
def group_get_topic(self, groupnumber):
"""
Write the topic designated by the given group number to a byte array.
Call tox_group_get_topic_size to determine the allocation size for the `topic` parameter.
The data written to `topic` is equal to the data received by the last
`group_topic` callback.
:return topic
"""
error = c_int()
size = self.group_get_topic_size(groupnumber)
topic = create_string_buffer(size)
result = Tox.libtoxcore.tox_group_get_topic(self._tox_pointer, groupnumber, topic, byref(error))
return str(topic[:size], 'utf-8')
def group_get_name_size(self, groupnumber):
"""
Return the length of the group name. If the group number is invalid, the
return value is unspecified.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_get_name_size(self._tox_pointer, groupnumber, byref(error))
return result
def group_get_name(self, groupnumber):
"""
Write the name of the group designated by the given group number to a byte array.
Call tox_group_get_name_size to determine the allocation size for the `name` parameter.
:return true on success.
"""
error = c_int()
size = self.group_get_name_size(groupnumber)
name = create_string_buffer(size)
result = Tox.libtoxcore.tox_group_get_name(self._tox_pointer, groupnumber,
name, byref(error))
return str(name[:size], 'utf-8')
def group_get_chat_id(self, groupnumber):
"""
Write the Chat ID designated by the given group number to a byte array.
`chat_id` should have room for at least TOX_GROUP_CHAT_ID_SIZE bytes.
:return true on success.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_get_chat_id(self._tox_pointer, groupnumber,
create_string_buffer(TOX_GROUP_CHAT_ID_SIZE), byref(error))
return result
def group_get_number_groups(self):
"""
Return the number of groups in the Tox chats array.
"""
result = Tox.libtoxcore.tox_group_get_number_groups(self._tox_pointer)
return result
def group_get_privacy_state(self, groupnumber):
"""
Return the privacy state of the group designated by the given group number. If group number
is invalid, the return value is unspecified.
The value returned is equal to the data received by the last
`group_privacy_state` callback.
see the `Group chat founder controls` section for the respective set function.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_get_privacy_state(self._tox_pointer, groupnumber, byref(error))
return result
def group_get_peer_limit(self, groupnumber):
"""
Return the maximum number of peers allowed for the group designated by the given group number.
If the group number is invalid, the return value is unspecified.
The value returned is equal to the data received by the last
`group_peer_limit` callback.
see the `Group chat founder controls` section for the respective set function.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_get_peer_limit(self._tox_pointer, groupnumber, byref(error))
return result
def group_get_password_size(self, groupnumber):
"""
Return the length of the group password. If the group number is invalid, the
return value is unspecified.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_get_password_size(self._tox_pointer, groupnumber, byref(error))
return result
def group_get_password(self, groupnumber):
"""
Write the password for the group designated by the given group number to a byte array.
Call tox_group_get_password_size to determine the allocation size for the `password` parameter.
The data received is equal to the data received by the last
`group_password` callback.
see the `Group chat founder controls` section for the respective set function.
:return true on success.
"""
error = c_int()
size = self.group_get_password_size(groupnumber)
password = create_string_buffer(size)
result = Tox.libtoxcore.tox_group_get_password(self._tox_pointer, groupnumber,
password, byref(error))
return str(password[:size], 'utf-8')
def callback_group_topic(self, callback, user_data):
"""
Set the callback for the `group_topic` event. Pass NULL to unset.
This event is triggered when a peer changes the group topic.
"""
c_callback = CFUNCTYPE(None, c_void_p, c_uint32, c_uint32, c_char_p, c_size_t, c_void_p)
self.group_topic_cb = c_callback(callback)
Tox.libtoxcore.tox_callback_group_topic(self._tox_pointer, self.group_topic_cb, user_data)
def callback_group_privacy_state(self, callback, user_data):
"""
Set the callback for the `group_privacy_state` event. Pass NULL to unset.
This event is triggered when the group founder changes the privacy state.
"""
c_callback = CFUNCTYPE(None, c_void_p, c_uint32, c_int, c_void_p)
self.group_privacy_state_cb = c_callback(callback)
Tox.libtoxcore.tox_callback_group_privacy_state(self._tox_pointer, self.group_privacy_state_cb, user_data)
def callback_group_peer_limit(self, callback, user_data):
"""
Set the callback for the `group_peer_limit` event. Pass NULL to unset.
This event is triggered when the group founder changes the maximum peer limit.
"""
c_callback = CFUNCTYPE(None, c_void_p, c_uint32, c_uint32, c_void_p)
self.group_peer_limit_cb = c_callback(callback)
Tox.libtoxcore.tox_callback_group_peer_limit(self._tox_pointer, self.group_peer_limit_cb, user_data)
def callback_group_password(self, callback, user_data):
"""
Set the callback for the `group_password` event. Pass NULL to unset.
This event is triggered when the group founder changes the group password.
"""
c_callback = CFUNCTYPE(None, c_void_p, c_uint32, c_char_p, c_size_t, c_void_p)
self.group_password_cb = c_callback(callback)
Tox.libtoxcore.tox_callback_group_password(self._tox_pointer, self.group_password_cb, user_data)
# -----------------------------------------------------------------------------------------------------------------
# Group message sending
# -----------------------------------------------------------------------------------------------------------------
def group_send_custom_packet(self, groupnumber, lossless, data):
"""
Send a custom packet to the group.
If lossless is true the packet will be lossless. Lossless packet behaviour is comparable
to TCP (reliability, arrive in order) but with packets instead of a stream.
If lossless is false, the packet will be lossy. Lossy packets behave like UDP packets,
meaning they might never reach the other side or might arrive more than once (if someone
is messing with the connection) or might arrive in the wrong order.
Unless latency is an issue or message reliability is not important, it is recommended that you use
lossless custom packets.
:param groupnumber: The group number of the group the message is intended for.
:param lossless: True if the packet should be lossless.
:param data A byte array containing the packet data.
:return True on success.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_send_custom_packet(self._tox_pointer, groupnumber, lossless, data,
len(data), byref(error))
return result
def group_send_private_message(self, groupnumber, peer_id, message):
"""
Send a text chat message to the specified peer in the specified group.
This function creates a group private message packet and pushes it into the send
queue.
The message length may not exceed TOX_MAX_MESSAGE_LENGTH. Larger messages
must be split by the client and sent as separate messages. Other clients can
then reassemble the fragments. Messages may not be empty.
:param groupnumber: The group number of the group the message is intended for.
:param peer_id: The ID of the peer the message is intended for.
:param message: A non-NULL pointer to the first element of a byte array containing the message text.
:return True on success.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_send_private_message(self._tox_pointer, groupnumber, peer_id, message,
len(message), byref(error))
return result
def group_send_message(self, groupnumber, type, message):
"""
Send a text chat message to the group.
This function creates a group message packet and pushes it into the send
queue.
The message length may not exceed TOX_MAX_MESSAGE_LENGTH. Larger messages
must be split by the client and sent as separate messages. Other clients can
then reassemble the fragments. Messages may not be empty.
:param groupnumber: The group number of the group the message is intended for.
:param type: Message type (normal, action, ...).
:param message: A non-NULL pointer to the first element of a byte array containing the message text.
:return True on success.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_send_message(self._tox_pointer, groupnumber, type, message, len(message),
byref(error))
return result
# -----------------------------------------------------------------------------------------------------------------
# Group message receiving
# -----------------------------------------------------------------------------------------------------------------
def callback_group_message(self, callback, user_data):
"""
Set the callback for the `group_message` event. Pass NULL to unset.
This event is triggered when the client receives a group message.
"""
c_callback = CFUNCTYPE(None, c_void_p, c_uint32, c_uint32, c_int, c_char_p, c_size_t, c_void_p)
self.group_message_cb = c_callback(callback)
Tox.libtoxcore.tox_callback_group_message(self._tox_pointer, self.group_message_cb, user_data)
def callback_group_private_message(self, callback, user_data):
"""
Set the callback for the `group_private_message` event. Pass NULL to unset.
This event is triggered when the client receives a private message.
"""
c_callback = CFUNCTYPE(None, c_void_p, c_uint32, c_uint32, c_char_p, c_size_t, c_void_p)
self.group_private_message_cb = c_callback(callback)
Tox.libtoxcore.tox_callback_group_private_message(self._tox_pointer, self.group_private_message_cb, user_data)
def callback_group_custom_packet(self, callback, user_data):
"""
Set the callback for the `group_custom_packet` event. Pass NULL to unset.
This event is triggered when the client receives a custom packet.
"""
c_callback = CFUNCTYPE(None, c_void_p, c_uint32, c_uint32, POINTER(c_uint8), c_void_p)
self.group_custom_packet_cb = c_callback(callback)
Tox.libtoxcore.tox_callback_group_custom_packet(self._tox_pointer, self.group_custom_packet_cb, user_data)
# -----------------------------------------------------------------------------------------------------------------
# Group chat inviting and join/part events
# -----------------------------------------------------------------------------------------------------------------
def group_invite_friend(self, groupnumber, friend_number):
"""
Invite a friend to a group.
This function creates an invite request packet and pushes it to the send queue.
:param groupnumber: The group number of the group the message is intended for.
:param friend_number: The friend number of the friend the invite is intended for.
:return True on success.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_invite_friend(self._tox_pointer, groupnumber, friend_number, byref(error))
return result
def group_invite_accept(self, invite_data, password):
"""
Accept an invite to a group chat that the client previously received from a friend. The invite
is only valid while the inviter is present in the group.
:param invite_data: The invite data received from the `group_invite` event.
:param password: The password required to join the group. Set to NULL if no password is required.
:return the groupnumber on success, UINT32_MAX on failure.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_invite_accept(self._tox_pointer, invite_data, len(invite_data), password,
len(password), byref(error))
return result
def callback_group_invite(self, callback, user_data):
"""
Set the callback for the `group_invite` event. Pass NULL to unset.
This event is triggered when the client receives a group invite from a friend. The client must store
invite_data which is used to join the group via tox_group_invite_accept.
"""
c_callback = CFUNCTYPE(None, c_void_p, c_uint32, c_char_p, c_size_t, c_void_p)
self.group_invite_cb = c_callback(callback)
Tox.libtoxcore.tox_callback_group_invite(self._tox_pointer, self.group_invite_cb, user_data)
def callback_group_peer_join(self, callback, user_data):
"""
Set the callback for the `group_peer_join` event. Pass NULL to unset.
This event is triggered when a peer other than self joins the group.
"""
c_callback = CFUNCTYPE(None, c_void_p, c_uint32, c_uint32, c_void_p)
self.group_peer_join_cb = c_callback(callback)
Tox.libtoxcore.tox_callback_group_peer_join(self._tox_pointer, self.group_peer_join_cb, user_data)
def callback_group_peer_exit(self, callback, user_data):
"""
Set the callback for the `group_peer_exit` event. Pass NULL to unset.
This event is triggered when a peer other than self exits the group.
"""
c_callback = CFUNCTYPE(None, c_void_p, c_uint32, c_uint32, c_char_p, c_size_t, c_void_p)
self.group_peer_exit_cb = c_callback(callback)
Tox.libtoxcore.tox_callback_group_peer_exit(self._tox_pointer, self.group_peer_exit_cb, user_data)
def callback_group_self_join(self, callback, user_data):
"""
Set the callback for the `group_self_join` event. Pass NULL to unset.
This event is triggered when the client has successfully joined a group. Use this to initialize
any group information the client may need.
"""
c_callback = CFUNCTYPE(None, c_void_p, c_uint32, c_void_p)
self.group_self_join_cb = c_callback(callback)
Tox.libtoxcore.tox_callback_group_self_join(self._tox_pointer, self.group_self_join_cb, user_data)
def callback_group_join_fail(self, callback, user_data):
"""
Set the callback for the `group_join_fail` event. Pass NULL to unset.
This event is triggered when the client fails to join a group.
"""
c_callback = CFUNCTYPE(None, c_void_p, c_uint32, c_int, c_void_p)
self.group_join_fail_cb = c_callback(callback)
Tox.libtoxcore.tox_callback_group_join_fail(self._tox_pointer, self.group_join_fail_cb, user_data)
# -----------------------------------------------------------------------------------------------------------------
# Group chat founder controls (these only work for the group founder)
# -----------------------------------------------------------------------------------------------------------------
def group_founder_set_password(self, groupnumber, password):
"""
Set or unset the group password.
This function sets the groups password, creates a new group shared state including the change,
and distributes it to the rest of the group.
:param groupnumber: The group number of the group for which we wish to set the password.
:param password: The password we want to set. Set password to NULL to unset the password.
:return True on success.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_founder_set_password(self._tox_pointer, groupnumber, password,
len(password), byref(error))
return result
def group_founder_set_privacy_state(self, groupnumber, privacy_state):
"""
Set the group privacy state.
This function sets the group's privacy state, creates a new group shared state
including the change, and distributes it to the rest of the group.
If an attempt is made to set the privacy state to the same state that the group is already
in, the function call will be successful and no action will be taken.
:param groupnumber: The group number of the group for which we wish to change the privacy state.
:param privacy_state: The privacy state we wish to set the group to.
:return true on success.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_founder_set_privacy_state(self._tox_pointer, groupnumber, privacy_state,
byref(error))
return result
def group_founder_set_peer_limit(self, groupnumber, max_peers):
"""
Set the group peer limit.
This function sets a limit for the number of peers who may be in the group, creates a new
group shared state including the change, and distributes it to the rest of the group.
:param groupnumber: The group number of the group for which we wish to set the peer limit.
:param max_peers: The maximum number of peers to allow in the group.
:return True on success.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_founder_set_peer_limit(self._tox_pointer, groupnumber,
max_peers, byref(error))
return result
# -----------------------------------------------------------------------------------------------------------------
# Group chat moderation
# -----------------------------------------------------------------------------------------------------------------
def group_toggle_ignore(self, groupnumber, peer_id, ignore):
"""
Ignore or unignore a peer.
:param groupnumber: The group number of the group the in which you wish to ignore a peer.
:param peer_id: The ID of the peer who shall be ignored or unignored.
:param ignore: True to ignore the peer, false to unignore the peer.
:return True on success.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_toggle_ignore(self._tox_pointer, groupnumber, peer_id, ignore, byref(error))
return result
def group_mod_set_role(self, groupnumber, peer_id, role):
"""
Set a peer's role.
This function will first remove the peer's previous role and then assign them a new role.
It will also send a packet to the rest of the group, requesting that they perform
the role reassignment. Note: peers cannot be set to the founder role.
:param groupnumber: The group number of the group the in which you wish set the peer's role.
:param peer_id: The ID of the peer whose role you wish to set.
:param role: The role you wish to set the peer to.
:return True on success.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_mod_set_role(self._tox_pointer, groupnumber, peer_id, role, byref(error))
return result
def group_mod_remove_peer(self, groupnumber, peer_id, set_ban):
"""
Kick/ban a peer.
This function will remove a peer from the caller's peer list and optionally add their IP address
to the ban list. It will also send a packet to all group members requesting them
to do the same.
:param groupnumber: The group number of the group the ban is intended for.
:param peer_id: The ID of the peer who will be kicked and/or added to the ban list.
:param set_ban: Set to true if a ban shall be set on the peer's IP address.
:return True on success.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_mod_remove_peer(self._tox_pointer, groupnumber, peer_id,
set_ban, byref(error))
return result
def group_mod_remove_ban(self, groupnumber, ban_id):
"""
Removes a ban.
This function removes a ban entry from the ban list, and sends a packet to the rest of
the group requesting that they do the same.
:param groupnumber: The group number of the group in which the ban is to be removed.
:param ban_id: The ID of the ban entry that shall be removed.
:return True on success
"""
error = c_int()
result = Tox.libtoxcore.tox_group_mod_remove_ban(self._tox_pointer, groupnumber, ban_id, byref(error))
return result
def callback_group_moderation(self, callback, user_data):
"""
Set the callback for the `group_moderation` event. Pass NULL to unset.
This event is triggered when a moderator or founder executes a moderation event.
"""
c_callback = CFUNCTYPE(None, c_void_p, c_uint32, c_uint32, c_uint32, c_int, c_void_p)
self.group_moderation_cb = c_callback(callback)
Tox.libtoxcore.tox_callback_group_moderation(self._tox_pointer, self.group_moderation_cb, user_data)
# -----------------------------------------------------------------------------------------------------------------
# Group chat ban list queries
# -----------------------------------------------------------------------------------------------------------------
def group_ban_get_list_size(self, groupnumber):
"""
Return the number of entries in the ban list for the group designated by
the given group number. If the group number is invalid, the return value is unspecified.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_ban_get_list_size(self._tox_pointer, groupnumber, byref(error))
return result
def group_ban_get_list(self, groupnumber):
"""
Copy a list of valid ban list ID's into an array.
Call tox_group_ban_get_list_size to determine the number of elements to allocate.
return true on success.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_ban_get_list(self._tox_pointer, groupnumber, POINTER(c_uint32)(
create_string_buffer(sizeof(c_uint32) * self.group_ban_get_list_size(groupnumber)), byref(error)))
return result
def group_ban_get_name_size(self, groupnumber, ban_id):
"""
Return the length of the name for the ban list entry designated by ban_id, in the
group designated by the given group number. If either groupnumber or ban_id is invalid,
the return value is unspecified.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_ban_get_name_size(self._tox_pointer, groupnumber, ban_id, byref(error))
return result
def group_ban_get_name(self, groupnumber, ban_id):
"""
Write the name of the ban entry designated by ban_id in the group designated by the
given group number to a byte array.
Call tox_group_ban_get_name_size to find out how much memory to allocate for the result.
:return name
"""
error = c_int()
size = self.group_ban_get_name_size(groupnumber, ban_id)
name = create_string_buffer()
result = Tox.libtoxcore.tox_group_ban_get_name(self._tox_pointer, groupnumber, ban_id,
name, byref(error))
return str(name[:size], 'utf-8')
def group_ban_get_time_set(self, groupnumber, ban_id):
"""
Return a time stamp indicating the time the ban was set, for the ban list entry
designated by ban_id, in the group designated by the given group number.
If either groupnumber or ban_id is invalid, the return value is unspecified.
"""
error = c_int()
result = Tox.libtoxcore.tox_group_ban_get_time_set(self._tox_pointer, groupnumber, ban_id, byref(error))
return result