Cleanup and fixes

disco/api/client.py

@@ -25,6 +25,14 @@ class APIClient(LoggingClass):
     """
     An abstraction over the :class:`disco.api.http.HTTPClient` that composes requests, and fits
     the models with the returned data.
+
+    Args
+    ----
+    token : str
+        The Discord authentication token (without prefixes) to be used for all
+        HTTP requests.
+    client : :class:`disco.client.Client`
+        The base disco client which will be used when constructing models.
     """
     def __init__(self, token, client=None):
         super(APIClient, self).__init__()

disco/api/http.py

@@ -113,6 +113,12 @@ class APIException(Exception):
     """
     Exception thrown when an HTTP-client level error occurs. Usually this will
     be a non-success status-code, or a transient network issue.
+
+    Attributes
+    ----------
+    status_code : int
+        The status code returned by the API for the request that triggered this
+        error.
     """
     def __init__(self, msg, status_code=0, content=None):
         self.status_code = status_code
@@ -200,7 +206,7 @@ class HTTPClient(LoggingClass):
         # If we got a success status code, just return the data
         if r.status_code < 400:
             return r
-        elif r.status_code != 429 and 400 < r.status_code < 500:
+        elif r.status_code != 429 and 400 <= r.status_code < 500:
             raise APIException('Request failed', r.status_code, r.content)
         else:
             if r.status_code == 429:

disco/cli.py

@@ -40,7 +40,6 @@ def disco_main(run=False):
 
     from disco.client import Client, ClientConfig
     from disco.bot import Bot, BotConfig
-    from disco.gateway.sharder import AutoSharder
     from disco.util.token import is_valid_token
     from holster.log import set_logging_levels
 
@@ -58,6 +57,7 @@ def disco_main(run=False):
         return
 
     if args.shard_auto:
+        from disco.gateway.sharder import AutoSharder
         AutoSharder(config).run()
         return
 

disco/types/channel.py

@@ -280,12 +280,24 @@ class Channel(SlottedModel, Permissible):
         if not messages:
             return
 
-        if len(messages) <= 2:
+        if self.can(self.client.state.me, Permissions.MANAGE_MESSAGES) and len(messages) > 2:
-            for msg in messages:
-                self.delete_message(msg)
-        else:
             for chunk in chunks(messages, 100):
                 self.client.api.channels_messages_delete_bulk(self.id, chunk)
+        else:
+            for msg in messages:
+                self.delete_message(msg)
+
+    def delete(self):
+        assert (self.is_dm or self.guild.can(self.client.state.me, Permissions.MANAGE_GUILD)), 'Invalid Permissions'
+        self.client.api.channels_delete(self.id)
+
+    def close(self):
+        """
+        Closes a DM channel. This is intended as a safer version of `delete`,
+        enforcing that the channel is actually a DM.
+        """
+        assert self.is_dm, 'Cannot close non-DM channel'
+        self.delete()
 
 
 class MessageIterator(object):

disco/types/guild.py

@@ -7,7 +7,7 @@ from disco.api.http import APIException
 from disco.util.snowflake import to_snowflake
 from disco.util.functional import cached_property
 from disco.types.base import SlottedModel, Field, snowflake, listof, dictof, text, binary, enum
-from disco.types.user import User
+from disco.types.user import User, Presence
 from disco.types.voice import VoiceState
 from disco.types.channel import Channel
 from disco.types.permissions import PermissionValue, Permissions, Permissible
@@ -246,6 +246,7 @@ class Guild(SlottedModel, Permissible):
     emojis = Field(dictof(Emoji, key='id'))
     voice_states = Field(dictof(VoiceState, key='session_id'))
     member_count = Field(int)
+    presences = Field(listof(Presence))
 
     synced = Field(bool, default=False)
 

disco/util/hashmap.py

@@ -45,12 +45,12 @@ class HashMap(UserDict):
     def filter(self, predicate):
         if not callable(predicate):
             raise TypeError('predicate must be callable')
-        return filter(self.values(), predicate)
+        return filter(predicate, self.values())
 
     def map(self, predicate):
         if not callable(predicate):
             raise TypeError('predicate must be callable')
-        return map(self.values(), predicate)
+        return map(predicate, self.values())
 
 
 class DefaultHashMap(defaultdict, HashMap):