Fix smashing PresenceUpdate.user value in state module

disco/client.py

@@ -15,13 +15,13 @@ from disco.util.backdoor import DiscoBackdoorServer
 
 class ClientConfig(Config):
     """
-    Configuration for the :class:`Client`.
+    Configuration for the `Client`.
 
     Attributes
     ----------
     token : str
         Discord authentication token, can be validated using the
-        :func:`disco.util.token.is_valid_token` function.
+        `disco.util.token.is_valid_token` function.
     shard_id : int
         The shard ID for the current client instance.
     shard_count : int
@@ -53,32 +53,32 @@ class Client(LoggingClass):
     """
     Class representing the base entry point that should be used in almost all
     implementation cases. This class wraps the functionality of both the REST API
-    (:class:`disco.api.client.APIClient`) and the realtime gateway API
-    (:class:`disco.gateway.client.GatewayClient`).
+    (`disco.api.client.APIClient`) and the realtime gateway API
+    (`disco.gateway.client.GatewayClient`).
 
     Parameters
     ----------
-    config : :class:`ClientConfig`
+    config : `ClientConfig`
         Configuration for this client instance.
 
     Attributes
     ----------
-    config : :class:`ClientConfig`
+    config : `ClientConfig`
         The runtime configuration for this client.
-    events : :class:`Emitter`
+    events : `Emitter`
         An emitter which emits Gateway events.
-    packets : :class:`Emitter`
+    packets : `Emitter`
         An emitter which emits Gateway packets.
-    state : :class:`State`
+    state : `State`
         The state tracking object.
-    api : :class:`APIClient`
+    api : `APIClient`
         The API client.
-    gw : :class:`GatewayClient`
+    gw : `GatewayClient`
         The gateway client.
     manhole_locals : dict
         Dictionary of local variables for each manhole connection. This can be
         modified to add/modify local variables.
-    manhole : Optional[:class:`BackdoorServer`]
+    manhole : Optional[`BackdoorServer`]
         Gevent backdoor server (if the manhole is enabled).
     """
     def __init__(self, config):

disco/state.py

@@ -1,4 +1,5 @@
 import six
+import copy
 import weakref
 import inflection
 
@@ -42,10 +43,10 @@ class StateConfig(Config):
         find they do not need and may be experiencing memory pressure can disable
         this feature entirely using this attribute.
     track_messages_size : int
-        The size of the deque for each channel. Using this you can calculate the
-        total number of possible :class:`StackMessage` objects kept in memory,
-        using: `total_mesages_size * total_channels`. This can be tweaked based
-        on usage to help prevent memory pressure.
+        The size of the messages deque for each channel. This value can be used
+        to calculate the total number of possible `StackMessage` objects kept in
+        memory, simply: `total_messages_size * total_channels`. This value can
+        be tweaked based on usage and to help prevent memory pressure.
     sync_guild_members : bool
         If true, guilds will be automatically synced when they are initially loaded
         or joined. Generally this setting is OK for smaller bots, however bots in over
@@ -60,31 +61,31 @@ class StateConfig(Config):
 class State(object):
     """
     The State class is used to track global state based on events emitted from
-    the :class:`GatewayClient`. State tracking is a core component of the Disco
-    client, providing the mechanism for most of the higher-level utility functions.
+    the `GatewayClient`. State tracking is a core component of the Disco client,
+    providing the mechanism for most of the higher-level utility functions.
 
     Attributes
     ----------
     EVENTS : list(str)
         A list of all events the State object binds to
-    client : :class:`disco.client.Client`
+    client : `disco.client.Client`
         The Client instance this state is attached to
-    config : :class:`StateConfig`
+    config : `StateConfig`
         The configuration for this state instance
-    me : :class:`disco.types.user.User`
+    me : `User`
         The currently logged in user
-    dms : dict(snowflake, :class:`disco.types.channel.Channel`)
+    dms : dict(snowflake, `Channel`)
         Mapping of all known DM Channels
-    guilds : dict(snowflake, :class:`disco.types.guild.Guild`)
+    guilds : dict(snowflake, `Guild`)
         Mapping of all known/loaded Guilds
-    channels : dict(snowflake, :class:`disco.types.channel.Channel`)
+    channels : dict(snowflake, `Channel`)
         Weak mapping of all known/loaded Channels
-    users : dict(snowflake, :class:`disco.types.user.User`)
+    users : dict(snowflake, `User`)
         Weak mapping of all known/loaded Users
-    voice_states : dict(str, :class:`disco.types.voice.VoiceState`)
+    voice_states : dict(str, `VoiceState`)
         Weak mapping of all known/active Voice States
-    messages : Optional[dict(snowflake, :class:`deque`)]
-        Mapping of channel ids to deques containing :class:`StackMessage` objects
+    messages : Optional[dict(snowflake, deque)]
+        Mapping of channel ids to deques containing `StackMessage` objects
     """
     EVENTS = [
         'Ready', 'GuildCreate', 'GuildUpdate', 'GuildDelete', 'GuildMemberAdd', 'GuildMemberRemove',
@@ -315,12 +316,14 @@ class State(object):
         self.guilds[event.guild_id].emojis = HashMap({i.id: i for i in event.emojis})
 
     def on_presence_update(self, event):
-        # Grab a copy of the user, and clear it out. All the operations below
-        #  do not want the nested user object, as the normaly structure is
-        #  user -> presence, and without clearing this becomes recursive
+        # Grab a copy of the entire presence object, and clear the user out. All
+        #  the operations below do not require or want a nested user object, and
+        #  having it set just complicates the general structure. We copy so as
+        #  to avoid interferring with other events that may require the nested
+        #  user object.
         user = event.presence.user
-        user.presence = event.presence
-        event.presence.user = None
+        user.presence = copy.deepcopy(event.presence)
+        user.presence.user = None
 
         # if we have the user tracked locally, we can just use the presence
         #  update to update both their presence and the cached user object.