Change the default implementation of on_error to log to the root logger
instead of discord.client and clarify that the exception is being
ignored. This ensures that a message will be output to standard error
in case the logging module has not been configured.
Also removes the argument printing for the default on_error, this is due
to them often being too long, that they could cause another exception to
be thrown, and because it sometimes causes sensitive information to be
output such as Discord tokens and session ids. It was also possible for
the length to get in the megabyte range with exceptions thrown by
on_socket_raw_receive in READY events.
Add on_socket_raw_receive and on_socket_raw_send events for sniffing the
data being received and sent on the websocket. Useful for debugging and
logging websocket messages received and sent on the link to Discord's
servers.
This adds a lot of new attributes into the Member class
such as giving a voice_channel that the user is currently connected
to. Initially there was a plan to have a voice_members attribute
in the Channel class but this proved to be difficult when it came to
actually removing users from the voice channel as the response would
return channel_id as null.
Fixes#16.
Change Client.event decorator to assign the event handler function to
the instance it self and levarage dispatch to handle calling these
event. Remove old _invoke_event method.
Change how the old style on_error event is called to match the new style
on_error event. Both are now called in case an exception is raised in
an user defined event handler, and will by default print the arguments
of the event tha raised the exception and the traceback for the
exception. In addition, overridding the on_error handler supresses this
behaviour.
When clicking on an invite link without having a Discord account it's
possible to create an unclaimed account for joining the conversation
quickly. Add register() method to Client that performs and invite based
registration of an unclaimed account.
Guard the execution of dispatch with a recursive thread lock. This is
needed to make a thread safe way to send events to Client objects. Note
that the only thread safe method is dispatch, everything else is unsafe
to call from another thread, as the thead handling the Client object
could be modifying arbitrary structures at any time. In addition this
only keeps nasal demons away, and does not solve any of the difficult
syncronization issues that might be present.
Move the socket message handling and Discord connection state tracking
out of the Client class. The WebSocket class handles the ws4py based
WebSocket to Discord, maintains the keepalive and dispatches
socket_<events> based on activity. The ConnectionSTate class maintains
the state associated with the WebSocket connection with Discord. In a
reconnect and switch gateway scenario this state can be kept for a
faster and less disruptive recovery.
Add event system based on a public dispatch method in Client. The new
event system bases itself on two types of events, internal event
handlers and user defined event handlers. Internal event handlers begin
with 'handle_', and user defined events begin with 'on_'. Events are
dispatched with dispatch(event_name, *args). The Client class should be
subclassed and the on_<event> handlers defined in it for responding to
events. The handle_<event> handlers can the overridden to override the
behaviour of the Client class, though this is not recommended.
The subclassing method allows separation of the instance of the client
and the code that handles it. (i.e. you don't need the instance of the
client object to define event handlers for it). Though, the old method
of using the event decorator from the instance will still be supported.
_keep_alive_handler would set up another keep alive after the first one
by creating a new threading.Timer object, but Client would only keep
track of the first timer object. Thus casing the keep alive to continue
running after Client.logout calls cancel() on it's timer object, as it
no longer references the actual timer object waiting for the keep alive.
Fix by replacing _keep_alive_handler with a threading.Thread subclass
that sends keep_alives of the given interval and exits when its stop
event is set.
