Message Flags, embed suppressing and cross-posts. (#150)

* Add embed suppression and crosspost support.

* Add new message flags.

* toggle_embeds_suppress -> set_embeds_suppressed.

.gitignore

@@ -20,5 +20,8 @@ node_modules/
 # JetBrains IDE
 .idea/
 
+# Visual Studio IDE
+/.vs
+
 # macOS
 .DS_Store

CHANGELOG.md

@@ -1,118 +0,0 @@
-# CHANGELOG
-
-## v0.0.12
-
-### Additions
-
-- **MAJOR** Added voice gateway v3 support. This will result in increased stability for voice connections
-- **BREAKING** Updated holster to v2.0.0 which changes the way emitters work (and removes the previous priorities). A migration guide will be provided post-RC cycle.
-- Added support for ETF on Python 3.x via `earl-etf` (@GiovanniMCMXCIX)
-- Supported detecting dead/inactive/zombied Gateway websocket connections via tracking `HEARTBEAT_ACK` (@PixeLInc)
-- Added support for animated emoji (@Seklfreak)
-- Added support for `LISTENING` and `WATCHING` game statuses (@PixeLInc)
-- Added `wsaccel` package within the `performance` pack, should improve websocket performance
-- Added the concept of a `shared_config` which propgates its options to all plugin configs (@enkoder)
-- Added support for streaming zlib compression to our gateway socket. This is enabled by default and provides significant performance improvements on startup and overall bandwidth usage
-- Added support for `Guild.system_channel_id` and `GUILD_MEMBER_JOIN` system message
-- Added `Guild.create_category`, `Guild.create_text_channel` and `Guild.create_voice_channel`
-- Added `Channel.create_text_channel` and `Channel.create_voice_channel` which can be called only on category channels to add sub-channels
-
-### Fixes
-
-- Fixed 'Invalid token passed' errors from showing up (via removal of token validation)
-- Fixed `IndexError` being raised when `MessageIterator` was done iterating (@Majora320)
-- Fixed overwrite calculations in `Channel.get_permissions` (@cookkkie)
-- A plethora of PEP8 and general syntax changes have been made to cleanup the code
-- Fixed a bug with `Emoji.custom`
-- Fixed a bug in the typing system that would not allow Field's to have a `default` of `None`
-- Fixed the `__str__` method for Channel's displaying (useless) unset data for DMs
-- Fixed a bug with `MessageIterator` related to iterating before or after an ID of 0
-- Fixed incorrect field name (`icon_proxy_url` vs `proxy_icon_url`) in MessageEmbedAuthor model
-- Fixed bugs related to creating and deleting pinned messages
-- Fixed `GuildBan.reason` incorrectly handling unicode reasons
-- Fixed `Paginator` throwing an exception when reaching the end of pagination, instead of just ending its iteration
-- Fixed `Paginator` defaulting to start at 0 for all iterations
-
-### Etc
-
-- **BREAKING** Refactor the way Role's are managed and updated. You should update your code to use `Role.update`
-- **BREAKING** Renamed `Model.update` to `Model.inplace_update`. You should not have to worry about this change unless you explicitly call that method
-- **DEPRECATION** Deprecated the use of `Guild.create_channel`. You should use the explicit channel type creation methods added in this release
-- Cleaned up various documentation
-- Removed some outdated storage/etc examples
-- Expanded `APIClient.guilds_roles_create` to handle more attributes
-- Bumped various requirement versions
-
-## v0.0.11
-
-### Additions
-
-- Added support for Guild audit logs, exposed via `Guild.get_audit_log_entries`, `Guild.audit_log` and `Guild.audit_log_iter`. For more information see the `AuditLogEntry` model
-- Added built-in Flask HTTP server which can be enabled via `http_enabled` and configured via `http_host`/`http_port` config options. The server allows plugins to define routes which can be called externally.
-- Added support for capturing the raw responses returned from API requests via the `APIClient.capture` contextmanager
-- Added support for NSFW channels via `Channel.nsfw` and `Channel.is_nsfw`
-- Added initial support for channel categories via `Channel.parent_id` and `Channel.parent`
-- Added various setters for updating Channel properties, e.g. `Channel.set_topic`
-- Added support for audit log reasons, accessible through passing `reason` to various methods
-- Added `disco.util.snowflake.from_timestamp_ms`
-- Added support for `on_complete` callback within DCADOpusEncoderPlayable
-- **BREAKING** Added new custom queue types `BaseQueue`/`PlayableQueue` for use w/ `Player`.
-  - `queue` can be passed when creating a `Player`, should inherit from BaseQueue
-  - Users who previously utilized the `put` method of the old `Player.queue` must move to using `Player.queue.append`, or providing a custom queue implementation.
-- Added `Emoji.custom` property
-
-### Fixes
-
-- Fixed GuildRoleCreate missing guild\_id, resulting in incorrect state
-- Fixed SimpleLimiter behaving incorrectly (causing GW socket to be ratelimited in some cases)
-- Fixed the shortest possible match for a single command being an empty string
-- Fixed group matching being overly greedy, which allowed for extra characters to be allowed at the end of a group match
-- Fixed errors thrown when not enabling manhole via cli
-- Fixed various warnings emitted due to useage of StopIteration
-- Fixed warnings about missing voice libs when importing `disco.types.channel`
-- Fixed `Bot.get_commands_for_message` returning None (instead of empty list) in some cases
-
-### Etc
-
-- Greatly imrpoved the performance of `HashMap`
-- **BREAKING** Increased the weight of group matches over command argument matches, and limited the number of commands executed per message to one.
-- Reuse a buffer in voice code to slightly improve performance
-
-## v0.0.11-rc.8
-
-### Additions
-
-- Added support for capturing the raw responses returned from the API via `APIClient.capture` contextmanager
-- Added various pieces of documentation
-
-### Fixes
-
-- Fixed Python 3 errors and Python 2 deprecation warnings for CommandError using `.message` attribute
-
-### ETC
-
-- Grealty improved the performance of the custom HashMap
-- Moved tests around and added pytest as the testing framework of choice
-
-
-## v0.0.11-rc.7
-
-### Additions
-
-- Added support for new NSFW attribute of channels
-  - `Channel.nsfw`
-  - `Channel.set_nsfw`
-  - `Channel.is_nsfw` behaves correctly, checking both the deprecated `nsfw-` prefix and the new attribute
-- Added support for `on_complete` callback within DCADOpusEncoderPlayable
-- **BREAKING** Added new custom queue types `BaseQueue`/`PlayableQueue` for use w/ `Player`.
-  - `queue` can be passed when creating a `Player`, should inherit from BaseQueue
-  - Users who previously utilized the `put` method of the old `Player.queue` must move to using `Player.queue.append`, or providing a custom queue implementation.
-
-### Fixes
-
-- Fixed bug within SimpleLimiter which would cause all events after a quiescent period to be immedietly dispatched. This would cause gateway disconnects w/ RATE\_LIMITED on clients with many Guilds and member sync enabled.
-
-### ETC
-
-- Improved log messages within GatewayClient
-- Log voice endpoint within VoiceClient

disco/api/client.py

@@ -1,4 +1,3 @@
-import six
 import json
 import warnings
 
@@ -6,28 +5,23 @@ from contextlib import contextmanager
 from gevent.local import local
 from six.moves.urllib.parse import quote
 
-from holster.enum import EnumAttr
 from disco.api.http import Routes, HTTPClient, to_bytes
+from disco.util.functional import optional
 from disco.util.logging import LoggingClass
 from disco.util.sanitize import S
 from disco.types.user import User
 from disco.types.message import Message
-from disco.types.guild import Guild, GuildMember, GuildBan, Role, GuildEmoji, AuditLogEntry
+from disco.types.oauth import Application, Connection
+from disco.types.guild import (
+    Guild, GuildMember, GuildBan, GuildEmbed, PruneCount, Role, GuildEmoji,
+    AuditLogEntry, Integration,
+)
 from disco.types.channel import Channel
 from disco.types.invite import Invite
+from disco.types.voice import VoiceRegion
 from disco.types.webhook import Webhook
 
 
-def optional(**kwargs):
-    """
-    Takes a set of keyword arguments, creating a dictionary with only the non-
-    null values.
-
-    :returns: dict
-    """
-    return {k: v for k, v in six.iteritems(kwargs) if v is not None}
-
-
 def _reason_header(value):
     return optional(**{'X-Audit-Log-Reason': quote(to_bytes(value)) if value else None})
 
@@ -48,8 +42,8 @@ class APIClient(LoggingClass):
     is the only path to the API used within models/other interfaces, and it's
     the recommended path for all third-party users/implementations.
 
-    Args
-    ----
+    Parameters
+    ----------
     token : str
         The Discord authentication token (without prefixes) to be used for all
         HTTP requests.
@@ -101,6 +95,10 @@ class APIClient(LoggingClass):
         data = self.http(Routes.GATEWAY_BOT_GET).json()
         return data
 
+    def oauth2_applications_me_get(self):
+        r = self.http(Routes.OAUTH2_APPLICATIONS_ME)
+        return Application.create(self.client, r.json())
+
     def channels_get(self, channel):
         r = self.http(Routes.CHANNELS_GET, dict(channel=channel))
         return Channel.create(self.client, r.json())
@@ -188,8 +186,8 @@ class APIClient(LoggingClass):
 
         return Message.create(self.client, r.json())
 
-    def channels_messages_modify(self, channel, message, content=None, embed=None, sanitize=False):
-        payload = {}
+    def channels_messages_modify(self, channel, message, content=None, embed=None, flags=None, sanitize=False):
+        payload = optional(flags=flags)
 
         if content is not None:
             if sanitize:
@@ -230,6 +228,9 @@ class APIClient(LoggingClass):
 
         self.http(route, obj)
 
+    def channels_messages_reactions_delete_all(self, channel, message):
+        self.http(Routes.CHANNELS_MESSAGES_REACTIONS_DELETE_ALL, dict(channel=channel, message=message))
+
     def channels_permissions_modify(self, channel, permission, allow, deny, typ, reason=None):
         self.http(Routes.CHANNELS_PERMISSIONS_MODIFY, dict(channel=channel, permission=permission), json={
             'allow': allow,
@@ -286,7 +287,34 @@ class APIClient(LoggingClass):
         return Guild.create(self.client, r.json())
 
     def guilds_delete(self, guild):
-        r = self.http(Routes.GUILDS_DELETE, dict(guild=guild))
+        self.http(Routes.GUILDS_DELETE, dict(guild=guild))
+
+    def guilds_create(
+            self,
+            name,
+            region=None,
+            icon=None,
+            verification_level=None,
+            default_message_notifications=None,
+            explicit_content_filter=None,
+            roles=None,
+            channels=None):
+
+        payload = {
+            'name': name,
+            'roles': (roles or []),
+            'channels': (channels or []),
+        }
+
+        payload.update(optional(
+            region=region,
+            icon=icon,
+            verification_level=verification_level,
+            default_message_notifications=default_message_notifications,
+            explicit_content_filter=explicit_content_filter,
+        ))
+
+        r = self.http(Routes.GUILDS_CREATE, json=payload)
         return Guild.create(self.client, r.json())
 
     def guilds_channels_list(self, guild):
@@ -308,7 +336,7 @@ class APIClient(LoggingClass):
 
         payload = {
             'name': name,
-            'type': channel_type.value if isinstance(channel_type, EnumAttr) else channel_type,
+            'type': channel_type,
             'permission_overwrites': [i.to_dict() for i in permission_overwrites],
             'parent_id': parent_id,
         }
@@ -366,6 +394,20 @@ class APIClient(LoggingClass):
     def guilds_members_me_nick(self, guild, nick):
         self.http(Routes.GUILDS_MEMBERS_ME_NICK, dict(guild=guild), json={'nick': nick})
 
+    def guilds_members_add(self, guild, member, access_token, nick=None, roles=None, mute=None, deaf=None):
+        payload = {
+            'access_token': access_token
+        }
+
+        payload.update(optional(
+            nick=nick,
+            roles=roles,
+            mute=mute,
+            deaf=deaf,
+        ))
+
+        self.http(Routes.GUILDS_MEMBERS_ADD, dict(guild=guild, member=member), json=payload)
+
     def guilds_members_kick(self, guild, member, reason=None):
         self.http(Routes.GUILDS_MEMBERS_KICK, dict(guild=guild, member=member), headers=_reason_header(reason))
 
@@ -373,6 +415,10 @@ class APIClient(LoggingClass):
         r = self.http(Routes.GUILDS_BANS_LIST, dict(guild=guild))
         return GuildBan.create_hash(self.client, 'user.id', r.json())
 
+    def guilds_bans_get(self, guild, user):
+        r = self.http(Routes.GUILDS_BANS_GET, dict(guild=guild, user=user))
+        return GuildBan.create(self.client, r.json())
+
     def guilds_bans_create(self, guild, user, delete_message_days=0, reason=None):
         self.http(Routes.GUILDS_BANS_CREATE, dict(guild=guild, user=user), params={
             'delete-message-days': delete_message_days,
@@ -385,6 +431,17 @@ class APIClient(LoggingClass):
             dict(guild=guild, user=user),
             headers=_reason_header(reason))
 
+    def guilds_prune_count_get(self, guild, days=None):
+        r = self.http(Routes.GUILDS_PRUNE_COUNT, dict(guild=guild), params=optional(days=days))
+        return PruneCount.create(self.client, r.json())
+
+    def guilds_prune_create(self, guild, days=None, compute_prune_count=None):
+        r = self.http(Routes.GUILDS_PRUNE_CREATE, dict(guild=guild), params=optional(
+            days=days,
+            compute_prune_count=compute_prune_count,
+        ))
+        return PruneCount.create(self.client, r.json())
+
     def guilds_roles_list(self, guild):
         r = self.http(Routes.GUILDS_ROLES_LIST, dict(guild=guild))
         return Role.create_map(self.client, r.json(), guild_id=guild)
@@ -445,14 +502,69 @@ class APIClient(LoggingClass):
     def guilds_roles_delete(self, guild, role, reason=None):
         self.http(Routes.GUILDS_ROLES_DELETE, dict(guild=guild, role=role), headers=_reason_header(reason))
 
+    def guilds_voice_regions_list(self, guild):
+        r = self.http(Routes.GUILDS_VOICE_REGIONS_LIST, dict(guild=guild))
+        return VoiceRegion.create_hash(self.client, 'id', r.json())
+
     def guilds_invites_list(self, guild):
         r = self.http(Routes.GUILDS_INVITES_LIST, dict(guild=guild))
         return Invite.create_map(self.client, r.json())
 
+    def guilds_integrations_list(self, guild):
+        r = self.http(Routes.GUILDS_INTEGRATIONS_LIST, dict(guild=guild))
+        return Integration.create_map(self.client, r.json())
+
+    def guilds_integrations_create(self, guild, type, id):
+        r = self.http(Routes.GUILDS_INTEGRATIONS_CREATE, dict(guild=guild), json={"type": type, "id": id})
+        return Integration.create(r.json())
+
+    def guilds_integrations_modify(
+            self,
+            guild,
+            integration,
+            expire_behavior=None,
+            expire_grace_period=None,
+            enable_emoticons=None):
+
+        self.http(
+            Routes.GUILDS_INTEGRATIONS_MODIFY,
+            dict(guild=guild, integration=integration),
+            json=optional(
+                expire_behavior=expire_behavior,
+                expire_grace_period=expire_grace_period,
+                enable_emoticons=enable_emoticons,
+            ))
+
+    def guilds_integrations_delete(self, guild, integration):
+        self.http(Routes.GUILDS_INTEGRATIONS_DELETE, dict(guild=guild, integration=integration))
+
+    def guilds_integrations_sync(self, guild, integration):
+        self.http(Routes.GUILDS_INTEGRATIONS_SYNC, dict(guild=guild, integration=integration))
+
+    def guilds_vanity_url_get(self, guild):
+        r = self.http(Routes.GUILDS_VANITY_URL_GET, dict(guild=guild))
+        return Invite.create(self.client, r.json())
+
+    def guilds_embed_get(self, guild):
+        r = self.http(Routes.GUILDS_EMBED_GET, dict(guild=guild))
+        return GuildEmbed.create(self.client, r.json())
+
+    def guilds_embed_modify(self, guild, reason=None, **kwargs):
+        r = self.http(
+            Routes.GUILDS_EMBED_MODIFY,
+            dict(guild=guild),
+            json=kwargs,
+            headers=_reason_header(reason))
+        return GuildEmbed.create(self.client, r.json())
+
     def guilds_webhooks_list(self, guild):
         r = self.http(Routes.GUILDS_WEBHOOKS_LIST, dict(guild=guild))
         return Webhook.create_map(self.client, r.json())
 
+    def guilds_emojis_get(self, guild, emoji):
+        r = self.http(Routes.GUILDS_EMOJIS_GET, dict(guild=guild, emoji=emoji))
+        return GuildEmoji.create(self.client, r.json())
+
     def guilds_emojis_list(self, guild):
         r = self.http(Routes.GUILDS_EMOJIS_LIST, dict(guild=guild))
         return GuildEmoji.create_map(self.client, r.json())
@@ -498,12 +610,17 @@ class APIClient(LoggingClass):
         return User.create(self.client, r.json())
 
     def users_me_get(self):
-        return User.create(self.client, self.http(Routes.USERS_ME_GET).json())
+        r = self.http(Routes.USERS_ME_GET)
+        return User.create(self.client, r.json())
 
     def users_me_patch(self, payload):
         r = self.http(Routes.USERS_ME_PATCH, json=payload)
         return User.create(self.client, r.json())
 
+    def users_me_guilds_list(self):
+        r = self.http(Routes.USERS_ME_GUILDS_LIST)
+        return Guild.create_hash(self.client, 'id', r.json())
+
     def users_me_guilds_delete(self, guild):
         self.http(Routes.USERS_ME_GUILDS_DELETE, dict(guild=guild))
 
@@ -513,14 +630,22 @@ class APIClient(LoggingClass):
         })
         return Channel.create(self.client, r.json())
 
-    def invites_get(self, invite):
-        r = self.http(Routes.INVITES_GET, dict(invite=invite))
+    def users_me_connections_list(self):
+        r = self.http(Routes.USERS_ME_CONNECTIONS_LIST)
+        return Connection.create_map(self.client, r.json())
+
+    def invites_get(self, invite, with_counts=None):
+        r = self.http(Routes.INVITES_GET, dict(invite=invite), params=optional(with_counts=with_counts))
         return Invite.create(self.client, r.json())
 
     def invites_delete(self, invite, reason=None):
         r = self.http(Routes.INVITES_DELETE, dict(invite=invite), headers=_reason_header(reason))
         return Invite.create(self.client, r.json())
 
+    def voice_regions_list(self):
+        r = self.http(Routes.VOICE_REGIONS_LIST)
+        return VoiceRegion.create_hash(self.client, 'id', r.json())
+
     def webhooks_get(self, webhook):
         r = self.http(Routes.WEBHOOKS_GET, dict(webhook=webhook))
         return Webhook.create(self.client, r.json())

disco/api/http.py

@@ -4,21 +4,18 @@ import gevent
 import six
 import sys
 
-from holster.enum import Enum
-
 from disco import VERSION as disco_version
 from requests import __version__ as requests_version
 from disco.util.logging import LoggingClass
 from disco.api.ratelimit import RateLimiter
 
-# Enum of all HTTP methods used
-HTTPMethod = Enum(
-    GET='GET',
-    POST='POST',
-    PUT='PUT',
-    PATCH='PATCH',
-    DELETE='DELETE',
-)
+
+class HTTPMethod(object):
+    GET = 'GET'
+    POST = 'POST'
+    PUT = 'PUT'
+    PATCH = 'PATCH'
+    DELETE = 'DELETE'
 
 
 def to_bytes(obj):
@@ -37,6 +34,12 @@ class Routes(object):
     GATEWAY_GET = (HTTPMethod.GET, '/gateway')
     GATEWAY_BOT_GET = (HTTPMethod.GET, '/gateway/bot')
 
+    # OAUTH2
+    OAUTH2 = '/oauth2'
+    OAUTH2_TOKEN = (HTTPMethod.POST, OAUTH2 + '/token')
+    OAUTH2_TOKEN_REVOKE = (HTTPMethod.POST, OAUTH2 + '/token/revoke')
+    OAUTH2_APPLICATIONS_ME = (HTTPMethod.GET, OAUTH2 + '/applications/@me')
+
     # Channels
     CHANNELS = '/channels/{channel}'
     CHANNELS_GET = (HTTPMethod.GET, CHANNELS)
@@ -51,6 +54,7 @@ class Routes(object):
     CHANNELS_MESSAGES_DELETE_BULK = (HTTPMethod.POST, CHANNELS + '/messages/bulk_delete')
     CHANNELS_MESSAGES_REACTIONS_GET = (HTTPMethod.GET, CHANNELS + '/messages/{message}/reactions/{emoji}')
     CHANNELS_MESSAGES_REACTIONS_CREATE = (HTTPMethod.PUT, CHANNELS + '/messages/{message}/reactions/{emoji}/@me')
+    CHANNELS_MESSAGES_REACTIONS_DELETE_ALL = (HTTPMethod.DELETE, CHANNELS + '/messages/{message}/reactions')
     CHANNELS_MESSAGES_REACTIONS_DELETE_ME = (HTTPMethod.DELETE, CHANNELS + '/messages/{message}/reactions/{emoji}/@me')
     CHANNELS_MESSAGES_REACTIONS_DELETE_USER = (HTTPMethod.DELETE,
                                                CHANNELS + '/messages/{message}/reactions/{emoji}/{user}')
@@ -67,6 +71,7 @@ class Routes(object):
     # Guilds
     GUILDS = '/guilds/{guild}'
     GUILDS_GET = (HTTPMethod.GET, GUILDS)
+    GUILDS_CREATE = (HTTPMethod.POST, '/guilds')
     GUILDS_MODIFY = (HTTPMethod.PATCH, GUILDS)
     GUILDS_DELETE = (HTTPMethod.DELETE, GUILDS)
     GUILDS_CHANNELS_LIST = (HTTPMethod.GET, GUILDS + '/channels')
@@ -79,7 +84,9 @@ class Routes(object):
     GUILDS_MEMBERS_ROLES_REMOVE = (HTTPMethod.DELETE, GUILDS + '/members/{member}/roles/{role}')
     GUILDS_MEMBERS_ME_NICK = (HTTPMethod.PATCH, GUILDS + '/members/@me/nick')
     GUILDS_MEMBERS_KICK = (HTTPMethod.DELETE, GUILDS + '/members/{member}')
+    GUILDS_MEMBERS_ADD = (HTTPMethod.PUT, GUILDS + '/members/{member}')
     GUILDS_BANS_LIST = (HTTPMethod.GET, GUILDS + '/bans')
+    GUILDS_BANS_GET = (HTTPMethod.GET, GUILDS + '/bans/{user}')
     GUILDS_BANS_CREATE = (HTTPMethod.PUT, GUILDS + '/bans/{user}')
     GUILDS_BANS_DELETE = (HTTPMethod.DELETE, GUILDS + '/bans/{user}')
     GUILDS_ROLES_LIST = (HTTPMethod.GET, GUILDS + '/roles')
@@ -88,8 +95,9 @@ class Routes(object):
     GUILDS_ROLES_MODIFY = (HTTPMethod.PATCH, GUILDS + '/roles/{role}')
     GUILDS_ROLES_DELETE = (HTTPMethod.DELETE, GUILDS + '/roles/{role}')
     GUILDS_PRUNE_COUNT = (HTTPMethod.GET, GUILDS + '/prune')
-    GUILDS_PRUNE_BEGIN = (HTTPMethod.POST, GUILDS + '/prune')
+    GUILDS_PRUNE_CREATE = (HTTPMethod.POST, GUILDS + '/prune')
     GUILDS_VOICE_REGIONS_LIST = (HTTPMethod.GET, GUILDS + '/regions')
+    GUILDS_VANITY_URL_GET = (HTTPMethod.GET, GUILDS + '/vanity-url')
     GUILDS_INVITES_LIST = (HTTPMethod.GET, GUILDS + '/invites')
     GUILDS_INTEGRATIONS_LIST = (HTTPMethod.GET, GUILDS + '/integrations')
     GUILDS_INTEGRATIONS_CREATE = (HTTPMethod.POST, GUILDS + '/integrations')
@@ -101,6 +109,7 @@ class Routes(object):
     GUILDS_WEBHOOKS_LIST = (HTTPMethod.GET, GUILDS + '/webhooks')
     GUILDS_EMOJIS_LIST = (HTTPMethod.GET, GUILDS + '/emojis')
     GUILDS_EMOJIS_CREATE = (HTTPMethod.POST, GUILDS + '/emojis')
+    GUILDS_EMOJIS_GET = (HTTPMethod.GET, GUILDS + '/emojis/{emoji}')
     GUILDS_EMOJIS_MODIFY = (HTTPMethod.PATCH, GUILDS + '/emojis/{emoji}')
     GUILDS_EMOJIS_DELETE = (HTTPMethod.DELETE, GUILDS + '/emojis/{emoji}')
     GUILDS_AUDITLOGS_LIST = (HTTPMethod.GET, GUILDS + '/audit-logs')
@@ -121,6 +130,10 @@ class Routes(object):
     INVITES_GET = (HTTPMethod.GET, INVITES + '/{invite}')
     INVITES_DELETE = (HTTPMethod.DELETE, INVITES + '/{invite}')
 
+    # Voice
+    VOICE = '/voice'
+    VOICE_REGIONS_LIST = (HTTPMethod.GET, VOICE + '/regions')
+
     # Webhooks
     WEBHOOKS = '/webhooks/{webhook}'
     WEBHOOKS_GET = (HTTPMethod.GET, WEBHOOKS)
@@ -171,7 +184,9 @@ class APIException(Exception):
                 self.msg = '{} ({} - {})'.format(data['message'], self.code, self.errors)
             elif len(data) == 1:
                 key, value = list(data.items())[0]
-                self.msg = 'Request Failed: {}: {}'.format(key, ', '.join(value))
+                if not isinstance(value, str):
+                    value = ', '.join(value)
+                self.msg = 'Request Failed: {}: {}'.format(key, value)
         except ValueError:
             pass
 
@@ -199,18 +214,18 @@ class HTTPClient(LoggingClass):
             sys.version_info.micro)
 
         self.limiter = RateLimiter()
-        self.headers = {
+        self.after_request = after_request
+
+        self.session = requests.Session()
+        self.session.headers.update({
             'User-Agent': 'DiscordBot (https://github.com/b1naryth1ef/disco {}) Python/{} requests/{}'.format(
                 disco_version,
                 py_version,
                 requests_version),
-        }
+        })
 
         if token:
-            self.headers['Authorization'] = 'Bot ' + token
-
-        self.after_request = after_request
-        self.session = requests.Session()
+            self.session.headers['Authorization'] = 'Bot ' + token
 
     def __call__(self, route, args=None, **kwargs):
         return self.call(route, args, **kwargs)
@@ -232,7 +247,7 @@ class HTTPClient(LoggingClass):
             to create the requestable route. The HTTPClient uses this to track
             rate limits as well.
         kwargs : dict
-            Keyword arguments that will be passed along to the requests library
+            Keyword arguments that will be passed along to the requests library.
 
         Raises
         ------
@@ -243,21 +258,15 @@ class HTTPClient(LoggingClass):
         Returns
         -------
         :class:`requests.Response`
-            The response object for the request
+            The response object for the request.
         """
         args = args or {}
         retry = kwargs.pop('retry_number', 0)
 
-        # Merge or set headers
-        if 'headers' in kwargs:
-            kwargs['headers'].update(self.headers)
-        else:
-            kwargs['headers'] = self.headers
-
         # Build the bucket URL
         args = {k: to_bytes(v) for k, v in six.iteritems(args)}
         filtered = {k: (v if k in ('guild', 'channel') else '') for k, v in six.iteritems(args)}
-        bucket = (route[0].value, route[1].format(**filtered))
+        bucket = (route[0], route[1].format(**filtered))
 
         response = APIResponse()
 
@@ -268,8 +277,8 @@ class HTTPClient(LoggingClass):
 
         # Make the actual request
         url = self.BASE_URL + route[1].format(**args)
-        self.log.info('%s %s (%s)', route[0].value, url, kwargs.get('params'))
-        r = self.session.request(route[0].value, url, **kwargs)
+        self.log.info('%s %s (%s)', route[0], url, kwargs.get('params'))
+        r = self.session.request(route[0], url, **kwargs)
 
         if self.after_request:
             response.response = r
@@ -312,7 +321,7 @@ class HTTPClient(LoggingClass):
         client suspects is transient. Will always return a value between 500 and
         5000 milliseconds.
 
-        :returns: a random backoff in milliseconds
+        :returns: a random backoff in milliseconds.
         :rtype: float
         """
         return random.randint(500, 5000) / 1000.0

disco/api/ratelimit.py

@@ -26,7 +26,7 @@ class RouteState(LoggingClass):
         The number of remaining requests to the route before the rate limit will
         be hit, triggering a 429 response.
     reset_time : int
-        A unix epoch timestamp (in seconds) after which this rate limit is reset
+        A UNIX epoch timestamp (in seconds) after which this rate limit is reset.
     event : :class:`gevent.event.Event`
         An event that is used to block all requests while a route is in the
         cooldown stage.
@@ -45,7 +45,7 @@ class RouteState(LoggingClass):
     @property
     def chilled(self):
         """
-        Whether this route is currently being cooldown (aka waiting until reset_time).
+        Whether this route is currently being cooled-down (aka waiting until reset_time).
         """
         return self.event is not None
 
@@ -63,8 +63,8 @@ class RouteState(LoggingClass):
 
     def update(self, response):
         """
-        Updates this route with a given Requests response object. Its expected
-        the response has the required headers, however in the case it doesn't
+        Updates this route with a given Requests response object. It's expected
+        the response has the required headers, however in the case that it doesn't
         this function has no effect.
         """
         if 'X-RateLimit-Remaining' not in response.headers:
@@ -108,7 +108,7 @@ class RouteState(LoggingClass):
 
 class RateLimiter(LoggingClass):
     """
-    A in-memory store of ratelimit states for all routes we've ever called.
+    An in-memory store of ratelimit states for all routes we've ever called.
 
     Attributes
     ----------
@@ -124,7 +124,7 @@ class RateLimiter(LoggingClass):
         Checks whether a given route can be called. This function will return
         immediately if no rate-limit cooldown is being imposed for the given
         route, or will wait indefinitely until the route is finished being
-        cooled down. This function should be called before making a request to
+        cooled-down. This function should be called before making a request to
         the specified route.
 
         Parameters

disco/bot/bot.py

@@ -6,7 +6,6 @@ import inspect
 import importlib
 
 from six.moves import reload_module
-from holster.threadlocal import ThreadLocal
 from gevent.pywsgi import WSGIServer
 
 from disco.types.guild import GuildMember
@@ -16,6 +15,8 @@ from disco.bot.storage import Storage
 from disco.util.config import Config
 from disco.util.logging import LoggingClass
 from disco.util.serializer import Serializer
+from disco.util.threadlocal import ThreadLocal
+from disco.util.enum import get_enum_value_by_name
 
 
 class BotConfig(Config):
@@ -26,7 +27,7 @@ class BotConfig(Config):
     Attributes
     ----------
     levels : dict(snowflake, str)
-        Mapping of user IDs/role IDs to :class:`disco.bot.commands.CommandLevesls`
+        Mapping of user IDs/role IDs to :class:`disco.bot.commands.CommandLevels`
         which is used for the default commands_level_getter.
     plugins : list[string]
         List of plugin modules to load.
@@ -40,19 +41,25 @@ class BotConfig(Config):
         A dictionary describing what mention types can be considered a mention
         of the bot when using :attr:`commands_require_mention`. This dictionary
         can contain the following keys: `here`, `everyone`, `role`, `user`. When
-        a keys value is set to true, the mention type will be considered for
+        a key's value is set to true, the mention type will be considered for
         command parsing.
     commands_prefix : str
         A string prefix that is required for a message to be considered for
-        command parsing.
+        command parsing.  **DEPRECATED**
+    command_prefixes : list[string]
+        A list of string prefixes that are required for a message to be considered
+        for command parsing.
+    commands_prefix_getter : Optional[function]
+        A function which takes in a message object and returns an array of strings
+        (prefixes).
     commands_allow_edit : bool
-        If true, the bot will reparse an edited message if it was the last sent
+        If true, the bot will re-parse an edited message if it was the last sent
         message in a channel, and did not previously trigger a command. This is
-        helpful for allowing edits to typod commands.
+        helpful for allowing edits to typed commands.
     commands_level_getter : function
         If set, a function which when given a GuildMember or User, returns the
         relevant :class:`disco.bot.commands.CommandLevels`.
-    commands_group_abbrev : function
+    commands_group_abbrev : bool
         If true, command groups may be abbreviated to the least common variation.
         E.g. the grouping 'test' may be abbreviated down to 't', unless 'tag' exists,
         in which case it may be abbreviated down to 'te'.
@@ -69,10 +76,12 @@ class BotConfig(Config):
         Whether to enable the built-in Flask server which allows plugins to handle
         and route HTTP requests.
     http_host : str
-        The host string for the HTTP Flask server (if enabled)
+        The host string for the HTTP Flask server (if enabled).
     http_port : int
-        The port for the HTTP Flask server (if enabled)
+        The port for the HTTP Flask server (if enabled).
     """
+    deprecated = {'commands_prefix': 'command_prefixes'}
+
     levels = {}
     plugins = []
     plugin_config = {}
@@ -86,7 +95,9 @@ class BotConfig(Config):
         'role': True,
         'user': True,
     }
-    commands_prefix = ''
+    commands_prefix = ''  # now deprecated
+    command_prefixes = []
+    commands_prefix_getter = None
     commands_allow_edit = True
     commands_level_getter = None
     commands_group_abbrev = True
@@ -108,7 +119,7 @@ class BotConfig(Config):
 class Bot(LoggingClass):
     """
     Disco's implementation of a simple but extendable Discord bot. Bots consist
-    of a set of plugins, and a Disco client.
+    of a set of plugins, and a Disco Client.
 
     Parameters
     ----------
@@ -125,7 +136,7 @@ class Bot(LoggingClass):
     config : `BotConfig`
         The bot configuration instance for this bot.
     plugins : dict(str, :class:`disco.bot.plugin.Plugin`)
-        Any plugins this bot has loaded
+        Any plugins this bot has loaded.
     """
     def __init__(self, client, config=None):
         self.client = client
@@ -185,9 +196,14 @@ class Bot(LoggingClass):
         for plugin_mod in self.config.plugins:
             self.add_plugin_module(plugin_mod)
 
-        # Convert level mapping
-        for k, v in list(six.iteritems(self.config.levels)):
-            self.config.levels[int(k) if k.isdigit() else k] = CommandLevels.get(v)
+        # Convert our configured mapping of entities to levels into something
+        #  we can actually use. This ensures IDs are converted properly, and maps
+        #  any level names (e.g. `role_id: admin`) map to their numerical values.
+        for entity_id, level in list(six.iteritems(self.config.levels)):
+            del self.config.levels[entity_id]
+            entity_id = int(entity_id) if str(entity_id).isdigit() else entity_id
+            level = int(level) if str(level).isdigit() else get_enum_value_by_name(CommandLevels, level)
+            self.config.levels[entity_id] = level
 
     @classmethod
     def from_cli(cls, *plugins):
@@ -199,8 +215,7 @@ class Bot(LoggingClass):
         Parameters
         ---------
         plugins : Optional[list(:class:`disco.bot.plugin.Plugin`)]
-            Any plugins to load after creating the new bot instance
-
+            Any plugins to load after creating the new bot instance.
         """
         from disco.cli import disco_main
         inst = cls(disco_main())
@@ -234,7 +249,7 @@ class Bot(LoggingClass):
         Computes all possible abbreviations for a command grouping.
         """
         # For the first pass, we just want to compute each groups possible
-        #  abbreviations that don't conflict with eachother.
+        #  abbreviations that don't conflict with each other.
         possible = {}
         for group in groups:
             for index in range(1, len(group)):
@@ -244,7 +259,7 @@ class Bot(LoggingClass):
                 else:
                     possible[current] = group
 
-        # Now, we want to compute the actual shortest abbreivation out of the
+        # Now, we want to compute the actual shortest abbreviation out of the
         #  possible ones
         result = {}
         for abbrev, group in six.iteritems(possible):
@@ -270,21 +285,30 @@ class Bot(LoggingClass):
         else:
             self.command_matches_re = None
 
-    def get_commands_for_message(self, require_mention, mention_rules, prefix, msg):
+    def get_commands_for_message(self, require_mention, mention_rules, prefixes, msg):
         """
         Generator of all commands that a given message object triggers, based on
         the bots plugins and configuration.
 
         Parameters
         ---------
+        require_mention : bool
+            Checks if the message starts with a mention (and then ignores the prefix(es))
+        mention_rules : dict(str, bool)
+            Whether `user`, `everyone`, and `role` mentions are allowed. Defaults to:
+            `{'user': True, 'everyone': False, 'role': False}`
+        prefixes : list[string]
+            A list of prefixes to check the message starts with.
         msg : :class:`disco.types.message.Message`
-            The message object to parse and find matching commands for
+            The message object to parse and find matching commands for.
 
         Yields
         -------
         tuple(:class:`disco.bot.command.Command`, `re.MatchObject`)
-            All commands the message triggers
+            All commands the message triggers.
         """
+        # somebody better figure out what this yields...
+
         content = msg.content
 
         if require_mention:
@@ -321,10 +345,17 @@ class Bot(LoggingClass):
 
             content = content.lstrip()
 
-        if prefix and not content.startswith(prefix):
-            return []
+        # Scan through the prefixes to find the first one that matches.
+        # This may lead to unexpected results, but said unexpectedness
+        # should be easy to avoid. An example of the unexpected results
+        # that may occur would be if one prefix was `!` and one was `!a`.
+        for prefix in prefixes:
+            if prefix and content.startswith(prefix):
+                content = content[len(prefix):]
+                break
         else:
-            content = content[len(prefix):]
+            if not require_mention:  # don't want to prematurely return
+                return []
 
         if not self.command_matches_re or not self.command_matches_re.match(content):
             return []
@@ -334,6 +365,7 @@ class Bot(LoggingClass):
             match = command.compiled_regex.match(content)
             if match:
                 options.append((command, match))
+
         return sorted(options, key=lambda obj: obj[0].group is None)
 
     def get_level(self, actor):
@@ -375,12 +407,15 @@ class Bot(LoggingClass):
         Returns
         -------
         bool
-            whether any commands where successfully triggered by the message
+            Whether any commands where successfully triggered by the message.
         """
+        custom_message_prefixes = (self.config.commands_prefix_getter(msg)
+                                   if self.config.commands_prefix_getter else [])
+
         commands = list(self.get_commands_for_message(
             self.config.commands_require_mention,
             self.config.commands_mention_rules,
-            self.config.commands_prefix,
+            custom_message_prefixes or self.config.command_prefixes,
             msg,
         ))
 
@@ -466,7 +501,7 @@ class Bot(LoggingClass):
             Plugin class to unload and remove.
         """
         if cls.__name__ not in self.plugins:
-            raise Exception('Cannot remove non-existant plugin: {}'.format(cls.__name__))
+            raise Exception('Cannot remove non-existent plugin: {}'.format(cls.__name__))
 
         ctx = {}
         self.plugins[cls.__name__].unload(ctx)

disco/bot/command.py

@@ -1,8 +1,6 @@
 import re
 import argparse
 
-from holster.enum import Enum
-
 from six import integer_types
 
 from disco.bot.parser import ArgumentSet, ArgumentError
@@ -16,13 +14,13 @@ USER_MENTION_RE = re.compile('<@!?([0-9]+)>')
 ROLE_MENTION_RE = re.compile('<@&([0-9]+)>')
 CHANNEL_MENTION_RE = re.compile('<#([0-9]+)>')
 
-CommandLevels = Enum(
-    DEFAULT=0,
-    TRUSTED=10,
-    MOD=50,
-    ADMIN=100,
-    OWNER=500,
-)
+
+class CommandLevels(object):
+    DEFAULT = 0
+    TRUSTED = 10
+    MOD = 50
+    ADMIN = 100
+    OWNER = 500
 
 
 class PluginArgumentParser(argparse.ArgumentParser):
@@ -37,7 +35,7 @@ class CommandEvent(object):
     message information).
 
     Attributes
-    ---------
+    ----------
     command : :class:`Command`
         The command this event was created for (aka the triggered command).
     msg : :class:`disco.types.message.Message`
@@ -45,9 +43,9 @@ class CommandEvent(object):
     match : :class:`re.MatchObject`
         The regex match object for the command.
     name : str
-        The command name (or alias) which was triggered by the command
+        The command name (or alias) which was triggered by the command.
     args : list(str)
-        Arguments passed to the command
+        Arguments passed to the command.
     """
 
     def __init__(self, command, msg, match):
@@ -173,7 +171,7 @@ class Command(object):
             oob=False,
             context=None,
             parser=False,
-            **kwargs):
+            metadata=None):
         self.triggers += aliases or []
 
         def resolve_role(ctx, rid):
@@ -211,7 +209,7 @@ class Command(object):
         self.is_regex = is_regex
         self.oob = oob
         self.context = context or {}
-        self.metadata = kwargs
+        self.metadata = metadata or {}
 
         if parser:
             self.parser = PluginArgumentParser(prog=self.name, add_help=False)
@@ -278,7 +276,7 @@ class Command(object):
         Returns
         -------
         bool
-            Whether this command was successful
+            Whether this command was successful.
         """
         parsed_kwargs = {}
 

disco/bot/parser.py

@@ -226,6 +226,6 @@ class ArgumentSet(object):
     @property
     def required_length(self):
         """
-        The number of required arguments to compile this set/specificaiton.
+        The number of required arguments to compile this set/specification.
         """
         return sum(i.true_count for i in self.args if i.required)

disco/bot/plugin.py

@@ -7,8 +7,8 @@ import warnings
 import functools
 
 from gevent.event import AsyncResult
-from holster.emitter import Priority
 
+from disco.util.emitter import Priority
 from disco.util.logging import LoggingClass
 from disco.bot.command import Command, CommandError
 
@@ -436,8 +436,8 @@ class Plugin(LoggingClass, PluginDeco):
         Registers a function to be called repeatedly, waiting for an interval
         duration.
 
-        Args
-        ----
+        Parameters
+        ----------
         func : function
             The function to be registered.
         interval : int
@@ -447,8 +447,8 @@ class Plugin(LoggingClass, PluginDeco):
         init : bool
             Whether to run this schedule once immediately, or wait for the first
             scheduled iteration.
-        kwargs: dict
-            kwargs which will be passed to executed `func`
+        kwargs : dict
+            kwargs which will be passed to executed `func`.
         """
         if kwargs is None:
             kwargs = {}

disco/cli.py

@@ -16,8 +16,8 @@ monkey.patch_all()
 parser = argparse.ArgumentParser()
 
 # Command line specific arguments
-parser.add_argument('--run-bot', help='run a disco bot on this client', action='store_true', default=False)
-parser.add_argument('--plugin', help='load plugins into the bot', nargs='*', default=[])
+parser.add_argument('--run-bot', help='Run a disco bot on this client', action='store_true', default=False)
+parser.add_argument('--plugin', help='Load plugins into the bot', nargs='*', default=[])
 parser.add_argument('--config', help='Configuration file', default=None)
 parser.add_argument('--shard-auto', help='Automatically run all shards', action='store_true', default=False)
 
@@ -29,7 +29,7 @@ parser.add_argument('--max-reconnects', help='Maximum reconnect attempts', defau
 parser.add_argument('--log-level', help='log level', default=None)
 parser.add_argument('--manhole', action='store_true', help='Enable the manhole', default=None)
 parser.add_argument('--manhole-bind', help='host:port for the manhole to bind too', default=None)
-parser.add_argument('--encoder', help='encoder for gateway data', default=None)
+parser.add_argument('--encoder', help='Encoder for gateway data', default=None)
 
 
 # Mapping of argument names to configuration overrides
@@ -53,7 +53,7 @@ def disco_main(run=False):
     Returns
     -------
     :class:`Client`
-        A new Client from the provided command line arguments
+        A new Client from the provided command line arguments.
     """
     from disco.client import Client, ClientConfig
     from disco.bot import Bot, BotConfig

disco/client.py

@@ -1,14 +1,13 @@
 import time
 import gevent
 
-from holster.emitter import Emitter
-
 from disco.state import State, StateConfig
 from disco.api.client import APIClient
 from disco.gateway.client import GatewayClient
 from disco.gateway.packets import OPCode
 from disco.types.user import Status, Game
 from disco.util.config import Config
+from disco.util.emitter import Emitter
 from disco.util.logging import LoggingClass
 from disco.util.backdoor import DiscoBackdoorServer
 
@@ -26,14 +25,16 @@ class ClientConfig(Config):
         The shard ID for the current client instance.
     shard_count : int
         The total count of shards running.
+    guild_subscriptions : bool
+        Whether to enable subscription events (e.g. presence and typing).
     max_reconnects : int
         The maximum number of connection retries to make before giving up (0 = never give up).
-    log_level: str
+    log_level : str
         The logging level to use.
     manhole_enable : bool
         Whether to enable the manhole (e.g. console backdoor server) utility.
     manhole_bind : tuple(str, int)
-        A (host, port) combination which the manhole server will bind to (if its
+        A (host, port) combination which the manhole server will bind to (if it's
         enabled using :attr:`manhole_enable`).
     encoder : str
         The type of encoding to use for encoding/decoding data from websockets,
@@ -43,6 +44,7 @@ class ClientConfig(Config):
     token = ''
     shard_id = 0
     shard_count = 1
+    guild_subscriptions = True
     max_reconnects = 5
     log_level = 'info'
 
@@ -112,12 +114,12 @@ class Client(LoggingClass):
         """
         Updates the current clients presence.
 
-        Params
-        ------
+        Parameters
+        ----------
         status : `user.Status`
             The clients current status.
         game : `user.Game`
-            If passed, the game object to set for the users presence.
+            If passed, the game object to set for the user's presence.
         afk : bool
             Whether the client is currently afk.
         since : float
@@ -132,7 +134,7 @@ class Client(LoggingClass):
         payload = {
             'afk': afk,
             'since': since,
-            'status': status.value.lower(),
+            'status': status.lower(),
             'game': None,
         }
 

disco/gateway/client.py

@@ -2,7 +2,9 @@ import gevent
 import zlib
 import six
 import ssl
+import time
 
+import platform
 from websocket import ABNF
 
 from disco.gateway.packets import OPCode, RECV, SEND
@@ -70,6 +72,10 @@ class GatewayClient(LoggingClass):
         self._heartbeat_task = None
         self._heartbeat_acknowledged = True
 
+        # Latency
+        self._last_heartbeat = 0
+        self.latency = -1
+
     def send(self, op, data):
         self.limiter.check()
         return self._send(op, data)
@@ -78,7 +84,7 @@ class GatewayClient(LoggingClass):
         self.log.debug('GatewayClient.send %s', op)
         self.packets.emit((SEND, op), data)
         self.ws.send(self.encoder.encode({
-            'op': op.value,
+            'op': op,
             'd': data,
         }), self.encoder.OPCODE)
 
@@ -89,6 +95,7 @@ class GatewayClient(LoggingClass):
                 self._heartbeat_acknowledged = True
                 self.ws.close(status=4000)
                 return
+            self._last_heartbeat = time.time()
 
             self._send(OPCode.HEARTBEAT, self.seq)
             self._heartbeat_acknowledged = False
@@ -107,6 +114,7 @@ class GatewayClient(LoggingClass):
     def handle_heartbeat_acknowledge(self, _):
         self.log.debug('Received HEARTBEAT_ACK')
         self._heartbeat_acknowledged = True
+        self.latency = int((time.time() - self._last_heartbeat) * 1000)
 
     def handle_reconnect(self, _):
         self.log.warning('Received RECONNECT request, forcing a fresh reconnect')
@@ -188,7 +196,7 @@ class GatewayClient(LoggingClass):
             self.seq = data['s']
 
         # Emit packet
-        self.packets.emit((RECV, OPCode[data['op']]), data)
+        self.packets.emit((RECV, data['op']), data)
 
     def on_error(self, error):
         if isinstance(error, KeyboardInterrupt):
@@ -214,12 +222,13 @@ class GatewayClient(LoggingClass):
                 'token': self.client.config.token,
                 'compress': True,
                 'large_threshold': 250,
+                'guild_subscriptions': self.client.config.guild_subscriptions,
                 'shard': [
                     int(self.client.config.shard_id),
                     int(self.client.config.shard_count),
                 ],
                 'properties': {
-                    '$os': 'linux',
+                    '$os': platform.system(),
                     '$browser': 'disco',
                     '$device': 'disco',
                     '$referrer': '',
@@ -264,7 +273,7 @@ class GatewayClient(LoggingClass):
         gevent.spawn(self.connect_and_run)
         self.ws_event.wait()
 
-    def request_guild_members(self, guild_id_or_ids, query=None, limit=0):
+    def request_guild_members(self, guild_id_or_ids, query=None, limit=0, presences=False):
         """
         Request a batch of Guild members from Discord. Generally this function
         can be called when initially loading Guilds to fill the local member state.
@@ -272,6 +281,19 @@ class GatewayClient(LoggingClass):
         self.send(OPCode.REQUEST_GUILD_MEMBERS, {
             # This is simply unfortunate naming on the part of Discord...
             'guild_id': guild_id_or_ids,
+            'limit': limit,
+            'presences': presences,
             'query': query or '',
+        })
+
+    def request_guild_members_by_id(self, guild_id_or_ids, user_id_or_ids, limit=0, presences=False):
+        """
+        Request a batch of Guild members from Discord by their snowflake(s).
+        """
+        self.send(OPCode.REQUEST_GUILD_MEMBERS, {
+            'guild_id': guild_id_or_ids,
             'limit': limit,
+            'presences': presences,
+            # This is simply even more unfortunate naming from Discord...
+            'user_ids': user_id_or_ids,
         })

disco/gateway/encoding/base.py

@@ -1,9 +1,7 @@
 from websocket import ABNF
 
-from holster.interface import Interface
 
-
-class BaseEncoder(Interface):
+class BaseEncoder(object):
     TYPE = None
     OPCODE = ABNF.OPCODE_TEXT
 

disco/gateway/events.py

@@ -7,7 +7,7 @@ from disco.types.channel import Channel, PermissionOverwrite
 from disco.types.message import Message, MessageReactionEmoji
 from disco.types.voice import VoiceState
 from disco.types.guild import Guild, GuildMember, Role, GuildEmoji
-from disco.types.base import Model, ModelMeta, Field, ListField, AutoDictField, snowflake, datetime
+from disco.types.base import Model, ModelMeta, Field, ListField, AutoDictField, UNSET, snowflake, datetime
 from disco.util.string import underscore
 
 # Mapping of discords event name to our event classes
@@ -127,13 +127,13 @@ class Ready(GatewayEvent):
     for bootstrapping the client's states.
 
     Attributes
-    -----
+    ----------
     version : int
         The gateway version.
     session_id : str
         The session ID.
     user : :class:`disco.types.user.User`
-        The user object for the authed account.
+        The user object for the authenticated account.
     guilds : list[:class:`disco.types.guild.Guild`
         All guilds this account is a member of. These are shallow guild objects.
     private_channels list[:class:`disco.types.channel.Channel`]
@@ -144,14 +144,12 @@ class Ready(GatewayEvent):
     user = Field(User)
     guilds = ListField(Guild)
     private_channels = ListField(Channel)
-    trace = ListField(str, alias='_trace')
 
 
 class Resumed(GatewayEvent):
     """
     Sent after a resume completes.
     """
-    trace = ListField(str, alias='_trace')
 
 
 @wraps_model(Guild)
@@ -160,12 +158,12 @@ class GuildCreate(GatewayEvent):
     Sent when a guild is joined, or becomes available.
 
     Attributes
-    -----
+    ----------
     guild : :class:`disco.types.guild.Guild`
-        The guild being created (e.g. joined)
+        The guild being created (e.g. joined).
     unavailable : bool
         If false, this guild is coming online from a previously unavailable state,
-        and if None, this is a normal guild join event.
+        and if UNSET, this is a normal guild join event.
     """
     unavailable = Field(bool)
     presences = ListField(Presence)
@@ -175,7 +173,7 @@ class GuildCreate(GatewayEvent):
         """
         Shortcut property which is true when we actually joined the guild.
         """
-        return self.unavailable is None
+        return self.unavailable is UNSET
 
 
 @wraps_model(Guild)
@@ -184,7 +182,7 @@ class GuildUpdate(GatewayEvent):
     Sent when a guild is updated.
 
     Attributes
-    -----
+    ----------
     guild : :class:`disco.types.guild.Guild`
         The updated guild object.
     """
@@ -195,11 +193,11 @@ class GuildDelete(GatewayEvent):
     Sent when a guild is deleted, left, or becomes unavailable.
 
     Attributes
-    -----
+    ----------
     id : snowflake
         The ID of the guild being deleted.
     unavailable : bool
-        If true, this guild is becoming unavailable, if None this is a normal
+        If true, this guild is becoming unavailable, if UNSET this is a normal
         guild leave event.
     """
     id = Field(snowflake)
@@ -210,7 +208,7 @@ class GuildDelete(GatewayEvent):
         """
         Shortcut property which is true when we actually have left the guild.
         """
-        return self.unavailable is None
+        return self.unavailable is UNSET
 
 
 @wraps_model(Channel)
@@ -219,7 +217,7 @@ class ChannelCreate(GatewayEvent):
     Sent when a channel is created.
 
     Attributes
-    -----
+    ----------
     channel : :class:`disco.types.channel.Channel`
         The channel which was created.
     """
@@ -231,7 +229,7 @@ class ChannelUpdate(ChannelCreate):
     Sent when a channel is updated.
 
     Attributes
-    -----
+    ----------
     channel : :class:`disco.types.channel.Channel`
         The channel which was updated.
     """
@@ -244,7 +242,7 @@ class ChannelDelete(ChannelCreate):
     Sent when a channel is deleted.
 
     Attributes
-    -----
+    ----------
     channel : :class:`disco.types.channel.Channel`
         The channel being deleted.
     """
@@ -255,10 +253,10 @@ class ChannelPinsUpdate(GatewayEvent):
     Sent when a channel's pins are updated.
 
     Attributes
-    -----
+    ----------
     channel_id : snowflake
         ID of the channel where pins where updated.
-    last_pin_timestap : datetime
+    last_pin_timestamp : datetime
         The time the last message was pinned.
     """
     channel_id = Field(snowflake)
@@ -271,7 +269,7 @@ class GuildBanAdd(GatewayEvent):
     Sent when a user is banned from a guild.
 
     Attributes
-    -----
+    ----------
     guild_id : snowflake
         The ID of the guild the user is being banned from.
     user : :class:`disco.types.user.User`
@@ -291,7 +289,7 @@ class GuildBanRemove(GuildBanAdd):
     Sent when a user is unbanned from a guild.
 
     Attributes
-    -----
+    ----------
     guild_id : snowflake
         The ID of the guild the user is being unbanned from.
     user : :class:`disco.types.user.User`
@@ -308,11 +306,11 @@ class GuildEmojisUpdate(GatewayEvent):
     Sent when a guild's emojis are updated.
 
     Attributes
-    -----
+    ----------
     guild_id : snowflake
         The ID of the guild the emojis are being updated in.
     emojis : list[:class:`disco.types.guild.Emoji`]
-        The new set of emojis for the guild
+        The new set of emojis for the guild.
     """
     guild_id = Field(snowflake)
     emojis = ListField(GuildEmoji)
@@ -323,7 +321,7 @@ class GuildIntegrationsUpdate(GatewayEvent):
     Sent when a guild's integrations are updated.
 
     Attributes
-    -----
+    ----------
     guild_id : snowflake
         The ID of the guild integrations where updated in.
     """
@@ -335,14 +333,20 @@ class GuildMembersChunk(GatewayEvent):
     Sent in response to a member's chunk request.
 
     Attributes
-    -----
+    ----------
     guild_id : snowflake
         The ID of the guild this member chunk is for.
     members : list[:class:`disco.types.guild.GuildMember`]
         The chunk of members.
+    not_found : list[snowflake]
+        An array of invalid requested guild members.
+    presences : list[:class:`disco.types.user.Presence`]
+        An array of requested member presence states.
     """
     guild_id = Field(snowflake)
     members = ListField(GuildMember)
+    not_found = ListField(snowflake)
+    presences = ListField(Presence)
 
     @property
     def guild(self):
@@ -355,7 +359,7 @@ class GuildMemberAdd(GatewayEvent):
     Sent when a user joins a guild.
 
     Attributes
-    -----
+    ----------
     member : :class:`disco.types.guild.GuildMember`
         The member that has joined the guild.
     """
@@ -367,7 +371,7 @@ class GuildMemberRemove(GatewayEvent):
     Sent when a user leaves a guild (via leaving, kicking, or banning).
 
     Attributes
-    -----
+    ----------
     guild_id : snowflake
         The ID of the guild the member left from.
     user : :class:`disco.types.user.User`
@@ -387,7 +391,7 @@ class GuildMemberUpdate(GatewayEvent):
     Sent when a guilds member is updated.
 
     Attributes
-    -----
+    ----------
     member : :class:`disco.types.guild.GuildMember`
         The member being updated
     """
@@ -400,7 +404,7 @@ class GuildRoleCreate(GatewayEvent):
     Sent when a role is created.
 
     Attributes
-    -----
+    ----------
     guild_id : snowflake
         The ID of the guild where the role was created.
     role : :class:`disco.types.guild.Role`
@@ -419,7 +423,7 @@ class GuildRoleUpdate(GuildRoleCreate):
     Sent when a role is updated.
 
     Attributes
-    -----
+    ----------
     guild_id : snowflake
         The ID of the guild where the role was created.
     role : :class:`disco.types.guild.Role`
@@ -436,7 +440,7 @@ class GuildRoleDelete(GatewayEvent):
     Sent when a role is deleted.
 
     Attributes
-    -----
+    ----------
     guild_id : snowflake
         The ID of the guild where the role is being deleted.
     role_id : snowflake
@@ -456,7 +460,7 @@ class MessageCreate(GatewayEvent):
     Sent when a message is created.
 
     Attributes
-    -----
+    ----------
     message : :class:`disco.types.message.Message`
         The message being created.
     guild_id : snowflake
@@ -471,7 +475,7 @@ class MessageUpdate(MessageCreate):
     Sent when a message is updated/edited.
 
     Attributes
-    -----
+    ----------
     message : :class:`disco.types.message.Message`
         The message being updated.
     guild_id : snowflake
@@ -485,7 +489,7 @@ class MessageDelete(GatewayEvent):
     Sent when a message is deleted.
 
     Attributes
-    -----
+    ----------
     id : snowflake
         The ID of message being deleted.
     channel_id : snowflake
@@ -511,7 +515,7 @@ class MessageDeleteBulk(GatewayEvent):
     Sent when multiple messages are deleted from a channel.
 
     Attributes
-    -----
+    ----------
     guild_id : snowflake
         The guild the messages are being deleted in.
     channel_id : snowflake
@@ -538,7 +542,7 @@ class PresenceUpdate(GatewayEvent):
     Sent when a user's presence is updated.
 
     Attributes
-    -----
+    ----------
     presence : :class:`disco.types.user.Presence`
         The updated presence object.
     guild_id : snowflake
@@ -559,7 +563,7 @@ class TypingStart(GatewayEvent):
     Sent when a user begins typing in a channel.
 
     Attributes
-    -----
+    ----------
     guild_id : snowflake
         The ID of the guild where the user is typing.
     channel_id : snowflake
@@ -581,7 +585,7 @@ class VoiceStateUpdate(GatewayEvent):
     Sent when a users voice state changes.
 
     Attributes
-    -----
+    ----------
     state : :class:`disco.models.voice.VoiceState`
         The voice state which was updated.
     """
@@ -592,7 +596,7 @@ class VoiceServerUpdate(GatewayEvent):
     Sent when a voice server is updated.
 
     Attributes
-    -----
+    ----------
     token : str
         The token for the voice server.
     endpoint : str
@@ -610,7 +614,7 @@ class WebhooksUpdate(GatewayEvent):
     Sent when a channels webhooks are updated.
 
     Attributes
-    -----
+    ----------
     channel_id : snowflake
         The channel ID this webhooks update is for.
     guild_id : snowflake
@@ -716,3 +720,15 @@ class MessageReactionRemoveAll(GatewayEvent):
     @property
     def guild(self):
         return self.channel.guild
+
+
+@wraps_model(User)
+class UserUpdate(GatewayEvent):
+    """
+    Sent when the client user is updated.
+
+    Attributes
+    -----
+    user : :class:`disco.types.user.User`
+        The updated user object.
+    """

disco/gateway/ipc.py

@@ -3,8 +3,6 @@ import gevent
 import string
 import weakref
 
-from holster.enum import Enum
-
 from disco.util.logging import LoggingClass
 from disco.util.serializer import dump_function, load_function
 
@@ -13,12 +11,11 @@ def get_random_str(size):
     return ''.join([random.choice(string.printable) for _ in range(size)])
 
 
-IPCMessageType = Enum(
-    'CALL_FUNC',
-    'GET_ATTR',
-    'EXECUTE',
-    'RESPONSE',
-)
+class IPCMessageType(object):
+    CALL_FUNC = 1
+    GET_ATTR = 2
+    EXECUTE = 3
+    RESPONSE = 4
 
 
 class GIPCProxy(LoggingClass):
@@ -37,7 +34,7 @@ class GIPCProxy(LoggingClass):
         return base
 
     def send(self, typ, data):
-        self.pipe.put((typ.value, data))
+        self.pipe.put((typ, data))
 
     def handle(self, mtype, data):
         if mtype == IPCMessageType.CALL_FUNC:
@@ -75,17 +72,17 @@ class GIPCProxy(LoggingClass):
         nonce = get_random_str(32)
         raw = dump_function(func)
         self.results[nonce] = result = gevent.event.AsyncResult()
-        self.pipe.put((IPCMessageType.EXECUTE.value, (nonce, raw)))
+        self.pipe.put((IPCMessageType.EXECUTE, (nonce, raw)))
         return result
 
     def get(self, path):
         nonce = get_random_str(32)
         self.results[nonce] = result = gevent.event.AsyncResult()
-        self.pipe.put((IPCMessageType.GET_ATTR.value, (nonce, path)))
+        self.pipe.put((IPCMessageType.GET_ATTR, (nonce, path)))
         return result
 
     def call(self, path, *args, **kwargs):
         nonce = get_random_str(32)
         self.results[nonce] = result = gevent.event.AsyncResult()
-        self.pipe.put((IPCMessageType.CALL_FUNC.value, (nonce, path, args, kwargs)))
+        self.pipe.put((IPCMessageType.CALL_FUNC, (nonce, path, args, kwargs)))
         return result

disco/gateway/packets.py

@@ -1,20 +1,17 @@
-from holster.enum import Enum
-
 SEND = 1
 RECV = 2
 
-OPCode = Enum(
-    DISPATCH=0,
-    HEARTBEAT=1,
-    IDENTIFY=2,
-    STATUS_UPDATE=3,
-    VOICE_STATE_UPDATE=4,
-    VOICE_SERVER_PING=5,
-    RESUME=6,
-    RECONNECT=7,
-    REQUEST_GUILD_MEMBERS=8,
-    INVALID_SESSION=9,
-    HELLO=10,
-    HEARTBEAT_ACK=11,
-    GUILD_SYNC=12,
-)
+
+class OPCode(object):
+    DISPATCH = 0
+    HEARTBEAT = 1
+    IDENTIFY = 2
+    STATUS_UPDATE = 3
+    VOICE_STATE_UPDATE = 4
+    VOICE_SERVER_PING = 5
+    RESUME = 6
+    RECONNECT = 7
+    REQUEST_GUILD_MEMBERS = 8
+    INVALID_SESSION = 9
+    HELLO = 10
+    HEARTBEAT_ACK = 11

disco/state.py

@@ -3,13 +3,12 @@ import weakref
 
 from collections import deque, namedtuple
 from gevent.event import Event
-from holster.emitter import Priority
 
 from disco.types.base import UNSET
 from disco.util.config import Config
 from disco.util.string import underscore
 from disco.util.hashmap import HashMap, DefaultHashMap
-from disco.voice.client import VoiceState
+from disco.util.emitter import Priority
 
 
 class StackMessage(namedtuple('StackMessage', ['id', 'channel_id', 'author_id'])):
@@ -20,11 +19,11 @@ class StackMessage(namedtuple('StackMessage', ['id', 'channel_id', 'author_id'])
     Attributes
     ---------
     id : snowflake
-        the id of the message
+        The id of the message.
     channel_id : snowflake
-        the id of the channel this message was sent in
+        The id of the channel this message was sent in.
     author_id : snowflake
-        the id of the author of this message
+        The id of the author of this message.
     """
 
 
@@ -41,8 +40,8 @@ class StateConfig(Config):
 
         Message tracking is implemented using a deque and a namedtuple, meaning
         it should generally not have a high impact on memory, however users who
-        find they do not need and may be experiencing memory pressure can disable
-        this feature entirely using this attribute.
+        find that 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 messages deque for each channel. This value can be used
         to calculate the total number of possible `StackMessage` objects kept in
@@ -51,7 +50,7 @@ class StateConfig(Config):
     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
-        50 guilds will notice this operation can take a while to complete and may want
+        50 guilds will notice this operation can take a while to complete, and may want
         to batch requests using the underlying `GatewayClient.request_guild_members`
         interface.
     """
@@ -70,33 +69,33 @@ class State(object):
     Attributes
     ----------
     EVENTS : list(str)
-        A list of all events the State object binds to
+        A list of all events the State object binds to.
     client : `disco.client.Client`
-        The Client instance this state is attached to
+        The Client instance this state is attached to.
     config : `StateConfig`
-        The configuration for this state instance
+        The configuration for this state instance.
     me : `User`
-        The currently logged in user
+        The currently logged in user.
     dms : dict(snowflake, `Channel`)
-        Mapping of all known DM Channels
+        Mapping of all known DM Channels.
     guilds : dict(snowflake, `Guild`)
-        Mapping of all known/loaded Guilds
+        Mapping of all known/loaded Guilds.
     channels : dict(snowflake, `Channel`)
-        Weak mapping of all known/loaded Channels
+        Weak mapping of all known/loaded Channels.
     users : dict(snowflake, `User`)
-        Weak mapping of all known/loaded Users
+        Weak mapping of all known/loaded Users.
     voice_clients : dict(str, 'VoiceClient')
-        Weak mapping of all known voice clients
+        Weak mapping of all known voice clients.
     voice_states : dict(str, `VoiceState`)
-        Weak mapping of all known/active Voice States
+        Weak mapping of all known/active Voice States.
     messages : Optional[dict(snowflake, deque)]
-        Mapping of channel ids to deques containing `StackMessage` objects
+        Mapping of channel ids to deques containing `StackMessage` objects.
     """
     EVENTS = [
         'Ready', 'GuildCreate', 'GuildUpdate', 'GuildDelete', 'GuildMemberAdd', 'GuildMemberRemove',
         'GuildMemberUpdate', 'GuildMembersChunk', 'GuildRoleCreate', 'GuildRoleUpdate', 'GuildRoleDelete',
         'GuildEmojisUpdate', 'ChannelCreate', 'ChannelUpdate', 'ChannelDelete', 'VoiceServerUpdate', 'VoiceStateUpdate',
-        'MessageCreate', 'PresenceUpdate',
+        'MessageCreate', 'PresenceUpdate', 'UserUpdate',
     ]
 
     def __init__(self, client, config):
@@ -139,7 +138,7 @@ class State(object):
 
         for event in self.EVENTS:
             func = 'on_' + underscore(event)
-            self.listeners.append(self.client.events.on(event, getattr(self, func), priority=Priority.BEFORE))
+            self.listeners.append(self.client.events.on(event, getattr(self, func), priority=Priority.AFTER))
 
     def fill_messages(self, channel):
         for message in reversed(next(channel.messages_iter(bulk=True))):
@@ -154,6 +153,9 @@ class State(object):
             self.dms[dm.id] = dm
             self.channels[dm.id] = dm
 
+    def on_user_update(self, event):
+        self.me.inplace_update(event.user)
+
     def on_message_create(self, event):
         if self.config.track_messages:
             self.messages[event.message.channel_id].append(
@@ -227,6 +229,11 @@ class State(object):
         elif event.channel.is_dm:
             self.dms[event.channel.id] = event.channel
             self.channels[event.channel.id] = event.channel
+            for user in six.itervalues(event.channel.recipients):
+                if user.id not in self.users:
+                    self.users[user.id] = user
+                else:
+                    event.channel.recipients[user.id] = self.users[user.id]
 
     def on_channel_update(self, event):
         if event.channel.id in self.channels:
@@ -274,21 +281,6 @@ class State(object):
                 del self.voice_states[expired_voice_state.session_id]
             self.voice_states[event.state.session_id] = event.state
 
-        if event.state.user_id != self.me.id:
-            return
-
-        server_id = event.state.guild_id or event.state.channel_id
-        if server_id in self.voice_clients:
-            voice_client = self.voice_clients[server_id]
-
-            voice_client.channel_id = event.state.channel_id
-            if not event.state.channel_id:
-                voice_client.disconnect()
-                return
-
-            if voice_client.token:
-                voice_client.set_state(VoiceState.CONNECTED)
-
     def on_guild_member_add(self, event):
         if event.member.user.id not in self.users:
             self.users[event.member.user.id] = event.member.user
@@ -298,6 +290,10 @@ class State(object):
         if event.member.guild_id not in self.guilds:
             return
 
+        # Avoid adding duplicate events to member_count.
+        if event.member.id not in self.guilds[event.member.guild_id].members:
+            self.guilds[event.member.guild_id].member_count += 1
+
         self.guilds[event.member.guild_id].members[event.member.id] = event.member
 
     def on_guild_member_update(self, event):
@@ -316,6 +312,8 @@ class State(object):
         if event.user.id not in self.guilds[event.guild_id].members:
             return
 
+        self.guilds[event.guild_id].member_count -= 1
+
         del self.guilds[event.guild_id].members[event.user.id]
 
     def on_guild_members_chunk(self, event):
@@ -332,6 +330,15 @@ class State(object):
             else:
                 member.user = self.users[member.id]
 
+        if not event.presences:
+            return
+
+        for presence in event.presences:
+            # TODO: this matches the recursive, hackfix method found in on_presence_update
+            user = presence.user
+            user.presence = presence
+            self.users[user.id].inplace_update(user)
+
     def on_guild_role_create(self, event):
         if event.guild_id not in self.guilds:
             return

disco/types/base.py

@@ -3,11 +3,11 @@ import gevent
 import inspect
 import functools
 
-from holster.enum import BaseEnumMeta, EnumAttr
 from datetime import datetime as real_datetime
 
 from disco.util.chains import Chainable
 from disco.util.hashmap import HashMap
+from disco.util.enum import get_enum_members
 
 DATETIME_FORMATS = [
     '%Y-%m-%dT%H:%M:%S.%f',
@@ -109,10 +109,10 @@ class Field(object):
     def type_to_deserializer(typ):
         if isinstance(typ, Field) or inspect.isclass(typ) and issubclass(typ, Model):
             return typ
-        elif isinstance(typ, BaseEnumMeta):
-            def _f(raw, client, **kwargs):
-                return typ.get(raw)
-            return _f
+        # elif isinstance(typ, BaseEnumMeta):
+        #    def _f(raw, client, **kwargs):
+        #        return typ.get(raw)
+        #    return _f
         elif typ is None:
             def _f(*args, **kwargs):
                 return None
@@ -123,9 +123,7 @@ class Field(object):
 
     @staticmethod
     def serialize(value, inst=None):
-        if isinstance(value, EnumAttr):
-            return value.value
-        elif isinstance(value, Model):
+        if isinstance(value, Model):
             return value.to_dict(ignore=(inst.ignore_dump if inst else []))
         else:
             if inst and inst.cast:
@@ -196,9 +194,16 @@ def snowflake(data):
 
 def enum(typ):
     def _f(data):
-        if isinstance(data, str):
-            data = data.lower()
-        return typ.get(data) if data is not None else None
+        if data is None:
+            return None
+
+        for k, v in get_enum_members(typ):
+            if isinstance(data, six.string_types) and k == data.upper():
+                return v
+            elif k == data or v == data:
+                return v
+
+        return None
     return _f
 
 
@@ -215,7 +220,7 @@ def datetime(data):
         except (ValueError, TypeError):
             continue
 
-    raise ValueError('Failed to conver `{}` to datetime'.format(data))
+    raise ValueError('Failed to convert `{}` to datetime'.format(data))
 
 
 def text(obj):
@@ -381,7 +386,7 @@ class Model(six.with_metaclass(ModelMeta, Chainable)):
             if ignore and name in ignore:
                 continue
 
-            if getattr(self, name) == UNSET:
+            if getattr(self, name) is UNSET:
                 continue
             obj[name] = field.serialize(getattr(self, name), field)
         return obj
@@ -416,3 +421,77 @@ class Model(six.with_metaclass(ModelMeta, Chainable)):
 
 class SlottedModel(Model):
     __slots__ = ['client']
+
+
+class BitsetMap(object):
+    @classmethod
+    def keys(cls):
+        for k, v in six.iteritems(cls.__dict__):
+            if k.isupper():
+                yield k
+
+
+class BitsetValue(object):
+    __slots__ = ['value', 'map']
+
+    def __init__(self, value=0):
+        if isinstance(value, self.__class__):
+            value = value.value
+
+        self.value = value
+
+    def check(self, *args):
+        for arg in args:
+            if not (self.value & arg) == arg:
+                return False
+        return True
+
+    def add(self, other):
+        if isinstance(other, self.__class__):
+            self.value |= other.value
+        elif isinstance(other, int):
+            self.value |= other
+        else:
+            raise TypeError('Cannot BitsetValue.add from type {}'.format(type(other)))
+        return self
+
+    def sub(self, other):
+        if isinstance(other, self.__class__):
+            self.value &= ~other.value
+        elif isinstance(other, int):
+            self.value &= ~other
+        else:
+            raise TypeError('Cannot BitsetValue.sub from type {}'.format(type(other)))
+        return self
+
+    def __iadd__(self, other):
+        return self.add(other)
+
+    def __isub__(self, other):
+        return self.sub(other)
+
+    def __getattribute__(self, name):
+        try:
+            perm_value = getattr(super(BitsetValue, self).__getattribute__('map'), name.upper())
+            return (self.value & perm_value) == perm_value
+        except AttributeError:
+            return super(BitsetValue, self).__getattribute__(name)
+
+    def __setattr__(self, name, value):
+        try:
+            perm_value = getattr(self.map, name.upper())
+        except AttributeError:
+            return super(BitsetValue, self).__setattr__(name, value)
+
+        if value:
+            self.value |= perm_value
+        else:
+            self.value &= ~perm_value
+
+    def __int__(self):
+        return self.value
+
+    def to_dict(self):
+        return {
+            k: getattr(self, k) for k in list(self.map.keys())
+        }

disco/types/channel.py

@@ -2,7 +2,6 @@ import re
 import six
 
 from six.moves import map
-from holster.enum import Enum
 
 from disco.util.snowflake import to_snowflake
 from disco.util.functional import one_or_many, chunks
@@ -14,19 +13,19 @@ from disco.types.permissions import Permissions, Permissible, PermissionValue
 NSFW_RE = re.compile('^nsfw(-|$)')
 
 
-ChannelType = Enum(
-    GUILD_TEXT=0,
-    DM=1,
-    GUILD_VOICE=2,
-    GROUP_DM=3,
-    GUILD_CATEGORY=4,
-    GUILD_NEWS=5,
-)
+class ChannelType(object):
+    GUILD_TEXT = 0
+    DM = 1
+    GUILD_VOICE = 2
+    GROUP_DM = 3
+    GUILD_CATEGORY = 4
+    GUILD_NEWS = 5
+    GUILD_STORE = 6
 
-PermissionOverwriteType = Enum(
-    ROLE='role',
-    MEMBER='member',
-)
+
+class PermissionOverwriteType(object):
+    ROLE = 'role'
+    MEMBER = 'member'
 
 
 class ChannelSubType(SlottedModel):
@@ -44,13 +43,13 @@ class PermissionOverwrite(ChannelSubType):
     Attributes
     ----------
     id : snowflake
-        The overwrite ID
+        The overwrite ID.
     type : :const:`disco.types.channel.PermissionsOverwriteType`
-        The overwrite type
+        The overwrite type.
     allow : :class:`disco.types.permissions.PermissionValue`
-        All allowed permissions
+        All allowed permissions.
     deny : :class:`disco.types.permissions.PermissionValue`
-        All denied permissions
+        All denied permissions.
     """
     id = Field(snowflake)
     type = Field(enum(PermissionOverwriteType))
@@ -85,7 +84,7 @@ class PermissionOverwrite(ChannelSubType):
                                                     self.id,
                                                     self.allow.value or 0,
                                                     self.deny.value or 0,
-                                                    self.type.name,
+                                                    self.type,
                                                     **kwargs)
         return self
 
@@ -113,7 +112,7 @@ class Channel(SlottedModel, Permissible):
         The channel's bitrate.
     user_limit : int
         The channel's user limit.
-    recipients: list(:class:`disco.types.user.User`)
+    recipients : list(:class:`disco.types.user.User`)
         Members of this channel (if this is a DM channel).
     type : :const:`ChannelType`
         The type of this channel.
@@ -133,6 +132,7 @@ class Channel(SlottedModel, Permissible):
     type = Field(enum(ChannelType))
     overwrites = AutoDictField(PermissionOverwrite, 'id', alias='permission_overwrites')
     parent_id = Field(snowflake)
+    rate_limit_per_user = Field(int)
 
     def __init__(self, *args, **kwargs):
         super(Channel, self).__init__(*args, **kwargs)
@@ -265,7 +265,7 @@ class Channel(SlottedModel, Permissible):
         Returns
         -------
         `Message`
-            The fetched message
+            The fetched message.
         """
         return self.client.api.channels_messages_get(self.id, to_snowflake(message))
 
@@ -304,8 +304,8 @@ class Channel(SlottedModel, Permissible):
         """
         Pins the given message to the channel.
 
-        Params
-        ------
+        Parameters
+        ----------
         message : `Message`|snowflake
             The message or message ID to pin.
         """
@@ -315,8 +315,8 @@ class Channel(SlottedModel, Permissible):
         """
         Unpins the given message from the channel.
 
-        Params
-        ------
+        Parameters
+        ----------
         message : `Message`|snowflake
             The message or message ID to pin.
         """
@@ -362,18 +362,6 @@ class Channel(SlottedModel, Permissible):
         """
         self.client.api.channels_typing(self.id)
 
-    def connect(self, *args, **kwargs):
-        """
-        Connect to this channel over voice.
-        """
-        from disco.voice.client import VoiceClient
-        assert self.is_voice, 'Channel must support voice to connect'
-
-        server_id = self.guild_id or self.id
-        vc = self.client.state.voice_clients.get(server_id) or VoiceClient(self.client, server_id, is_dm=self.is_dm)
-
-        return vc.connect(self.id, *args, **kwargs)
-
     def create_overwrite(self, *args, **kwargs):
         """
         Creates a `PermissionOverwrite` for this channel. See
@@ -385,8 +373,8 @@ class Channel(SlottedModel, Permissible):
         """
         Deletes a single message from this channel.
 
-        Args
-        ----
+        Parameters
+        ----------
         message : snowflake|`Message`
             The message to delete.
         """
@@ -398,8 +386,8 @@ class Channel(SlottedModel, Permissible):
         Deletes a set of messages using the correct API route based on the number
         of messages passed.
 
-        Args
-        ----
+        Parameters
+        ----------
         messages : list(snowflake|`Message`)
             List of messages (or message ids) to delete. All messages must originate
             from this channel.
@@ -477,6 +465,16 @@ class Channel(SlottedModel, Permissible):
             parent_id=to_snowflake(parent) if parent else parent,
             reason=reason)
 
+    def set_slowmode(self, interval, reason=None):
+        """
+        Sets the channels slowmode (rate_limit_per_user).
+        """
+        assert (self.type == ChannelType.GUILD_TEXT)
+        return self.client.api.channels_modify(
+            self.id,
+            rate_limit_per_user=interval,
+            reason=reason)
+
     def create_text_channel(self, *args, **kwargs):
         """
         Creates a sub-text-channel in this category. See `Guild.create_text_channel`
@@ -528,7 +526,9 @@ class MessageIterator(object):
     chunk_size : int
         The number of messages to request per API call.
     """
-    Direction = Enum('UP', 'DOWN')
+    class Direction(object):
+        UP = 1
+        DOWN = 2
 
     def __init__(self, client, channel, direction=Direction.UP, bulk=False, before=None, after=None, chunk_size=100):
         self.client = client

disco/types/guild.py

@@ -1,8 +1,6 @@
 import six
 import warnings
 
-from holster.enum import Enum
-
 from disco.api.http import APIException
 from disco.util.paginator import Paginator
 from disco.util.snowflake import to_snowflake
@@ -17,24 +15,23 @@ from disco.types.message import Emoji
 from disco.types.permissions import PermissionValue, Permissions, Permissible
 
 
-VerificationLevel = Enum(
-    NONE=0,
-    LOW=1,
-    MEDIUM=2,
-    HIGH=3,
-    EXTREME=4,
-)
+class VerificationLevel(object):
+    NONE = 0
+    LOW = 1
+    MEDIUM = 2
+    HIGH = 3
+    EXTREME = 4
 
-ExplicitContentFilterLevel = Enum(
-    NONE=0,
-    WITHOUT_ROLES=1,
-    ALL=2,
-)
 
-DefaultMessageNotificationsLevel = Enum(
-    ALL_MESSAGES=0,
-    ONLY_MENTIONS=1,
-)
+class ExplicitContentFilterLevel(object):
+    NONE = 0
+    WITHOUT_ROLES = 1
+    ALL = 2
+
+
+class DefaultMessageNotificationsLevel(object):
+    ALL_MESSAGES = 0
+    ONLY_MENTIONS = 1
 
 
 class GuildEmoji(Emoji):
@@ -82,6 +79,10 @@ class GuildEmoji(Emoji):
         return self.client.state.guilds.get(self.guild_id)
 
 
+class PruneCount(SlottedModel):
+    pruned = Field(int, default=None)
+
+
 class Role(SlottedModel):
     """
     A role object.
@@ -136,6 +137,11 @@ class GuildBan(SlottedModel):
     reason = Field(text)
 
 
+class GuildEmbed(SlottedModel):
+    enabled = Field(bool)
+    channel_id = Field(snowflake)
+
+
 class GuildMember(SlottedModel):
     """
     A GuildMember object.
@@ -156,6 +162,8 @@ class GuildMember(SlottedModel):
         When this user joined the guild.
     roles : list(snowflake)
         Roles this member is part of.
+    premium_since : datetime
+        When this user set their Nitro boost to this server.
     """
     user = Field(User)
     guild_id = Field(snowflake)
@@ -164,6 +172,7 @@ class GuildMember(SlottedModel):
     deaf = Field(bool)
     joined_at = Field(datetime)
     roles = ListField(snowflake)
+    premium_since = Field(datetime)
 
     def __str__(self):
         return self.user.__str__()
@@ -195,8 +204,8 @@ class GuildMember(SlottedModel):
         """
         Bans the member from the guild.
 
-        Args
-        ----
+        Parameters
+        ----------
         delete_message_days : int
             The number of days to retroactively delete messages for.
         """
@@ -212,8 +221,8 @@ class GuildMember(SlottedModel):
         """
         Sets the member's nickname (or clears it if None).
 
-        Args
-        ----
+        Parameters
+        ----------
         nickname : Optional[str]
             The nickname (or none to reset) to set.
         """
@@ -309,6 +318,10 @@ class Guild(SlottedModel, Permissible):
         All of the guild's emojis.
     voice_states : dict(str, :class:`disco.types.voice.VoiceState`)
         All of the guild's voice states.
+    premium_tier : int
+        Guild's premium tier.
+    premium_subscription_count : int
+        The amount of users using their Nitro boost on this guild.
     """
     id = Field(snowflake)
     owner_id = Field(snowflake)
@@ -333,6 +346,12 @@ class Guild(SlottedModel, Permissible):
     emojis = AutoDictField(GuildEmoji, 'id')
     voice_states = AutoDictField(VoiceState, 'session_id')
     member_count = Field(int)
+    premium_tier = Field(int)
+    premium_subscription_count = Field(int, default=0)
+    vanity_url_code = Field(text)
+    max_presences = Field(int, default=5000)
+    max_members = Field(int)
+    description = Field(text)
 
     def __init__(self, *args, **kwargs):
         super(Guild, self).__init__(*args, **kwargs)
@@ -407,6 +426,12 @@ class Guild(SlottedModel, Permissible):
 
         return self.members.get(user)
 
+    def get_prune_count(self, days=None):
+        return self.client.api.guilds_prune_count_get(self.id, days=days)
+
+    def prune(self, days=None, compute_prune_count=None):
+        return self.client.api.guilds_prune_create(self.id, days=days, compute_prune_count=compute_prune_count)
+
     def create_role(self, **kwargs):
         """
         Create a new role.
@@ -430,8 +455,11 @@ class Guild(SlottedModel, Permissible):
 
         return self.client.api.guilds_roles_modify(self.id, to_snowflake(role), **kwargs)
 
-    def request_guild_members(self, query=None, limit=0):
-        self.client.gw.request_guild_members(self.id, query, limit)
+    def request_guild_members(self, query=None, limit=0, presences=False):
+        self.client.gw.request_guild_members(self.id, query, limit, presences)
+
+    def request_guild_members_by_id(self, user_id_or_ids, limit=0, presences=False):
+        self.client.gw.request_guild_members_by_id(self.id, user_id_or_ids, limit, presences)
 
     def sync(self):
         warnings.warn(
@@ -443,6 +471,9 @@ class Guild(SlottedModel, Permissible):
     def get_bans(self):
         return self.client.api.guilds_bans_list(self.id)
 
+    def get_ban(self, user):
+        return self.client.api.guilds_bans_get(self.id, user)
+
     def delete_ban(self, user, **kwargs):
         self.client.api.guilds_bans_delete(self.id, to_snowflake(user), **kwargs)
 
@@ -507,11 +538,30 @@ class Guild(SlottedModel, Permissible):
     def get_emojis(self):
         return self.client.api.guilds_emojis_list(self.id)
 
-    def get_icon_url(self, fmt='webp', size=1024):
+    def get_emoji(self, emoji):
+        return self.client.api.guilds_emojis_get(self.id, emoji)
+
+    def get_voice_regions(self):
+        return self.client.api.guilds_voice_regions_list(self.id)
+
+    def get_icon_url(self, still_format='webp', animated_format='gif', size=1024):
         if not self.icon:
             return ''
 
-        return 'https://cdn.discordapp.com/icons/{}/{}.{}?size={}'.format(self.id, self.icon, fmt, size)
+        if self.icon.startswith('a_'):
+            return 'https://cdn.discordapp.com/icons/{}/{}.{}?size={}'.format(
+                self.id, self.icon, animated_format, size
+            )
+        else:
+            return 'https://cdn.discordapp.com/icons/{}/{}.{}?size={}'.format(
+                self.id, self.icon, still_format, size
+            )
+
+    def get_vanity_url(self):
+        if not self.vanity_url_code:
+            return ''
+
+        return 'https://discord.gg/' + self.vanity_url_code
 
     def get_splash_url(self, fmt='webp', size=1024):
         if not self.splash:
@@ -529,6 +579,10 @@ class Guild(SlottedModel, Permissible):
     def icon_url(self):
         return self.get_icon_url()
 
+    @property
+    def vanity_url(self):
+        return self.get_vanity_url()
+
     @property
     def splash_url(self):
         return self.get_splash_url()
@@ -557,34 +611,52 @@ class Guild(SlottedModel, Permissible):
         return self.client.api.guilds_auditlogs_list(self.id, *args, **kwargs)
 
 
-AuditLogActionTypes = Enum(
-    GUILD_UPDATE=1,
-    CHANNEL_CREATE=10,
-    CHANNEL_UPDATE=11,
-    CHANNEL_DELETE=12,
-    CHANNEL_OVERWRITE_CREATE=13,
-    CHANNEL_OVERWRITE_UPDATE=14,
-    CHANNEL_OVERWRITE_DELETE=15,
-    MEMBER_KICK=20,
-    MEMBER_PRUNE=21,
-    MEMBER_BAN_ADD=22,
-    MEMBER_BAN_REMOVE=23,
-    MEMBER_UPDATE=24,
-    MEMBER_ROLE_UPDATE=25,
-    ROLE_CREATE=30,
-    ROLE_UPDATE=31,
-    ROLE_DELETE=32,
-    INVITE_CREATE=40,
-    INVITE_UPDATE=41,
-    INVITE_DELETE=42,
-    WEBHOOK_CREATE=50,
-    WEBHOOK_UPDATE=51,
-    WEBHOOK_DELETE=52,
-    EMOJI_CREATE=60,
-    EMOJI_UPDATE=61,
-    EMOJI_DELETE=62,
-    MESSAGE_DELETE=72,
-)
+class IntegrationAccount(SlottedModel):
+    id = Field(text)
+    name = Field(text)
+
+
+class Integration(SlottedModel):
+    id = Field(snowflake)
+    name = Field(text)
+    type = Field(text)
+    enabled = Field(bool)
+    syncing = Field(bool)
+    role_id = Field(snowflake)
+    expire_behavior = Field(int)
+    expire_grace_period = Field(int)
+    user = Field(User)
+    account = Field(IntegrationAccount)
+    synced_at = Field(datetime)
+
+
+class AuditLogActionTypes(object):
+    GUILD_UPDATE = 1
+    CHANNEL_CREATE = 10
+    CHANNEL_UPDATE = 11
+    CHANNEL_DELETE = 12
+    CHANNEL_OVERWRITE_CREATE = 13
+    CHANNEL_OVERWRITE_UPDATE = 14
+    CHANNEL_OVERWRITE_DELETE = 15
+    MEMBER_KICK = 20
+    MEMBER_PRUNE = 21
+    MEMBER_BAN_ADD = 22
+    MEMBER_BAN_REMOVE = 23
+    MEMBER_UPDATE = 24
+    MEMBER_ROLE_UPDATE = 25
+    ROLE_CREATE = 30
+    ROLE_UPDATE = 31
+    ROLE_DELETE = 32
+    INVITE_CREATE = 40
+    INVITE_UPDATE = 41
+    INVITE_DELETE = 42
+    WEBHOOK_CREATE = 50
+    WEBHOOK_UPDATE = 51
+    WEBHOOK_DELETE = 52
+    EMOJI_CREATE = 60
+    EMOJI_UPDATE = 61
+    EMOJI_DELETE = 62
+    MESSAGE_DELETE = 72
 
 
 GUILD_ACTIONS = (

disco/types/invite.py

@@ -1,9 +1,13 @@
-from disco.types.base import SlottedModel, Field, datetime
+from disco.types.base import SlottedModel, Field, datetime, enum
 from disco.types.user import User
 from disco.types.guild import Guild
 from disco.types.channel import Channel
 
 
+class InviteTargetUserType(object):
+    STREAM = 1
+
+
 class Invite(SlottedModel):
     """
     An invite object.
@@ -12,30 +16,42 @@ class Invite(SlottedModel):
     ----------
     code : str
         The invite code.
-    inviter : :class:`disco.types.user.User`
-        The user who created this invite.
     guild : :class:`disco.types.guild.Guild`
         The guild this invite is for.
     channel : :class:`disco.types.channel.Channel`
         The channel this invite is for.
-    max_age : int
-        The time after this invite's creation at which it expires.
-    max_uses : int
-        The maximum number of uses.
+    target_user : :class:`disco.types.user.User`
+        The user this invite targets.
+    target_user_type : int
+        The type of user target for this invite.
+    approximate_presence_count : int
+        The approximate count of online members.
+    approximate_member_count : int
+        The approximate count of total members.
+    inviter : :class:`disco.types.user.User`
+        The user who created this invite.
     uses : int
         The current number of times the invite was used.
+    max_uses : int
+        The maximum number of uses.
+    max_age : int
+        The time after this invite's creation at which it expires.
     temporary : bool
         Whether this invite only grants temporary membership.
     created_at : datetime
         When this invite was created.
     """
     code = Field(str)
-    inviter = Field(User)
     guild = Field(Guild)
     channel = Field(Channel)
-    max_age = Field(int)
-    max_uses = Field(int)
+    target_user = Field(User)
+    target_user_type = Field(enum(InviteTargetUserType))
+    approximate_presence_count = Field(int)
+    approximate_member_count = Field(int)
+    inviter = Field(User)
     uses = Field(int)
+    max_uses = Field(int)
+    max_age = Field(int)
     temporary = Field(bool)
     created_at = Field(datetime)
 

disco/types/message.py

@@ -4,27 +4,37 @@ import warnings
 import functools
 import unicodedata
 
-from holster.enum import Enum
-
 from disco.types.base import (
-    SlottedModel, Field, ListField, AutoDictField, snowflake, text,
-    datetime, enum, cached_property,
+    BitsetMap, BitsetValue, SlottedModel, Field, ListField, AutoDictField,
+    snowflake, text, datetime, enum, cached_property,
 )
 from disco.util.paginator import Paginator
 from disco.util.snowflake import to_snowflake
+from disco.types.channel import ChannelType
 from disco.types.user import User
 
 
-MessageType = Enum(
-    DEFAULT=0,
-    RECIPIENT_ADD=1,
-    RECIPIENT_REMOVE=2,
-    CALL=3,
-    CHANNEL_NAME_CHANGE=4,
-    CHANNEL_ICON_CHANGE=5,
-    PINS_ADD=6,
-    GUILD_MEMBER_JOIN=7,
-)
+class MessageType(object):
+    DEFAULT = 0
+    RECIPIENT_ADD = 1
+    RECIPIENT_REMOVE = 2
+    CALL = 3
+    CHANNEL_NAME_CHANGE = 4
+    CHANNEL_ICON_CHANGE = 5
+    PINS_ADD = 6
+    GUILD_MEMBER_JOIN = 7
+    USER_PREMIUM_GUILD_SUBSCRIPTION = 8
+    USER_PREMIUM_GUILD_SUBSCRIPTION_TIER_1 = 9
+    USER_PREMIUM_GUILD_SUBSCRIPTION_TIER_2 = 10
+    USER_PREMIUM_GUILD_SUBSCRIPTION_TIER_3 = 11
+    CHANNEL_FOLLOW_ADD = 12
+
+
+class MessageActivityType(object):
+    JOIN = 1
+    SPECTATE = 2
+    LISTEN = 3
+    JOIN_REQUEST = 5
 
 
 class Emoji(SlottedModel):
@@ -84,6 +94,51 @@ class MessageReaction(SlottedModel):
     me = Field(bool)
 
 
+class MessageApplication(SlottedModel):
+    """
+    The application of a Rich Presence-related chat embed.
+
+    Attributes
+    ----------
+    id : snowflake
+        The id of the application.
+    cover_image : str
+        The id of the embed's image asset.
+    description : str
+        The application's description.
+    icon : str
+        The id of the application's icon.
+    name : str
+        The name of the application.
+    """
+    id = Field(snowflake)
+    cover_image = Field(text)
+    description = Field(text)
+    icon = Field(text)
+    name = Field(text)
+
+
+class MessageReference(SlottedModel):
+    message_id = Field(snowflake)
+    channel_id = Field(snowflake)
+    guild_id = Field(snowflake)
+
+
+class MessageActivity(SlottedModel):
+    """
+    The activity of a Rich Presence-related chat embed.
+
+    Attributes
+    ----------
+    type : `MessageActivityType`
+        The type of message activity.
+    party_id : str
+        The party id from a Rich Presence event.
+    """
+    type = Field(enum(MessageActivityType))
+    party_id = Field(text)
+
+
 class MessageEmbedFooter(SlottedModel):
     """
     A footer for the `MessageEmbed`.
@@ -312,6 +367,25 @@ class MessageAttachment(SlottedModel):
     width = Field(int)
 
 
+class ChannelMention(SlottedModel):
+    id = Field(snowflake)
+    guild_id = Field(snowflake)
+    type = Field(enum(ChannelType))
+    name = Field(text)
+
+
+class MessageFlags(BitsetMap):
+    CROSSPOSTED = 1 << 0
+    IS_CROSSPOST = 1 << 1
+    SUPPRESS_EMBEDS = 1 << 2
+    SOURCE_MESSAGE_DELETED = 1 << 3
+    URGENT = 1 << 4
+
+
+class MessageFlagValue(BitsetValue):
+    map = MessageFlags
+
+
 class Message(SlottedModel):
     """
     Represents a Message created within a Channel on Discord.
@@ -346,10 +420,20 @@ class Message(SlottedModel):
         IDs for roles mentioned within this message.
     embeds : list[`MessageEmbed`]
         Embeds for this message.
+    mention_channels : list[`ChannelMention`]
+        The channels mentioned in this message if it is cross-posted.
     attachments : dict[`MessageAttachment`]
         Attachments for this message.
     reactions : list[`MessageReaction`]
         Reactions for this message.
+    activity : `MessageActivity`
+        The activity of a Rich Presence-related chat embed.
+    application : `MessageApplication`
+        The application of a Rich Presence-related chat embed.
+    message_reference: `MessageReference`
+        The reference of a cross-posted message.
+    flags: `MessageFlagValue`
+        The flags attached to a message.
     """
     id = Field(snowflake)
     channel_id = Field(snowflake)
@@ -366,8 +450,13 @@ class Message(SlottedModel):
     mentions = AutoDictField(User, 'id')
     mention_roles = ListField(snowflake)
     embeds = ListField(MessageEmbed)
+    mention_channels = ListField(ChannelMention)
     attachments = AutoDictField(MessageAttachment, 'id')
     reactions = ListField(MessageReaction)
+    activity = Field(MessageActivity)
+    application = Field(MessageApplication)
+    message_reference = Field(MessageReference)
+    flags = Field(MessageFlagValue)
 
     def __str__(self):
         return '<Message {} ({})>'.format(self.id, self.channel_id)
@@ -429,8 +518,8 @@ class Message(SlottedModel):
         """
         Edit this message.
 
-        Args
-        ----
+        Parameters
+        ----------
         content : str
             The new edited contents of the message.
 
@@ -452,6 +541,24 @@ class Message(SlottedModel):
         """
         return self.client.api.channels_messages_delete(self.channel_id, self.id)
 
+    def set_embeds_suppressed(self, state):
+        """
+        Toggle this message's embed suppression.
+
+        Parameters
+        ----------
+        `state`
+            Whether this message's embeds should be suppressed.
+        """
+        flags = int(self.flags or 0)
+
+        if state:
+            flags |= MessageFlags.SUPPRESS_EMBEDS
+        else:
+            flags &= ~MessageFlags.SUPPRESS_EMBEDS
+
+        self.edit(flags=flags)
+
     def get_reactors(self, emoji, *args, **kwargs):
         """
         Returns an iterator which paginates the reactors for the given emoji.
@@ -512,6 +619,15 @@ class Message(SlottedModel):
             emoji,
             user)
 
+    def delete_all_reactions(self):
+        """
+        Deletes all the reactions from a message.
+        """
+        self.client.api.channels_messages_reactions_delete_all(
+            self.channel_id,
+            self.id,
+        )
+
     def is_mentioned(self, entity):
         """
         Returns
@@ -559,8 +675,8 @@ class Message(SlottedModel):
         """
         Replaces user and role mentions with the result of a given lambda/function.
 
-        Args
-        ----
+        Parameters
+        ----------
         user_replace : function
             A function taking a single argument, the user object mentioned, and
             returning a valid string.

disco/types/oauth.py

@@ -0,0 +1,85 @@
+from disco.types.base import SlottedModel, Field, ListField, snowflake, text, enum
+from disco.types.guild import Integration
+from disco.types.user import User
+from disco.util.snowflake import to_snowflake
+
+
+class TeamMembershipState(object):
+    INVITED = 1
+    ACCEPTED = 2
+
+
+class TeamMember(SlottedModel):
+    membership_state = Field(enum(TeamMembershipState))
+    permissions = Field(text)
+    team_id = Field(snowflake)
+    user = Field(User)
+
+
+class Team(SlottedModel):
+    icon = Field(text)
+    id = Field(snowflake)
+    members = ListField(TeamMember)
+    owner_user_id = Field(snowflake)
+
+
+class Application(SlottedModel):
+    id = Field(snowflake)
+    name = Field(text)
+    icon = Field(text)
+    description = Field(text)
+    rpc_origins = ListField(text)
+    bot_public = Field(bool)
+    bot_require_code_grant = Field(bool)
+    owner = Field(User)
+    summary = Field(text)
+    verify_key = Field(text)
+    team = Field(Team)
+    guild_id = Field(snowflake)
+    primary_sku_id = Field(snowflake)
+    slug = Field(text)
+    cover_image = Field(text)
+
+    def user_is_owner(self, user):
+        user_id = to_snowflake(user)
+        if user_id == self.owner.id:
+            return True
+
+        return any(user_id == member.user.id for member in self.team.members)
+
+    def get_icon_url(self, fmt='webp', size=1024):
+        if not self.icon:
+            return ''
+
+        return 'https://cdn.discordapp.com/app-icons/{}/{}.{}?size={}'.format(self.id, self.icon, fmt, size)
+
+    def get_cover_image_url(self, fmt='webp', size=1024):
+        if not self.cover_image:
+            return ''
+
+        return 'https://cdn.discordapp.com/app-icons/{}/{}.{}?size={}'.format(self.id, self.cover_image, fmt, size)
+
+    @property
+    def icon_url(self):
+        return self.get_icon_url()
+
+    @property
+    def cover_image_url(self):
+        return self.get_cover_image_url()
+
+
+class ConnectionVisibility(object):
+    NOBODY = 0
+    EVERYONE = 1
+
+
+class Connection(SlottedModel):
+    id = Field(text)
+    name = Field(text)
+    type = Field(text)
+    revoked = Field(bool)
+    integrations = ListField(Integration)
+    verified = Field(bool)
+    friend_sync = Field(bool)
+    show_activity = Field(bool)
+    visibility = Field(enum(ConnectionVisibility))

disco/types/permissions.py

@@ -1,109 +1,47 @@
-from holster.enum import Enum, EnumAttr
-
-Permissions = Enum(
-    CREATE_INSTANT_INVITE=1 << 0,
-    KICK_MEMBERS=1 << 1,
-    BAN_MEMBERS=1 << 2,
-    ADMINISTRATOR=1 << 3,
-    MANAGE_CHANNELS=1 << 4,
-    MANAGE_GUILD=1 << 5,
-    ADD_REACTIONS=1 << 6,
-    VIEW_AUDIT_LOG=1 << 7,
-    PRIORITY_SPEAKER=1 << 8,
-    READ_MESSAGES=1 << 10,
-    SEND_MESSAGES=1 << 11,
-    SEND_TSS_MESSAGES=1 << 12,
-    MANAGE_MESSAGES=1 << 13,
-    EMBED_LINKS=1 << 14,
-    ATTACH_FILES=1 << 15,
-    READ_MESSAGE_HISTORY=1 << 16,
-    MENTION_EVERYONE=1 << 17,
-    USE_EXTERNAL_EMOJIS=1 << 18,
-    CONNECT=1 << 20,
-    SPEAK=1 << 21,
-    MUTE_MEMBERS=1 << 22,
-    DEAFEN_MEMBERS=1 << 23,
-    MOVE_MEMBERS=1 << 24,
-    USE_VAD=1 << 25,
-    CHANGE_NICKNAME=1 << 26,
-    MANAGE_NICKNAMES=1 << 27,
-    MANAGE_ROLES=1 << 28,
-    MANAGE_WEBHOOKS=1 << 29,
-    MANAGE_EMOJIS=1 << 30,
-)
-
-
-class PermissionValue(object):
-    __slots__ = ['value']
-
-    def __init__(self, value=0):
-        if isinstance(value, EnumAttr) or isinstance(value, PermissionValue):
-            value = value.value
-
-        self.value = value
+from disco.types.base import BitsetMap, BitsetValue
+
+
+class Permissions(BitsetMap):
+    CREATE_INSTANT_INVITE = 1 << 0
+    KICK_MEMBERS = 1 << 1
+    BAN_MEMBERS = 1 << 2
+    ADMINISTRATOR = 1 << 3
+    MANAGE_CHANNELS = 1 << 4
+    MANAGE_GUILD = 1 << 5
+    ADD_REACTIONS = 1 << 6
+    VIEW_AUDIT_LOG = 1 << 7
+    PRIORITY_SPEAKER = 1 << 8
+    STREAM = 1 << 9
+    VIEW_CHANNEL = 1 << 10
+    SEND_MESSAGES = 1 << 11
+    SEND_TSS_MESSAGES = 1 << 12
+    MANAGE_MESSAGES = 1 << 13
+    EMBED_LINKS = 1 << 14
+    ATTACH_FILES = 1 << 15
+    READ_MESSAGE_HISTORY = 1 << 16
+    MENTION_EVERYONE = 1 << 17
+    USE_EXTERNAL_EMOJIS = 1 << 18
+    CONNECT = 1 << 20
+    SPEAK = 1 << 21
+    MUTE_MEMBERS = 1 << 22
+    DEAFEN_MEMBERS = 1 << 23
+    MOVE_MEMBERS = 1 << 24
+    USE_VAD = 1 << 25
+    CHANGE_NICKNAME = 1 << 26
+    MANAGE_NICKNAMES = 1 << 27
+    MANAGE_ROLES = 1 << 28
+    MANAGE_WEBHOOKS = 1 << 29
+    MANAGE_EMOJIS = 1 << 30
+
+
+class PermissionValue(BitsetValue):
+    map = Permissions
 
     def can(self, *perms):
         # Administrator permission overwrites all others
         if self.administrator:
             return True
-
-        for perm in perms:
-            if isinstance(perm, EnumAttr):
-                perm = perm.value
-            if not (self.value & perm) == perm:
-                return False
-        return True
-
-    def add(self, other):
-        if isinstance(other, PermissionValue):
-            self.value |= other.value
-        elif isinstance(other, int):
-            self.value |= other
-        elif isinstance(other, EnumAttr):
-            setattr(self, other.name, True)
-        else:
-            raise TypeError('Cannot PermissionValue.add from type {}'.format(type(other)))
-        return self
-
-    def sub(self, other):
-        if isinstance(other, PermissionValue):
-            self.value &= ~other.value
-        elif isinstance(other, int):
-            self.value &= ~other
-        elif isinstance(other, EnumAttr):
-            setattr(self, other.name, False)
-        else:
-            raise TypeError('Cannot PermissionValue.sub from type {}'.format(type(other)))
-        return self
-
-    def __iadd__(self, other):
-        return self.add(other)
-
-    def __isub__(self, other):
-        return self.sub(other)
-
-    def __getattribute__(self, name):
-        if name in Permissions.keys_:
-            return (self.value & Permissions[name].value) == Permissions[name].value
-        else:
-            return object.__getattribute__(self, name)
-
-    def __setattr__(self, name, value):
-        if name not in Permissions.keys_:
-            return super(PermissionValue, self).__setattr__(name, value)
-
-        if value:
-            self.value |= Permissions[name].value
-        else:
-            self.value &= ~Permissions[name].value
-
-    def __int__(self):
-        return self.value
-
-    def to_dict(self):
-        return {
-            k: getattr(self, k) for k in Permissions.keys_
-        }
+        return self.check(*perms)
 
     @classmethod
     def text(cls):

disco/types/user.py

@@ -1,16 +1,21 @@
-from holster.enum import Enum
+from datetime import datetime
 
-from disco.types.base import SlottedModel, Field, snowflake, text, with_equality, with_hash
-
-DefaultAvatars = Enum(
-    BLURPLE=0,
-    GREY=1,
-    GREEN=2,
-    ORANGE=3,
-    RED=4,
+from disco.types.base import (
+    SlottedModel, Field, snowflake, text, with_equality, with_hash, enum, ListField,
+    cached_property,
 )
 
 
+class DefaultAvatars(object):
+    BLURPLE = 0
+    GREY = 1
+    GREEN = 2
+    ORANGE = 3
+    RED = 4
+
+    ALL = [BLURPLE, GREY, GREEN, ORANGE, RED]
+
+
 class User(SlottedModel, with_equality('id'), with_hash('id')):
     id = Field(snowflake)
     username = Field(text)
@@ -22,19 +27,22 @@ class User(SlottedModel, with_equality('id'), with_hash('id')):
 
     presence = Field(None)
 
-    def get_avatar_url(self, fmt=None, size=1024):
+    def get_avatar_url(self, still_format='webp', animated_format='gif', size=1024):
         if not self.avatar:
-            return 'https://cdn.discordapp.com/embed/avatars/{}.png'.format(self.default_avatar.value)
-        if fmt is not None:
-            return 'https://cdn.discordapp.com/avatars/{}/{}.{}?size={}'.format(self.id, self.avatar, fmt, size)
+            return 'https://cdn.discordapp.com/embed/avatars/{}.png'.format(self.default_avatar)
+
         if self.avatar.startswith('a_'):
-            return 'https://cdn.discordapp.com/avatars/{}/{}.gif?size={}'.format(self.id, self.avatar, size)
+            return 'https://cdn.discordapp.com/avatars/{}/{}.{}?size={}'.format(
+                self.id, self.avatar, animated_format, size
+            )
         else:
-            return 'https://cdn.discordapp.com/avatars/{}/{}.webp?size={}'.format(self.id, self.avatar, size)
+            return 'https://cdn.discordapp.com/avatars/{}/{}.{}?size={}'.format(
+                self.id, self.avatar, still_format, size
+            )
 
     @property
     def default_avatar(self):
-        return DefaultAvatars[int(self.discriminator) % len(DefaultAvatars.attrs)]
+        return DefaultAvatars.ALL[int(self.discriminator) % len(DefaultAvatars.ALL)]
 
     @property
     def avatar_url(self):
@@ -58,29 +66,68 @@ class User(SlottedModel, with_equality('id'), with_hash('id')):
         return u'<User {} ({})>'.format(self.id, self)
 
 
-GameType = Enum(
-    DEFAULT=0,
-    STREAMING=1,
-    LISTENING=2,
-    WATCHING=3,
-)
+class GameType(object):
+    DEFAULT = 0
+    STREAMING = 1
+    LISTENING = 2
+    WATCHING = 3
 
-Status = Enum(
-    'ONLINE',
-    'IDLE',
-    'DND',
-    'INVISIBLE',
-    'OFFLINE',
-)
+
+class Status(object):
+    ONLINE = 'ONLINE'
+    IDLE = 'IDLE'
+    DND = 'DND'
+    INVISIBLE = 'INVISIBLE'
+    OFFLINE = 'OFFLINE'
+
+
+class Party(SlottedModel):
+    id = Field(text)
+    size = ListField(int)
+
+
+class Assets(SlottedModel):
+    large_image = Field(text)
+    large_text = Field(text)
+    small_image = Field(text)
+    small_text = Field(text)
+
+
+class Secrets(SlottedModel):
+    join = Field(text)
+    spectate = Field(text)
+    match = Field(text)
+
+
+class Timestamps(SlottedModel):
+    start = Field(int)
+    end = Field(int)
+
+    @cached_property
+    def start_time(self):
+        return datetime.utcfromtimestamp(self.start / 1000)
+
+    @cached_property
+    def end_time(self):
+        return datetime.utcfromtimestamp(self.end / 1000)
 
 
 class Game(SlottedModel):
-    type = Field(GameType)
+    type = Field(enum(GameType))
     name = Field(text)
     url = Field(text)
+    timestamps = Field(Timestamps)
+    application_id = Field(text)
+    details = Field(text)
+    state = Field(text)
+    party = Field(Party)
+    assets = Field(Assets)
+    secrets = Field(Secrets)
+    instance = Field(bool)
+    flags = Field(int)
 
 
 class Presence(SlottedModel):
     user = Field(User, alias='user', ignore_dump=['presence'])
     game = Field(Game)
-    status = Field(Status)
+    status = Field(enum(Status))

disco/types/voice.py

@@ -1,4 +1,4 @@
-from disco.types.base import SlottedModel, Field, snowflake, cached_property
+from disco.types.base import SlottedModel, text, Field, snowflake, cached_property
 
 
 class VoiceState(SlottedModel):
@@ -23,3 +23,18 @@ class VoiceState(SlottedModel):
     @cached_property
     def user(self):
         return self.client.state.users.get(self.user_id)
+
+
+class VoiceRegion(SlottedModel):
+    id = Field(text)
+    name = Field(text)
+    vip = Field(bool)
+    optimal = Field(bool)
+    deprecated = Field(bool)
+    custom = Field(bool)
+
+    def __str__(self):
+        return self.id
+
+    def __repr__(self):
+        return u'<VoiceRegion {}>'.format(self.name)

disco/util/config.py

@@ -10,6 +10,16 @@ class Config(object):
             k: getattr(self, k) for k in dir(self.__class__)
         })
 
+        # issue `DeprecationWarning`s
+        if hasattr(self.__class__, 'deprecated') and obj:
+            for deprecated_key, replacement in self.__class__.deprecated.items():
+                if deprecated_key in obj.keys():
+                    warning_text = '"{0}" is deprecated.'.format(deprecated_key)
+                    warning_text += ('\nReplace "{0}" with "{1}".'.format(deprecated_key, replacement)
+                                     if replacement else '')
+
+                    raise DeprecationWarning(warning_text)
+
         if obj:
             self.__dict__.update(obj)
 

disco/util/emitter.py

@@ -0,0 +1,175 @@
+import gevent
+
+from collections import defaultdict
+from gevent.event import AsyncResult
+from gevent.queue import Queue, Full
+
+
+from disco.util.logging import LoggingClass
+
+
+class Priority(object):
+    # BEFORE is the most dangerous priority level. Every event that flows through
+    #  the given emitter instance will be dispatched _sequentially_ to all BEFORE
+    #  handlers. Until these before handlers complete execution, no other event
+    #  will be allowed to continue. Any exceptions raised will be ignored.
+    BEFORE = 1
+
+    # AFTER has the same behavior as before with regards to dispatching events,
+    #  with the one difference being it executes after all the BEFORE listeners.
+    AFTER = 2
+
+    # SEQUENTIAL guarantees that all events your handler receives will be ordered
+    #  when looked at in isolation. SEQUENTIAL handlers will not block other handlers,
+    #  but do use a queue internally and thus can fall behind.
+    SEQUENTIAL = 3
+
+    # NONE provides no guarantees around the ordering or execution of events, sans
+    #  that BEFORE handlers will always complete before any NONE handlers are called.
+    NONE = 4
+
+    ALL = {BEFORE, AFTER, SEQUENTIAL, NONE}
+
+
+class Event(object):
+    def __init__(self, parent, data):
+        self.parent = parent
+        self.data = data
+
+    def __getattr__(self, name):
+        if hasattr(self.data, name):
+            return getattr(self.data, name)
+        raise AttributeError
+
+
+class EmitterSubscription(object):
+    def __init__(self, events, callback, priority=Priority.NONE, conditional=None, metadata=None, max_queue_size=8096):
+        self.events = events
+        self.callback = callback
+        self.priority = priority
+        self.conditional = conditional
+        self.metadata = metadata or {}
+        self.max_queue_size = max_queue_size
+
+        self._emitter = None
+        self._queue = None
+        self._queue_greenlet = None
+
+        if priority == Priority.SEQUENTIAL:
+            self._queue_greenlet = gevent.spawn(self._queue_handler)
+
+    def __del__(self):
+        if self._emitter:
+            self.detach()
+
+        if self._queue_greenlet:
+            self._queue_greenlet.kill()
+
+    def __call__(self, *args, **kwargs):
+        if self._queue is not None:
+            try:
+                self._queue.put_nowait((args, kwargs))
+            except Full:
+                # TODO: warning
+                pass
+            return
+
+        if callable(self.conditional):
+            if not self.conditional(*args, **kwargs):
+                return
+        return self.callback(*args, **kwargs)
+
+    def _queue_handler(self):
+        self._queue = Queue(self.max_queue_size)
+
+        while True:
+            args, kwargs = self._queue.get()
+            try:
+                self.callback(*args, **kwargs)
+            except Exception:
+                # TODO: warning
+                pass
+
+    def attach(self, emitter):
+        self._emitter = emitter
+
+        for event in self.events:
+            self._emitter.event_handlers[self.priority][event].append(self)
+
+        return self
+
+    def detach(self, emitter=None):
+        emitter = emitter or self._emitter
+
+        for event in self.events:
+            if self in emitter.event_handlers[self.priority][event]:
+                emitter.event_handlers[self.priority][event].remove(self)
+
+    def remove(self, emitter=None):
+        self.detach(emitter)
+
+
+class Emitter(LoggingClass):
+    def __init__(self):
+        self.event_handlers = {
+            k: defaultdict(list) for k in Priority.ALL
+        }
+
+    def emit(self, name, *args, **kwargs):
+        # First execute all BEFORE handlers sequentially
+        for listener in self.event_handlers[Priority.BEFORE].get(name, []):
+            try:
+                listener(*args, **kwargs)
+            except Exception as e:
+                self.log.warning('BEFORE {} event handler `{}` raised {}: {}'.format(
+                    name,
+                    listener.callback.__name__,
+                    e.__class__.__name__,
+                    e,
+                ))
+
+        # Next execute all AFTER handlers sequentially
+        for listener in self.event_handlers[Priority.AFTER].get(name, []):
+            try:
+                listener(*args, **kwargs)
+            except Exception as e:
+                self.log.warning('AFTER {} event handler `{}` raised {}: {}'.format(
+                    name,
+                    listener.callback.__name__,
+                    e.__class__.__name__,
+                    e,
+                ))
+
+        # Next enqueue all sequential handlers. This just puts stuff into a queue
+        #  without blocking, so we don't have to worry too much
+        for listener in self.event_handlers[Priority.SEQUENTIAL].get(name, []):
+            listener(*args, **kwargs)
+
+        # Finally just spawn for everything else
+        for listener in self.event_handlers[Priority.NONE].get(name, []):
+            gevent.spawn(listener, *args, **kwargs)
+
+    def on(self, *args, **kwargs):
+        return EmitterSubscription(args[:-1], args[-1], **kwargs).attach(self)
+
+    def once(self, *args, **kwargs):
+        result = AsyncResult()
+        li = None
+
+        def _f(e):
+            result.set(e)
+            li.detach()
+
+        li = self.on(*args + (_f, ))
+
+        return result.wait(kwargs.pop('timeout', None))
+
+    def wait(self, *args, **kwargs):
+        result = AsyncResult()
+        match = args[-1]
+
+        def _f(e):
+            if match(e):
+                result.set(e)
+
+        return result.wait(kwargs.pop('timeout', None))

disco/util/enum.py

@@ -0,0 +1,20 @@
+import six
+
+
+def get_enum_members(enum):
+    for k, v in six.iteritems(enum.__dict__):
+        if not isinstance(k, six.string_types):
+            continue
+
+        if k.startswith('_') or not k.isupper():
+            continue
+
+        yield k, v
+
+
+def get_enum_value_by_name(enum, name):
+    name = name.lower()
+
+    for k, v in get_enum_members(enum):
+        if k.lower() == name:
+            return v

disco/util/functional.py

@@ -1,4 +1,4 @@
-from six.moves import range
+import six
 
 NO_MORE_SENTINEL = object()
 
@@ -7,14 +7,14 @@ def take(seq, count):
     """
     Take count many elements from a sequence or generator.
 
-    Args
-    ----
+    Parameters
+    ----------
     seq : sequence or generator
         The sequence to take elements from.
     count : int
         The number of elements to take.
     """
-    for _ in range(count):
+    for _ in six.moves.range(count):
         i = next(seq, NO_MORE_SENTINEL)
         if i is NO_MORE_SENTINEL:
             return
@@ -25,14 +25,14 @@ def chunks(obj, size):
     """
     Splits a list into sized chunks.
 
-    Args
-    ----
+    Parameters
+    ----------
     obj : list
         List to split up.
     size : int
         Size of chunks to split list into.
     """
-    for i in range(0, len(obj), size):
+    for i in six.moves.range(0, len(obj), size):
         yield obj[i:i + size]
 
 
@@ -66,3 +66,12 @@ def simple_cached_property(method):
         delattr(inst, key)
 
     return property(_getattr, _setattr, _delattr)
+
+
+def optional(**kwargs):
+    """
+    Takes a set of keyword arguments, creating a dictionary with only the non-
+    null values.
+    :returns: dict
+    """
+    return {k: v for k, v in six.iteritems(kwargs) if v is not None}

disco/util/logging.py

@@ -21,7 +21,7 @@ def setup_logging(**kwargs):
     # Pass through our basic configuration
     logging.basicConfig(**kwargs)
 
-    # Override some noisey loggers
+    # Override some noisy loggers
     for logger, level in LEVEL_OVERRIDES.items():
         logging.getLogger(logger).setLevel(level)
 

disco/util/snowflake.py

@@ -41,7 +41,7 @@ def to_snowflake(i):
     elif hasattr(i, 'id'):
         return i.id
 
-    raise Exception('{} ({}) is not convertable to a snowflake'.format(type(i), i))
+    raise Exception('{} ({}) is not convertible to a snowflake'.format(type(i), i))
 
 
 def calculate_shard(shard_count, guild_id):

disco/util/threadlocal.py

@@ -0,0 +1,27 @@
+import gevent
+import weakref
+
+
+class ThreadLocal(object):
+    ___slots__ = ['storage']
+
+    def __init__(self):
+        self.storage = weakref.WeakKeyDictionary()
+
+    def get(self):
+        if gevent.getcurrent() not in self.storage:
+            self.storage[gevent.getcurrent()] = {}
+        return self.storage[gevent.getcurrent()]
+
+    def drop(self):
+        if gevent.getcurrent() in self.storage:
+            del self.storage[gevent.getcurrent()]
+
+    def __contains__(self, key):
+        return key in self.get()
+
+    def __getitem__(self, item):
+        return self.get()[item]
+
+    def __setitem__(self, item, value):
+        self.get()[item] = value

disco/util/websocket.py

@@ -3,8 +3,7 @@ from __future__ import absolute_import
 import websocket
 import six
 
-from holster.emitter import Emitter
-
+from disco.util.emitter import Emitter
 from disco.util.logging import LoggingClass
 
 

disco/voice.py

@@ -0,0 +1,176 @@
+import os
+import json
+
+import gevent
+from gevent.os import make_nonblocking, nb_read
+
+from disco.gateway.packets import OPCode
+from disco.types.channel import Channel
+from disco.util.emitter import Emitter
+from telecom import TelecomConnection, AvConvPlayable
+
+try:
+    import youtube_dl
+    ytdl = youtube_dl.YoutubeDL()
+except ImportError:
+    ytdl = None
+
+
+class YoutubeDLPlayable(AvConvPlayable):
+    def __init__(self, url):
+        url = next(self.from_url(url), None)
+        if not url:
+            raise Exception('No result found for URL {}'.format(url))
+        super(YoutubeDLPlayable, self).__init__(url)
+
+    @classmethod
+    def from_url(cls, url):
+        assert ytdl is not None, 'YoutubeDL isn\'t installed'
+
+        results = ytdl.extract_info(url, download=False)
+        if 'entries' not in results:
+            results = [results]
+        else:
+            results = results['entries']
+
+        for result in results:
+            audio_formats = [fmt for fmt in result['formats'] if fmt['vcodec'] == 'none' and fmt['acodec'] == 'opus']
+            if not audio_formats:
+                raise Exception("Couldn't find valid audio format for {}".format(url))
+
+            best_audio_format = sorted(audio_formats, key=lambda i: i['abr'], reverse=True)[0]
+            yield AvConvPlayable(best_audio_format['url'])
+
+
+class VoiceConnection(object):
+    def __init__(self, client, guild_id, enable_events=False):
+        self.client = client
+        self.guild_id = guild_id
+        self.channel_id = None
+        self.enable_events = enable_events
+        self._conn = None
+        self._voice_server_update_listener = self.client.events.on(
+            'VoiceServerUpdate',
+            self._on_voice_server_update,
+        )
+        self._event_reader_greenlet = None
+
+        self.events = None
+        if self.enable_events:
+            self.events = Emitter()
+
+        self._mute = False
+        self._deaf = False
+
+    def __del__(self):
+        if self._event_reader_greenlet:
+            self._event_reader_greenlet.kill()
+
+    @property
+    def mute(self):
+        return self._mute
+
+    @property
+    def deaf(self):
+        return self._deaf
+
+    @mute.setter
+    def mute(self, value):
+        if value is self._mute:
+            return
+
+        self._mute = value
+        self._send_voice_state_update()
+
+    @deaf.setter
+    def deaf(self, value):
+        if value is self._deaf:
+            return
+
+        self._deaf = value
+        self._send_voice_state_update()
+
+    @classmethod
+    def from_channel(self, channel, **kwargs):
+        assert channel.is_voice, 'Cannot connect to a non voice channel'
+        conn = VoiceConnection(channel.client, channel.guild_id, **kwargs)
+        conn.connect(channel.id)
+        return conn
+
+    def set_channel(self, channel_or_id):
+        if channel_or_id and isinstance(channel_or_id, Channel):
+            channel_or_id = channel_or_id.id
+
+        self.channel_id = channel_or_id
+        self._send_voice_state_update()
+
+    def connect(self, channel_id):
+        assert self._conn is None, 'Already connected'
+
+        self.set_channel(channel_id)
+
+        self._conn = TelecomConnection(
+            self.client.state.me.id,
+            self.guild_id,
+            self.client.gw.session_id,
+        )
+
+        if self.enable_events:
+            r, w = os.pipe()
+
+            self._event_reader_greenlet = gevent.spawn(self._event_reader, r)
+            self._conn.set_event_pipe(w)
+
+    def disconnect(self):
+        assert self._conn is not None, 'Not connected'
+
+        # Send disconnection
+        self.set_channel(None)
+
+        # If we have an event reader, kill it
+        if self._event_reader_greenlet:
+            self._event_reader_greenlet.kill()
+            self._event_reader_greenlet = None
+
+        # Delete our connection so it will get GC'd
+        del self._conn
+        self._conn = None
+
+    def play(self, playable):
+        self._conn.play(playable)
+
+    def play_file(self, url):
+        self._conn.play(AvConvPlayable(url))
+
+    def _on_voice_server_update(self, event):
+        if not self._conn or event.guild_id != self.guild_id:
+            return
+
+        self._conn.update_server_info(event.endpoint, event.token)
+
+    def _send_voice_state_update(self):
+        self.client.gw.send(OPCode.VOICE_STATE_UPDATE, {
+            'self_mute': self._mute,
+            'self_deaf': self._deaf,
+            'self_video': False,
+            'guild_id': self.guild_id,
+            'channel_id': self.channel_id,
+        })
+
+    def _event_reader(self, fd):
+        if not make_nonblocking(fd):
+            raise Exception('failed to make event pipe non-blocking')
+
+        buff = ""
+        while True:
+            buff += nb_read(fd, 2048).decode('utf-8')
+
+            parts = buff.split('\n')
+            for message in parts[:-1]:
+                event = json.loads(message)
+                self.events.emit(event['e'], event['d'])
+
+            if len(parts) > 1:
+                buff = parts[-1]
+            else:
+                buff = ""

disco/voice/__init__.py

@@ -1,5 +0,0 @@
-from disco.voice.client import *  # noqa: F401,F403
-from disco.voice.player import *  # noqa: F401,F403
-from disco.voice.playable import *  # noqa: F401,F403
-
-# TODO: deprecate this file

disco/voice/client.py

@@ -1,459 +0,0 @@
-from __future__ import print_function
-
-import gevent
-import time
-
-from collections import namedtuple
-
-from holster.enum import Enum
-from holster.emitter import Emitter
-
-from disco.gateway.encoding.json import JSONEncoder
-from disco.util.websocket import Websocket
-from disco.util.logging import LoggingClass
-from disco.gateway.packets import OPCode
-from disco.types.base import cached_property
-from disco.voice.packets import VoiceOPCode
-from disco.voice.udp import AudioCodecs, RTPPayloadTypes, UDPVoiceClient
-
-SpeakingFlags = Enum(
-    NONE=0,
-    VOICE=1 << 0,
-    SOUNDSHARE=1 << 1,
-    PRIORITY=1 << 2,
-)
-
-VoiceState = Enum(
-    DISCONNECTED=0,
-    RECONNECTING=1,
-    AWAITING_ENDPOINT=2,
-    AUTHENTICATING=3,
-    AUTHENTICATED=4,
-    CONNECTING=5,
-    CONNECTED=6,
-    VOICE_CONNECTING=7,
-    VOICE_CONNECTED=8,
-)
-
-VoiceSpeaking = namedtuple('VoiceSpeaking', [
-    'client',
-    'user_id',
-    'speaking',
-    'soundshare',
-    'priority',
-])
-
-
-class VoiceException(Exception):
-    def __init__(self, msg, client):
-        self.voice_client = client
-        super(VoiceException, self).__init__(msg)
-
-
-class VoiceClient(LoggingClass):
-    VOICE_GATEWAY_VERSION = 4
-
-    SUPPORTED_MODES = {
-        'xsalsa20_poly1305_lite',
-        'xsalsa20_poly1305_suffix',
-        'xsalsa20_poly1305',
-    }
-
-    def __init__(self, client, server_id, is_dm=False, encoder=None, max_reconnects=5):
-        super(VoiceClient, self).__init__()
-
-        self.client = client
-        self.server_id = server_id
-        self.channel_id = None
-        self.is_dm = is_dm
-        self.encoder = encoder or JSONEncoder
-        self.max_reconnects = max_reconnects
-        self.video_enabled = False
-
-        # Set the VoiceClient in the state's voice clients
-        self.client.state.voice_clients[self.server_id] = self
-
-        # Bind to some WS packets
-        self.packets = Emitter()
-        self.packets.on(VoiceOPCode.HELLO, self.on_voice_hello)
-        self.packets.on(VoiceOPCode.READY, self.on_voice_ready)
-        self.packets.on(VoiceOPCode.RESUMED, self.on_voice_resumed)
-        self.packets.on(VoiceOPCode.SESSION_DESCRIPTION, self.on_voice_sdp)
-        self.packets.on(VoiceOPCode.SPEAKING, self.on_voice_speaking)
-        self.packets.on(VoiceOPCode.CLIENT_CONNECT, self.on_voice_client_connect)
-        self.packets.on(VoiceOPCode.CLIENT_DISCONNECT, self.on_voice_client_disconnect)
-        self.packets.on(VoiceOPCode.CODECS, self.on_voice_codecs)
-
-        # State + state change emitter
-        self.state = VoiceState.DISCONNECTED
-        self.state_emitter = Emitter()
-
-        # Connection metadata
-        self.token = None
-        self.endpoint = None
-        self.ssrc = None
-        self.ip = None
-        self.port = None
-        self.mode = None
-        self.udp = None
-        self.audio_codec = None
-        self.video_codec = None
-        self.transport_id = None
-
-        # Websocket connection
-        self.ws = None
-
-        self._session_id = self.client.gw.session_id
-        self._reconnects = 0
-        self._heartbeat_task = None
-        self._identified = False
-
-        # SSRCs
-        self.audio_ssrcs = {}
-
-    def __repr__(self):
-        return u'<VoiceClient {}>'.format(self.server_id)
-
-    @cached_property
-    def guild(self):
-        return self.client.state.guilds.get(self.server_id) if not self.is_dm else None
-
-    @cached_property
-    def channel(self):
-        return self.client.state.channels.get(self.channel_id)
-
-    @property
-    def user_id(self):
-        return self.client.state.me.id
-
-    @property
-    def ssrc_audio(self):
-        return self.ssrc
-
-    @property
-    def ssrc_video(self):
-        return self.ssrc + 1
-
-    @property
-    def ssrc_rtx(self):
-        return self.ssrc + 2
-
-    @property
-    def ssrc_rtcp(self):
-        return self.ssrc + 3
-
-    def set_state(self, state):
-        self.log.debug('[%s] state %s -> %s', self, self.state, state)
-        prev_state = self.state
-        self.state = state
-        self.state_emitter.emit(state, prev_state)
-
-    def set_endpoint(self, endpoint):
-        endpoint = endpoint.split(':', 1)[0]
-        if self.endpoint == endpoint:
-            return
-
-        self.log.info(
-            '[%s] Set endpoint from VOICE_SERVER_UPDATE (state = %s / endpoint = %s)', self, self.state, endpoint)
-
-        self.endpoint = endpoint
-
-        if self.ws and self.ws.sock and self.ws.sock.connected:
-            self.ws.close()
-            self.ws = None
-
-        self._identified = False
-
-    def set_token(self, token):
-        if self.token == token:
-            return
-        self.token = token
-        if not self._identified:
-            self._connect_and_run()
-
-    def _connect_and_run(self):
-        self.ws = Websocket('wss://' + self.endpoint + '/?v={}'.format(self.VOICE_GATEWAY_VERSION))
-        self.ws.emitter.on('on_open', self.on_open)
-        self.ws.emitter.on('on_error', self.on_error)
-        self.ws.emitter.on('on_close', self.on_close)
-        self.ws.emitter.on('on_message', self.on_message)
-        self.ws.run_forever()
-
-    def _heartbeat(self, interval):
-        while True:
-            self.send(VoiceOPCode.HEARTBEAT, time.time())
-            gevent.sleep(interval / 1000)
-
-    def set_speaking(self, voice=False, soundshare=False, priority=False, delay=0):
-        value = SpeakingFlags.NONE.value
-        if voice:
-            value |= SpeakingFlags.VOICE.value
-        if soundshare:
-            value |= SpeakingFlags.SOUNDSHARE.value
-        if priority:
-            value |= SpeakingFlags.PRIORITY.value
-
-        self.send(VoiceOPCode.SPEAKING, {
-            'speaking': value,
-            'delay': delay,
-            'ssrc': self.ssrc,
-        })
-
-    def set_voice_state(self, channel_id, mute=False, deaf=False, video=False):
-        self.client.gw.send(OPCode.VOICE_STATE_UPDATE, {
-            'self_mute': bool(mute),
-            'self_deaf': bool(deaf),
-            'self_video': bool(video),
-            'guild_id': None if self.is_dm else self.server_id,
-            'channel_id': channel_id,
-        })
-
-    def send(self, op, data):
-        if self.ws and self.ws.sock and self.ws.sock.connected:
-            self.log.debug('[%s] sending OP %s (data = %s)', self, op, data)
-            self.ws.send(self.encoder.encode({
-                'op': op.value,
-                'd': data,
-            }), self.encoder.OPCODE)
-        else:
-            self.log.debug('[%s] dropping because ws is closed OP %s (data = %s)', self, op, data)
-
-    def on_voice_client_connect(self, data):
-        user_id = int(data['user_id'])
-
-        self.audio_ssrcs[data['audio_ssrc']] = user_id
-        # ignore data['voice_ssrc'] for now
-
-    def on_voice_client_disconnect(self, data):
-        user_id = int(data['user_id'])
-
-        for ssrc in self.audio_ssrcs.keys():
-            if self.audio_ssrcs[ssrc] == user_id:
-                del self.audio_ssrcs[ssrc]
-                break
-
-    def on_voice_codecs(self, data):
-        self.audio_codec = data['audio_codec']
-        self.video_codec = data['video_codec']
-        self.transport_id = data['media_session_id']
-
-        # Set the UDP's RTP Audio Header's Payload Type
-        self.udp.set_audio_codec(data['audio_codec'])
-
-    def on_voice_hello(self, data):
-        self.log.info('[%s] Received Voice HELLO payload, starting heartbeater', self)
-        self._heartbeat_task = gevent.spawn(self._heartbeat, data['heartbeat_interval'])
-        self.set_state(VoiceState.AUTHENTICATED)
-
-    def on_voice_ready(self, data):
-        self.log.info('[%s] Received Voice READY payload, attempting to negotiate voice connection w/ remote', self)
-        self.set_state(VoiceState.CONNECTING)
-        self.ssrc = data['ssrc']
-        self.ip = data['ip']
-        self.port = data['port']
-        self._identified = True
-
-        for mode in self.SUPPORTED_MODES:
-            if mode in data['modes']:
-                self.mode = mode
-                self.log.debug('[%s] Selected mode %s', self, mode)
-                break
-        else:
-            raise Exception('Failed to find a supported voice mode')
-
-        self.log.debug('[%s] Attempting IP discovery over UDP to %s:%s', self, self.ip, self.port)
-        self.udp = UDPVoiceClient(self)
-        ip, port = self.udp.connect(self.ip, self.port)
-
-        if not ip:
-            self.log.error('Failed to discover our IP, perhaps a NAT or firewall is fucking us')
-            self.disconnect()
-            return
-
-        codecs = []
-
-        # Sending discord our available codecs and rtp payload type for it
-        for idx, codec in enumerate(AudioCodecs):
-            codecs.append({
-                'name': codec,
-                'type': 'audio',
-                'priority': (idx + 1) * 1000,
-                'payload_type': RTPPayloadTypes.get(codec).value,
-            })
-
-        self.log.debug('[%s] IP discovery completed (ip = %s, port = %s), sending SELECT_PROTOCOL', self, ip, port)
-        self.send(VoiceOPCode.SELECT_PROTOCOL, {
-            'protocol': 'udp',
-            'data': {
-                'port': port,
-                'address': ip,
-                'mode': self.mode,
-            },
-            'codecs': codecs,
-        })
-        self.send(VoiceOPCode.CLIENT_CONNECT, {
-            'audio_ssrc': self.ssrc,
-            'video_ssrc': 0,
-            'rtx_ssrc': 0,
-        })
-
-    def on_voice_resumed(self, data):
-        self.log.info('[%s] Received resumed', self)
-        self.set_state(VoiceState.CONNECTED)
-
-    def on_voice_sdp(self, sdp):
-        self.log.info('[%s] Received session description, connection completed', self)
-
-        self.mode = sdp['mode']
-        self.audio_codec = sdp['audio_codec']
-        self.video_codec = sdp['video_codec']
-        self.transport_id = sdp['media_session_id']
-
-        # Set the UDP's RTP Audio Header's Payload Type
-        self.udp.set_audio_codec(sdp['audio_codec'])
-
-        # Create a secret box for encryption/decryption
-        self.udp.setup_encryption(bytes(bytearray(sdp['secret_key'])))
-
-        self.set_state(VoiceState.CONNECTED)
-
-    def on_voice_speaking(self, data):
-        user_id = int(data['user_id'])
-
-        self.audio_ssrcs[data['ssrc']] = user_id
-
-        # Maybe rename speaking to voice in future
-        payload = VoiceSpeaking(
-            client=self,
-            user_id=user_id,
-            speaking=bool(data['speaking'] & SpeakingFlags.VOICE.value),
-            soundshare=bool(data['speaking'] & SpeakingFlags.SOUNDSHARE.value),
-            priority=bool(data['speaking'] & SpeakingFlags.PRIORITY.value),
-        )
-
-        self.client.gw.events.emit('VoiceSpeaking', payload)
-
-    def on_message(self, msg):
-        try:
-            data = self.encoder.decode(msg)
-            self.packets.emit(VoiceOPCode[data['op']], data['d'])
-        except Exception:
-            self.log.exception('Failed to parse voice gateway message: ')
-
-    def on_error(self, err):
-        self.log.error('[%s] Voice websocket error: %s', self, err)
-
-    def on_open(self):
-        if self._identified:
-            self.send(VoiceOPCode.RESUME, {
-                'server_id': self.server_id,
-                'session_id': self._session_id,
-                'token': self.token,
-            })
-        else:
-            self.send(VoiceOPCode.IDENTIFY, {
-                'server_id': self.server_id,
-                'user_id': self.user_id,
-                'session_id': self._session_id,
-                'token': self.token,
-                'video': self.video_enabled,
-            })
-
-    def on_close(self, code, reason):
-        self.log.warning('[%s] Voice websocket closed: [%s] %s (%s)', self, code, reason, self._reconnects)
-
-        if self._heartbeat_task:
-            self._heartbeat_task.kill()
-            self._heartbeat_task = None
-
-        self.ws = None
-
-        # If we killed the connection, don't try resuming
-        if self.state == VoiceState.DISCONNECTED:
-            return
-
-        self.log.info('[%s] Attempting Websocket Resumption', self)
-
-        self.set_state(VoiceState.RECONNECTING)
-
-        # Check if code is not None, was not from us
-        if code is not None:
-            self._reconnects += 1
-
-            if self.max_reconnects and self._reconnects > self.max_reconnects:
-                raise VoiceException(
-                    'Failed to reconnect after {} attempts, giving up'.format(self.max_reconnects), self)
-
-            # Don't resume for these error codes:
-            if 4000 <= code <= 4016:
-                self._identified = False
-
-                if self.udp and self.udp.connected:
-                    self.udp.disconnect()
-
-            wait_time = 5
-        else:
-            wait_time = 1
-
-        self.log.info(
-            '[%s] Will attempt to %s after %s seconds', self, 'resume' if self._identified else 'reconnect', wait_time)
-        gevent.sleep(wait_time)
-
-        self._connect_and_run()
-
-    def connect(self, channel_id, timeout=10, **kwargs):
-        if self.is_dm:
-            channel_id = self.server_id
-
-        if not channel_id:
-            raise VoiceException('[{}] cannot connect to an empty channel id'.format(self))
-
-        if self.channel_id == channel_id:
-            if self.state == VoiceState.CONNECTED:
-                self.log.debug('[%s] Already connected to %s, returning', self, self.channel)
-                return self
-        else:
-            if self.state == VoiceState.CONNECTED:
-                self.log.debug('[%s] Moving to channel %s', self, channel_id)
-            else:
-                self.log.debug('[%s] Attempting connection to channel id %s', self, channel_id)
-                self.set_state(VoiceState.AWAITING_ENDPOINT)
-
-        self.set_voice_state(channel_id, **kwargs)
-
-        if not self.state_emitter.once(VoiceState.CONNECTED, timeout=timeout):
-            self.disconnect()
-            raise VoiceException('Failed to connect to voice', self)
-        else:
-            return self
-
-    def disconnect(self):
-        if self.state == VoiceState.DISCONNECTED:
-            return
-
-        self.log.debug('[%s] disconnect called', self)
-        self.set_state(VoiceState.DISCONNECTED)
-
-        del self.client.state.voice_clients[self.server_id]
-
-        if self._heartbeat_task:
-            self._heartbeat_task.kill()
-            self._heartbeat_task = None
-
-        if self.ws and self.ws.sock and self.ws.sock.connected:
-            self.ws.close()
-            self.ws = None
-
-        if self.udp and self.udp.connected:
-            self.udp.disconnect()
-
-        if self.channel_id:
-            self.set_voice_state(None)
-
-        self.client.gw.events.emit('VoiceDisconnect', self)
-
-    def send_frame(self, *args, **kwargs):
-        self.udp.send_frame(*args, **kwargs)
-
-    def increment_timestamp(self, *args, **kwargs):
-        self.udp.increment_timestamp(*args, **kwargs)

disco/voice/opus.py

@@ -1,152 +0,0 @@
-import six
-import sys
-import array
-import ctypes
-import ctypes.util
-
-from holster.enum import Enum
-
-from disco.util.logging import LoggingClass
-
-
-c_int_ptr = ctypes.POINTER(ctypes.c_int)
-c_int16_ptr = ctypes.POINTER(ctypes.c_int16)
-c_float_ptr = ctypes.POINTER(ctypes.c_float)
-
-
-class EncoderStruct(ctypes.Structure):
-    pass
-
-
-class DecoderStruct(ctypes.Structure):
-    pass
-
-
-EncoderStructPtr = ctypes.POINTER(EncoderStruct)
-DecoderStructPtr = ctypes.POINTER(DecoderStruct)
-
-
-class BaseOpus(LoggingClass):
-    BASE_EXPORTED = {
-        'opus_strerror': ([ctypes.c_int], ctypes.c_char_p),
-    }
-
-    EXPORTED = {}
-
-    def __init__(self, library_path=None):
-        self.path = library_path or self.find_library()
-        self.lib = ctypes.cdll.LoadLibrary(self.path)
-
-        methods = {}
-        methods.update(self.BASE_EXPORTED)
-        methods.update(self.EXPORTED)
-
-        for name, item in methods.items():
-            func = getattr(self.lib, name)
-
-            if item[0]:
-                func.argtypes = item[0]
-
-            func.restype = item[1]
-
-            setattr(self, name, func)
-
-    @staticmethod
-    def find_library():
-        if sys.platform == 'win32':
-            raise Exception('Cannot auto-load opus on Windows, please specify full library path')
-
-        return ctypes.util.find_library('opus')
-
-
-Application = Enum(
-    AUDIO=2049,
-    VOIP=2048,
-    LOWDELAY=2051,
-)
-
-
-Control = Enum(
-    SET_BITRATE=4002,
-    SET_BANDWIDTH=4008,
-    SET_FEC=4012,
-    SET_PLP=4014,
-)
-
-
-class OpusEncoder(BaseOpus):
-    EXPORTED = {
-        'opus_encoder_get_size': ([ctypes.c_int], ctypes.c_int),
-        'opus_encoder_create': ([ctypes.c_int, ctypes.c_int, ctypes.c_int, c_int_ptr], EncoderStructPtr),
-        'opus_encode': ([EncoderStructPtr, c_int16_ptr, ctypes.c_int, ctypes.c_char_p, ctypes.c_int32], ctypes.c_int32),
-        'opus_encoder_ctl': (None, ctypes.c_int32),
-        'opus_encoder_destroy': ([EncoderStructPtr], None),
-    }
-
-    def __init__(self, sampling_rate, channels, application=Application.AUDIO, library_path=None):
-        super(OpusEncoder, self).__init__(library_path)
-        self.sampling_rate = sampling_rate
-        self.channels = channels
-        self.application = application
-
-        self._inst = None
-
-    @property
-    def inst(self):
-        if not self._inst:
-            self._inst = self.create()
-            self.set_bitrate(128)
-            self.set_fec(True)
-            self.set_expected_packet_loss_percent(0.15)
-        return self._inst
-
-    def set_bitrate(self, kbps):
-        kbps = min(128, max(16, int(kbps)))
-        ret = self.opus_encoder_ctl(self.inst, int(Control.SET_BITRATE), kbps * 1024)
-
-        if ret < 0:
-            raise Exception('Failed to set bitrate to {}: {}'.format(kbps, ret))
-
-    def set_fec(self, value):
-        ret = self.opus_encoder_ctl(self.inst, int(Control.SET_FEC), int(value))
-
-        if ret < 0:
-            raise Exception('Failed to set FEC to {}: {}'.format(value, ret))
-
-    def set_expected_packet_loss_percent(self, perc):
-        ret = self.opus_encoder_ctl(self.inst, int(Control.SET_PLP), min(100, max(0, int(perc * 100))))
-
-        if ret < 0:
-            raise Exception('Failed to set PLP to {}: {}'.format(perc, ret))
-
-    def create(self):
-        ret = ctypes.c_int()
-        result = self.opus_encoder_create(self.sampling_rate, self.channels, self.application.value, ctypes.byref(ret))
-
-        if ret.value != 0:
-            raise Exception('Failed to create opus encoder: {}'.format(ret.value))
-
-        return result
-
-    def __del__(self):
-        if hasattr(self, '_inst') and self._inst:
-            self.opus_encoder_destroy(self._inst)
-            self._inst = None
-
-    def encode(self, pcm, frame_size):
-        max_data_bytes = len(pcm)
-        pcm = ctypes.cast(pcm, c_int16_ptr)
-        data = (ctypes.c_char * max_data_bytes)()
-
-        ret = self.opus_encode(self.inst, pcm, frame_size, data, max_data_bytes)
-        if ret < 0:
-            raise Exception('Failed to encode: {}'.format(ret))
-
-        if six.PY3:
-            return array.array('b', data[:ret]).tobytes()
-        else:
-            return array.array('b', data[:ret]).tostring()
-
-
-class OpusDecoder(BaseOpus):
-    pass

disco/voice/packets.py

@@ -1,17 +0,0 @@
-from holster.enum import Enum
-
-VoiceOPCode = Enum(
-    IDENTIFY=0,
-    SELECT_PROTOCOL=1,
-    READY=2,
-    HEARTBEAT=3,
-    SESSION_DESCRIPTION=4,
-    SPEAKING=5,
-    HEARTBEAT_ACK=6,
-    RESUME=7,
-    HELLO=8,
-    RESUMED=9,
-    CLIENT_CONNECT=12,
-    CLIENT_DISCONNECT=13,
-    CODECS=14,
-)

disco/voice/playable.py

@@ -1,357 +0,0 @@
-import abc
-import six
-import types
-import gevent
-import struct
-import subprocess
-
-from gevent.lock import Semaphore
-from gevent.queue import Queue
-
-from disco.voice.opus import OpusEncoder
-
-
-try:
-    from io import StringIO as BufferedIO
-except ImportError:
-    if six.PY2:
-        from StringIO import StringIO as BufferedIO
-    else:
-        from io import BytesIO as BufferedIO
-
-
-OPUS_HEADER_SIZE = struct.calcsize('<h')
-
-
-class AbstractOpus(object):
-    def __init__(self, sampling_rate=48000, frame_length=20, channels=2):
-        self.sampling_rate = sampling_rate
-        self.frame_length = frame_length
-        self.channels = 2
-        self.sample_size = 2 * self.channels
-        self.samples_per_frame = int(self.sampling_rate / 1000 * self.frame_length)
-        self.frame_size = self.samples_per_frame * self.sample_size
-
-
-class BaseUtil(object):
-    def pipe(self, other, *args, **kwargs):
-        child = other(self, *args, **kwargs)
-        setattr(child, 'metadata', self.metadata)
-        setattr(child, '_parent', self)
-        return child
-
-    @property
-    def metadata(self):
-        return getattr(self, '_metadata', None)
-
-    @metadata.setter
-    def metadata(self, value):
-        self._metadata = value
-
-
-@six.add_metaclass(abc.ABCMeta)
-class BasePlayable(BaseUtil):
-    @abc.abstractmethod
-    def next_frame(self):
-        raise NotImplementedError
-
-
-@six.add_metaclass(abc.ABCMeta)
-class BaseInput(BaseUtil):
-    @abc.abstractmethod
-    def read(self, size):
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def fileobj(self):
-        raise NotImplementedError
-
-
-class OpusFilePlayable(BasePlayable, AbstractOpus):
-    """
-    An input which reads opus data from a file or file-like object.
-    """
-    def __init__(self, fobj, *args, **kwargs):
-        super(OpusFilePlayable, self).__init__(*args, **kwargs)
-        self.fobj = fobj
-        self.done = False
-
-    def next_frame(self):
-        if self.done:
-            return None
-
-        header = self.fobj.read(OPUS_HEADER_SIZE)
-        if len(header) < OPUS_HEADER_SIZE:
-            self.done = True
-            return None
-
-        data_size = struct.unpack('<h', header)[0]
-        data = self.fobj.read(data_size)
-        if len(data) < data_size:
-            self.done = True
-            return None
-
-        return data
-
-
-class FFmpegInput(BaseInput, AbstractOpus):
-    def __init__(self, source='-', command='avconv', streaming=False, **kwargs):
-        super(FFmpegInput, self).__init__(**kwargs)
-        if source:
-            self.source = source
-        self.streaming = streaming
-        self.command = command
-
-        self._buffer = None
-        self._proc = None
-
-    def read(self, sz):
-        if self.streaming:
-            raise TypeError('Cannot read from a streaming FFmpegInput')
-
-        # First read blocks until the subprocess finishes
-        if not self._buffer:
-            data, _ = self.proc.communicate()
-            self._buffer = BufferedIO(data)
-
-        # Subsequent reads can just do dis thang
-        return self._buffer.read(sz)
-
-    def fileobj(self):
-        if self.streaming:
-            return self.proc.stdout
-        else:
-            return self
-
-    @property
-    def proc(self):
-        if not self._proc:
-            if callable(self.source):
-                self.source = self.source(self)
-
-            if isinstance(self.source, (tuple, list)):
-                self.source, self.metadata = self.source
-
-            args = [
-                self.command,
-                '-i', str(self.source),
-                '-f', 's16le',
-                '-ar', str(self.sampling_rate),
-                '-ac', str(self.channels),
-                '-loglevel', 'warning',
-                'pipe:1',
-            ]
-            self._proc = subprocess.Popen(args, stdin=None, stdout=subprocess.PIPE)
-        return self._proc
-
-
-class YoutubeDLInput(FFmpegInput):
-    def __init__(self, url=None, ie_info=None, *args, **kwargs):
-        super(YoutubeDLInput, self).__init__(None, *args, **kwargs)
-        self._url = url
-        self._ie_info = ie_info
-        self._info = None
-        self._info_lock = Semaphore()
-
-    @property
-    def info(self):
-        with self._info_lock:
-            if not self._info:
-                import youtube_dl
-                ydl = youtube_dl.YoutubeDL({'format': 'webm[abr>0]/bestaudio/best'})
-
-                if self._url:
-                    obj = ydl.extract_info(self._url, download=False, process=False)
-                    if 'entries' in obj:
-                        self._ie_info = list(obj['entries'])[0]
-                    else:
-                        self._ie_info = obj
-
-                self._info = ydl.process_ie_result(self._ie_info, download=False)
-            return self._info
-
-    @property
-    def _metadata(self):
-        return self.info
-
-    @classmethod
-    def many(cls, url, *args, **kwargs):
-        import youtube_dl
-
-        ydl = youtube_dl.YoutubeDL({'format': 'webm[abr>0]/bestaudio/best'})
-        info = ydl.extract_info(url, download=False, process=False)
-
-        if 'entries' not in info:
-            yield cls(ie_info=info, *args, **kwargs)
-            return
-
-        for item in info['entries']:
-            yield cls(ie_info=item, *args, **kwargs)
-
-    @property
-    def source(self):
-        return self.info['url']
-
-
-class BufferedOpusEncoderPlayable(BasePlayable, OpusEncoder, AbstractOpus):
-    def __init__(self, source, *args, **kwargs):
-        self.source = source
-        self.frames = Queue(kwargs.pop('queue_size', 4096))
-
-        # Call the AbstractOpus constructor, as we need properties it sets
-        AbstractOpus.__init__(self, *args, **kwargs)
-
-        # Then call the OpusEncoder constructor, which requires some properties
-        #  that AbstractOpus sets up
-        OpusEncoder.__init__(self, self.sampling_rate, self.channels)
-
-        # Spawn the encoder loop
-        gevent.spawn(self._encoder_loop)
-
-    def _encoder_loop(self):
-        while self.source:
-            raw = self.source.read(self.frame_size)
-            if len(raw) < self.frame_size:
-                break
-
-            self.frames.put(self.encode(raw, self.samples_per_frame))
-            gevent.idle()
-        self.source = None
-        self.frames.put(None)
-
-    def next_frame(self):
-        return self.frames.get()
-
-
-class DCADOpusEncoderPlayable(BasePlayable, AbstractOpus, OpusEncoder):
-    def __init__(self, source, *args, **kwargs):
-        self.source = source
-        self.command = kwargs.pop('command', 'dcad')
-        self.on_complete = kwargs.pop('on_complete', None)
-        super(DCADOpusEncoderPlayable, self).__init__(*args, **kwargs)
-
-        self._done = False
-        self._proc = None
-
-    @property
-    def proc(self):
-        if not self._proc:
-            source = obj = self.source.fileobj()
-            if not hasattr(obj, 'fileno'):
-                source = subprocess.PIPE
-
-            self._proc = subprocess.Popen([
-                self.command,
-                '--channels', str(self.channels),
-                '--rate', str(self.sampling_rate),
-                '--size', str(self.samples_per_frame),
-                '--bitrate', '128',
-                '--fec',
-                '--packet-loss-percent', '30',
-                '--input', 'pipe:0',
-                '--output', 'pipe:1',
-            ], stdin=source, stdout=subprocess.PIPE)
-
-            def writer():
-                while True:
-                    data = obj.read(2048)
-                    if len(data) > 0:
-                        self._proc.stdin.write(data)
-                    if len(data) < 2048:
-                        break
-
-            if source == subprocess.PIPE:
-                gevent.spawn(writer)
-        return self._proc
-
-    def next_frame(self):
-        if self._done:
-            return None
-
-        header = self.proc.stdout.read(OPUS_HEADER_SIZE)
-        if len(header) < OPUS_HEADER_SIZE:
-            self._done = True
-            self.on_complete()
-            return
-
-        size = struct.unpack('<h', header)[0]
-
-        data = self.proc.stdout.read(size)
-        if len(data) < size:
-            self._done = True
-            self.on_complete()
-            return
-
-        return data
-
-
-class FileProxyPlayable(BasePlayable, AbstractOpus):
-    def __init__(self, other, output, *args, **kwargs):
-        self.flush = kwargs.pop('flush', False)
-        self.on_complete = kwargs.pop('on_complete', None)
-        super(FileProxyPlayable, self).__init__(*args, **kwargs)
-        self.other = other
-        self.output = output
-
-    def next_frame(self):
-        frame = self.other.next_frame()
-
-        if frame:
-            self.output.write(struct.pack('<h', len(frame)))
-            self.output.write(frame)
-
-            if self.flush:
-                self.output.flush()
-        else:
-            self.output.flush()
-            self.on_complete()
-            self.output.close()
-        return frame
-
-
-class PlaylistPlayable(BasePlayable, AbstractOpus):
-    def __init__(self, items, *args, **kwargs):
-        super(PlaylistPlayable, self).__init__(*args, **kwargs)
-        self.items = items
-        self.now_playing = None
-
-    def _get_next(self):
-        if isinstance(self.items, types.GeneratorType):
-            return next(self.items, None)
-        return self.items.pop()
-
-    def next_frame(self):
-        if not self.items:
-            return
-
-        if not self.now_playing:
-            self.now_playing = self._get_next()
-            if not self.now_playing:
-                return
-
-        frame = self.now_playing.next_frame()
-        if not frame:
-            return self.next_frame()
-
-        return frame
-
-
-class MemoryBufferedPlayable(BasePlayable, AbstractOpus):
-    def __init__(self, other, *args, **kwargs):
-        from gevent.queue import Queue
-
-        super(MemoryBufferedPlayable, self).__init__(*args, **kwargs)
-        self.frames = Queue()
-        self.other = other
-        gevent.spawn(self._buffer)
-
-    def _buffer(self):
-        while True:
-            frame = self.other.next_frame()
-            if not frame:
-                break
-            self.frames.put(frame)
-        self.frames.put(None)
-
-    def next_frame(self):
-        return self.frames.get()

disco/voice/player.py

@@ -1,126 +0,0 @@
-import time
-import gevent
-
-from holster.enum import Enum
-from holster.emitter import Emitter
-
-from disco.voice.client import VoiceState
-from disco.voice.queue import PlayableQueue
-from disco.util.logging import LoggingClass
-
-
-class Player(LoggingClass):
-    Events = Enum(
-        'START_PLAY',
-        'STOP_PLAY',
-        'PAUSE_PLAY',
-        'RESUME_PLAY',
-        'DISCONNECT',
-    )
-
-    def __init__(self, client, queue=None):
-        super(Player, self).__init__()
-        self.client = client
-
-        # Queue contains playable items
-        self.queue = queue or PlayableQueue()
-
-        # Whether we're playing music (true for lifetime)
-        self.playing = True
-
-        # Set to an event when playback is paused
-        self.paused = None
-
-        # Current playing item
-        self.now_playing = None
-
-        # Current play task
-        self.play_task = None
-
-        # Core task
-        self.run_task = gevent.spawn(self.run)
-
-        # Event triggered when playback is complete
-        self.complete = gevent.event.Event()
-
-        # Event emitter for metadata
-        self.events = Emitter()
-
-    def disconnect(self):
-        self.client.disconnect()
-        self.events.emit(self.Events.DISCONNECT)
-
-    def skip(self):
-        self.play_task.kill()
-
-    def pause(self):
-        if self.paused:
-            return
-        self.paused = gevent.event.Event()
-        self.events.emit(self.Events.PAUSE_PLAY)
-
-    def resume(self):
-        if self.paused:
-            self.paused.set()
-            self.paused = None
-            self.events.emit(self.Events.RESUME_PLAY)
-
-    def play(self, item):
-        # Grab the first frame before we start anything else, sometimes playables
-        #  can do some lengthy async tasks here to setup the playable and we
-        #  don't want that lerp the first N frames of the playable into playing
-        #  faster
-        frame = item.next_frame()
-        if frame is None:
-            return
-
-        start = time.time()
-        loops = 0
-
-        while True:
-            loops += 1
-
-            if self.paused:
-                self.client.set_speaking(False)
-                self.paused.wait()
-                gevent.sleep(2)
-                self.client.set_speaking(True)
-                start = time.time()
-                loops = 0
-
-            if self.client.state == VoiceState.DISCONNECTED:
-                return
-
-            if self.client.state != VoiceState.CONNECTED:
-                self.client.state_emitter.once(VoiceState.CONNECTED, timeout=30)
-
-            # Send the voice frame and increment our timestamp
-            self.client.send_frame(frame)
-            self.client.increment_timestamp(item.samples_per_frame)
-
-            frame = item.next_frame()
-            if frame is None:
-                return
-
-            next_time = start + 0.02 * loops
-            delay = max(0, 0.02 + (next_time - time.time()))
-            gevent.sleep(delay)
-
-    def run(self):
-        self.client.set_speaking(True)
-
-        while self.playing:
-            self.now_playing = self.queue.get()
-
-            self.events.emit(self.Events.START_PLAY, self.now_playing)
-            self.play_task = gevent.spawn(self.play, self.now_playing)
-            self.play_task.join()
-            self.events.emit(self.Events.STOP_PLAY, self.now_playing)
-
-            if self.client.state == VoiceState.DISCONNECTED:
-                self.playing = False
-                self.complete.set()
-                return
-
-        self.client.set_speaking(False)
-        self.disconnect()

disco/voice/queue.py

@@ -1,52 +0,0 @@
-import abc
-import six
-import gevent
-import random
-
-
-@six.add_metaclass(abc.ABCMeta)
-class BaseQueue(object):
-    @abc.abstractmethod
-    def get(self):
-        raise NotImplementedError
-
-
-class PlayableQueue(BaseQueue):
-    def __init__(self):
-        self._data = []
-        self._event = gevent.event.Event()
-
-    def append(self, item):
-        self._data.append(item)
-
-        if self._event:
-            self._event.set()
-            self._event = None
-
-    def _get(self):
-        if not len(self._data):
-            if not self._event:
-                self._event = gevent.event.Event()
-            self._event.wait()
-            return self._get()
-        return self._data.pop(0)
-
-    def get(self):
-        return self._get()
-
-    def shuffle(self):
-        random.shuffle(self._data)
-
-    def clear(self):
-        self._data = []
-
-    def __len__(self):
-        return len(self._data)
-
-    def __iter__(self):
-        return self._data.__iter__()
-
-    def __nonzero__(self):
-        return True
-
-    __bool__ = __nonzero__

disco/voice/udp.py

@@ -1,341 +0,0 @@
-import struct
-import socket
-import gevent
-
-from collections import namedtuple
-
-try:
-    import nacl.secret
-except ImportError:
-    print('WARNING: nacl is not installed, voice support is disabled')
-
-from holster.enum import Enum
-
-from disco.util.logging import LoggingClass
-
-AudioCodecs = ('opus',)
-
-RTPPayloadTypes = Enum(OPUS=0x78)
-
-RTCPPayloadTypes = Enum(
-    SENDER_REPORT=200,
-    RECEIVER_REPORT=201,
-    SOURCE_DESCRIPTION=202,
-    BYE=203,
-    APP=204,
-    RTPFB=205,
-    PSFB=206,
-)
-
-MAX_UINT32 = 4294967295
-MAX_SEQUENCE = 65535
-
-RTP_HEADER_VERSION = 0x80  # Only RTP Version is set here (value of 2 << 6)
-RTP_EXTENSION_ONE_BYTE = (0xBE, 0xDE)
-
-RTPHeader = namedtuple('RTPHeader', [
-    'version',
-    'padding',
-    'extension',
-    'csrc_count',
-    'marker',
-    'payload_type',
-    'sequence',
-    'timestamp',
-    'ssrc',
-])
-
-RTCPHeader = namedtuple('RTCPHeader', [
-    'version',
-    'padding',
-    'reception_count',
-    'packet_type',
-    'length',
-    'ssrc',
-])
-
-RTCPData = namedtuple('RTCPData', [
-    'client',
-    'user_id',
-    'payload_type',
-    'header',
-    'data',
-])
-
-VoiceData = namedtuple('VoiceData', [
-    'client',
-    'user_id',
-    'payload_type',
-    'rtp',
-    'nonce',
-    'data',
-])
-
-
-class UDPVoiceClient(LoggingClass):
-    def __init__(self, vc):
-        super(UDPVoiceClient, self).__init__()
-        self.vc = vc
-
-        # The underlying UDP socket
-        self.conn = None
-
-        # Connection information
-        self.ip = None
-        self.port = None
-        self.connected = False
-
-        # Voice information
-        self.sequence = 0
-        self.timestamp = 0
-
-        self._nonce = 0
-        self._run_task = None
-        self._secret_box = None
-
-        # RTP Header
-        self._rtp_audio_header = bytearray(12)
-        self._rtp_audio_header[0] = RTP_HEADER_VERSION
-
-    def set_audio_codec(self, codec):
-        if codec not in AudioCodecs:
-            raise Exception('Unsupported audio codec received, {}'.format(codec))
-
-        ptype = RTPPayloadTypes.get(codec)
-        self._rtp_audio_header[1] = ptype.value
-        self.log.debug('[%s] Set UDP\'s Audio Codec to %s, RTP payload type %s', self.vc, ptype.name, ptype.value)
-
-    def increment_timestamp(self, by):
-        self.timestamp += by
-        if self.timestamp > MAX_UINT32:
-            self.timestamp = 0
-
-    def setup_encryption(self, encryption_key):
-        self._secret_box = nacl.secret.SecretBox(encryption_key)
-
-    def send_frame(self, frame, sequence=None, timestamp=None, incr_timestamp=None):
-        # Convert the frame to a bytearray
-        frame = bytearray(frame)
-
-        # Pack the rtc header into our buffer
-        struct.pack_into('>H', self._rtp_audio_header, 2, sequence or self.sequence)
-        struct.pack_into('>I', self._rtp_audio_header, 4, timestamp or self.timestamp)
-        struct.pack_into('>i', self._rtp_audio_header, 8, self.vc.ssrc_audio)
-
-        if self.vc.mode == 'xsalsa20_poly1305_lite':
-            # Use an incrementing number as a nonce, only first 4 bytes of the nonce is padded on
-            self._nonce += 1
-            if self._nonce > MAX_UINT32:
-                self._nonce = 0
-
-            nonce = bytearray(24)
-            struct.pack_into('>I', nonce, 0, self._nonce)
-            nonce_padding = nonce[:4]
-        elif self.vc.mode == 'xsalsa20_poly1305_suffix':
-            # Generate a nonce
-            nonce = nacl.utils.random(nacl.secret.SecretBox.NONCE_SIZE)
-            nonce_padding = nonce
-        elif self.vc.mode == 'xsalsa20_poly1305':
-            # Nonce is the header
-            nonce = bytearray(24)
-            nonce[:12] = self._rtp_audio_header
-            nonce_padding = None
-        else:
-            raise Exception('The voice mode, {}, isn\'t supported.'.format(self.vc.mode))
-
-        # Encrypt the payload with the nonce
-        payload = self._secret_box.encrypt(bytes(frame), bytes(nonce)).ciphertext
-
-        # Pad the payload with the nonce, if applicable
-        if nonce_padding:
-            payload += nonce_padding
-
-        # Send the header (sans nonce padding) plus the payload
-        self.send(self._rtp_audio_header + payload)
-
-        # Increment our sequence counter
-        self.sequence += 1
-        if self.sequence >= MAX_SEQUENCE:
-            self.sequence = 0
-
-        # Increment our timestamp (if applicable)
-        if incr_timestamp:
-            self.timestamp += incr_timestamp
-
-    def run(self):
-        while True:
-            data, addr = self.conn.recvfrom(4096)
-
-            # Data cannot be less than the bare minimum, just ignore
-            if len(data) <= 12:
-                self.log.debug('[%s] [VoiceData] Received voice data under 13 bytes', self.vc)
-                continue
-
-            first, second = struct.unpack_from('>BB', data)
-
-            payload_type = RTCPPayloadTypes.get(second)
-            if payload_type:
-                length, ssrc = struct.unpack_from('>HI', data, 2)
-
-                rtcp = RTCPHeader(
-                    version=first >> 6,
-                    padding=(first >> 5) & 1,
-                    reception_count=first & 0x1F,
-                    packet_type=second,
-                    length=length,
-                    ssrc=ssrc,
-                )
-
-                if rtcp.ssrc == self.vc.ssrc_rtcp:
-                    user_id = self.vc.user_id
-                else:
-                    rtcp_ssrc = rtcp.ssrc
-                    if rtcp_ssrc:
-                        rtcp_ssrc -= 3
-                    user_id = self.vc.audio_ssrcs.get(rtcp_ssrc, None)
-
-                payload = RTCPData(
-                    client=self.vc,
-                    user_id=user_id,
-                    payload_type=payload_type.name,
-                    header=rtcp,
-                    data=data[8:],
-                )
-
-                self.vc.client.gw.events.emit('RTCPData', payload)
-            else:
-                sequence, timestamp, ssrc = struct.unpack_from('>HII', data, 2)
-
-                rtp = RTPHeader(
-                    version=first >> 6,
-                    padding=(first >> 5) & 1,
-                    extension=(first >> 4) & 1,
-                    csrc_count=first & 0x0F,
-                    marker=second >> 7,
-                    payload_type=second & 0x7F,
-                    sequence=sequence,
-                    timestamp=timestamp,
-                    ssrc=ssrc,
-                )
-
-                # Check if rtp version is 2
-                if rtp.version != 2:
-                    self.log.debug('[%s] [VoiceData] Received an invalid RTP packet version, %s', self.vc, rtp.version)
-                    continue
-
-                payload_type = RTPPayloadTypes.get(rtp.payload_type)
-
-                # Unsupported payload type received
-                if not payload_type:
-                    self.log.debug('[%s] [VoiceData] Received unsupported payload type, %s', self.vc, rtp.payload_type)
-                    continue
-
-                nonce = bytearray(24)
-                if self.vc.mode == 'xsalsa20_poly1305_lite':
-                    nonce[:4] = data[-4:]
-                    data = data[:-4]
-                elif self.vc.mode == 'xsalsa20_poly1305_suffix':
-                    nonce[:24] = data[-24:]
-                    data = data[:-24]
-                elif self.vc.mode == 'xsalsa20_poly1305':
-                    nonce[:12] = data[:12]
-                else:
-                    self.log.debug('[%s] [VoiceData] Unsupported Encryption Mode, %s', self.vc, self.vc.mode)
-                    continue
-
-                try:
-                    data = self._secret_box.decrypt(bytes(data[12:]), bytes(nonce))
-                except Exception:
-                    self.log.debug('[%s] [VoiceData] Failed to decode data from ssrc %s', self.vc, rtp.ssrc)
-                    continue
-
-                # RFC3550 Section 5.1 (Padding)
-                if rtp.padding:
-                    padding_amount, = struct.unpack_from('>B', data[:-1])
-                    data = data[-padding_amount:]
-
-                if rtp.extension:
-                    # RFC5285 Section 4.2: One-Byte Header
-                    rtp_extension_header = struct.unpack_from('>BB', data)
-                    if rtp_extension_header == RTP_EXTENSION_ONE_BYTE:
-                        data = data[2:]
-
-                        fields_amount, = struct.unpack_from('>H', data)
-                        fields = []
-
-                        offset = 4
-                        for i in range(fields_amount):
-                            first_byte, = struct.unpack_from('>B', data[:offset])
-                            offset += 1
-
-                            rtp_extension_identifer = first_byte & 0xF
-                            rtp_extension_len = ((first_byte >> 4) & 0xF) + 1
-
-                            # Ignore data if identifer == 15, so skip if this is set as 0
-                            if rtp_extension_identifer:
-                                fields.append(data[offset:offset + rtp_extension_len])
-
-                            offset += rtp_extension_len
-
-                            # skip padding
-                            while data[offset] == 0:
-                                offset += 1
-
-                        if len(fields):
-                            fields.append(data[offset:])
-                            data = b''.join(fields)
-                        else:
-                            data = data[offset:]
-
-                # RFC3550 Section 5.3: Profile-Specific Modifications to the RTP Header
-                # clients send it sometimes, definitely on fresh connects to a server, dunno what to do here
-                if rtp.marker:
-                    self.log.debug('[%s] [VoiceData] Received RTP data with the marker set, skipping', self.vc)
-                    continue
-
-                payload = VoiceData(
-                    client=self.vc,
-                    user_id=self.vc.audio_ssrcs.get(rtp.ssrc, None),
-                    payload_type=payload_type.name,
-                    rtp=rtp,
-                    nonce=nonce,
-                    data=data,
-                )
-
-                self.vc.client.gw.events.emit('VoiceData', payload)
-
-    def send(self, data):
-        self.conn.sendto(data, (self.ip, self.port))
-
-    def disconnect(self):
-        self._run_task.kill()
-
-    def connect(self, host, port, timeout=10, addrinfo=None):
-        self.ip = socket.gethostbyname(host)
-        self.port = port
-
-        self.conn = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-
-        if addrinfo:
-            ip, port = addrinfo
-        else:
-            # Send discovery packet
-            packet = bytearray(70)
-            struct.pack_into('>I', packet, 0, self.vc.ssrc)
-            self.send(packet)
-
-            # Wait for a response
-            try:
-                data, addr = gevent.spawn(lambda: self.conn.recvfrom(70)).get(timeout=timeout)
-            except gevent.Timeout:
-                return (None, None)
-
-            # Read IP and port
-            ip = str(data[4:]).split('\x00', 1)[0]
-            port = struct.unpack('<H', data[-2:])[0]
-
-        # Spawn read thread so we don't max buffers
-        self.connected = True
-        self._run_task = gevent.spawn(self.run)
-
-        return (ip, port)

docs/bot_tutorial/building_block_commands.md

@@ -6,7 +6,7 @@ In the case of these examples, when you send `!help` or `!info` the bot will rep
 
 ## Basic commands
 
-Creating commands in Disco is really easy because of the [Plugins](https://b1naryth1ef.github.io/disco/bot_tutorial/building_block_plugins.html) that are a core fundamential of Disco. For more info on them, read back in the [Plugins](https://b1naryth1ef.github.io/disco/bot_tutorial/building_block_plugins.html) section of this tutorial. Creating a basic command is done as follows:
+Creating commands in Disco is really easy because of the [Plugins](https://b1naryth1ef.github.io/disco/bot_tutorial/building_block_plugins.html) that are a core fundamental of Disco. For more info on them, read back in the [Plugins](https://b1naryth1ef.github.io/disco/bot_tutorial/building_block_plugins.html) section of this tutorial. Creating a basic command is done as follows:
 First, create a Plugin class:
 ```py
 class myPlugin(Plugin):
@@ -48,7 +48,7 @@ Here, we added multiple arguments to our command. Namely, number a and number b,
 Lets create a tag system, that can either store a tag if you'd use it like this: `!tag name value` or retrieve a tag if you'd use it like this: `!tag name`
 
 We'll need 2 arguments. A name argument that's required, and an optional value argument. Inside the command we'll check if a `value` is provided. If there is, we'll store the tag. Otherwise, we'll try to retrieve the previously set value for that tag and return it.
-For the sake of this example, we'll asume that the `tags` dict gets stored somewhere so it doesn't get removed after a restart.
+For the sake of this example, we'll assume that the `tags` dict gets stored somewhere so it doesn't get removed after a restart.
 ```py
 tags = {}
 

docs/bot_tutorial/building_block_listeners.md

@@ -12,7 +12,7 @@ def on_message_create(self, event):
     self.log.debug('Got message: %s', event.message)
 ```
 
-Ok, but what if we want to make a listener which welcomes new users to our server? Well thats also easy:
+Ok, but what if we want to make a listener which welcomes new users to our server? Well that's also easy:
 
 ```py
 @Plugin.listen('GuildMemberAdd')
@@ -31,7 +31,7 @@ To see all the events you can subscribe too, checkout the [gateway events list](
 Each listener that's registered comes with a priority. This priority describes how the builtin event emitter will distribute events to your listener. To set a priority you can simply pass the priority kwarg:
 
 ```py
-from holster.emitter import Priority
+from disco.util.emitter import Priority
 
 @Plugin.listen('GuildMemberAdd', priority=Priority.BEFORE)
 def on_guild_member_add(self, event):

docs/bot_tutorial/first_steps.md

@@ -34,6 +34,14 @@ Now let's setup the configuration file. To start off with we'll paste the follow
 }
 ```
 
+{% hint style='tip' %}
+If you want to use a prefix (or even multiple), you add something this into the `"bot"` dictionary:
+```json
+"requires_mentions": false,
+"command_prefixes": ["!", "?"] 
+```
+{% endhint %}
+
 
 Now we're ready to write our plugin. Plugins are used to isolate the functionality of your bot into components. Plugins can be dynamically loaded, unloaded and reloaded at runtime. Lets start off by writing a plugin with a "ping" command;
 

docs/bot_tutorial/message_embeds.md

@@ -46,7 +46,7 @@ embed.set_footer(text='Disco Message Embeds tutorial')
 embed.color = '10038562' #This can be any color, but I chose a nice dark red tint
 ```
 
-Once your embed is finshed, you can send it using the `channel.send_message()` message or the `event.msg.reply()` function.
+Once your embed is finished, you can send it using the `channel.send_message()` message or the `event.msg.reply()` function.
 With `channel.send_message()`:
 ```py
 self.state.channels.get(<ChannelID>).send_message('[optional text]', embed=embed)

examples/music.py

@@ -1,56 +1,32 @@
 from disco.bot import Plugin
-from disco.bot.command import CommandError
-from disco.voice.player import Player
-from disco.voice.playable import YoutubeDLInput, BufferedOpusEncoderPlayable
-from disco.voice.client import VoiceException
+from disco.voice import VoiceConnection, YoutubeDLPlayable
 
 
 class MusicPlugin(Plugin):
-    def load(self, ctx):
-        super(MusicPlugin, self).load(ctx)
-        self.guilds = {}
+    def load(self, data):
+        super(MusicPlugin, self).load(data)
+        self._connections = {}
 
     @Plugin.command('join')
     def on_join(self, event):
-        if event.guild.id in self.guilds:
-            return event.msg.reply("I'm already playing music here.")
-
-        state = event.guild.get_member(event.author).get_voice_state()
-        if not state:
-            return event.msg.reply('You must be connected to voice to use that command.')
-
-        try:
-            client = state.channel.connect()
-        except VoiceException as e:
-            return event.msg.reply('Failed to connect to voice: `{}`'.format(e))
-
-        self.guilds[event.guild.id] = Player(client)
-        self.guilds[event.guild.id].complete.wait()
-        del self.guilds[event.guild.id]
-
-    def get_player(self, guild_id):
-        if guild_id not in self.guilds:
-            raise CommandError("I'm not currently playing music here.")
-        return self.guilds.get(guild_id)
-
-    @Plugin.command('leave')
-    def on_leave(self, event):
-        player = self.get_player(event.guild.id)
-        player.disconnect()
-
-    @Plugin.command('play', '<url:str>')
-    def on_play(self, event, url):
-        item = YoutubeDLInput(url).pipe(BufferedOpusEncoderPlayable)
-        self.get_player(event.guild.id).queue.append(item)
-
-    @Plugin.command('pause')
-    def on_pause(self, event):
-        self.get_player(event.guild.id).pause()
-
-    @Plugin.command('resume')
-    def on_resume(self, event):
-        self.get_player(event.guild.id).resume()
-
-    @Plugin.command('kill')
-    def on_kill(self, event):
-        self.get_player(event.guild.id).client.ws.sock.shutdown()
+        vs = event.guild.get_member(event.author).get_voice_state()
+        if not vs:
+            return event.msg.reply('you are not in a voice channel')
+
+        if event.guild.id in self._connections:
+            if self._connections[event.guild.id].channel_id == vs.channel_id:
+                return event.msg.reply('already in that channel')
+            else:
+                self._connections[event.guild.id].set_channel(vs.channel)
+                return
+
+        self._connections[event.guild.id] = VoiceConnection.from_channel(vs.channel, enable_events=True)
+
+    @Plugin.command('play', '<song:str>')
+    def on_play(self, event, song):
+        if event.guild.id not in self._connections:
+            return event.msg.reply('not in voice here')
+
+        playables = list(YoutubeDLPlayable.from_url(song))
+        for playable in playables:
+            self._connections[event.guild.id].play(playable)

requirements.txt

@@ -1,5 +1,4 @@
 gevent==1.3.7
-holster==2.0.0
 requests==2.20.1
 six==1.11.0
 websocket-client==0.44.0

setup.py

@@ -10,7 +10,7 @@ with open('README.md') as f:
     readme = f.read()
 
 extras_require = {
-    'voice': ['pynacl==1.2.1'],
+    'voice': ['telecom-py==0.0.4'],
     'http': ['flask==0.12.2'],
     'yaml': ['pyyaml==3.12'],
     'music': ['youtube_dl>=2018.1.21'],
@@ -28,7 +28,7 @@ setup(
     author='b1nzy',
     url='https://github.com/b1naryth1ef/disco',
     version=VERSION,
-    packages=find_packages(),
+    packages=find_packages(include=['disco*']),
     license='MIT',
     description='A Python library for Discord',
     long_description=readme,

tests/bot/bot.py

@@ -85,10 +85,19 @@ class TestBot(TestCase):
         msg = Object()
 
         msg.content = '!test a'
-        commands = list(self.bot.get_commands_for_message(False, None, '!', msg))
+        commands = list(self.bot.get_commands_for_message(False, None, ['!'], msg))
         self.assertEqual(commands[0][0], self.bot._commands[1])
         self.assertEqual(commands[1][0], self.bot._commands[0])
 
         msg.content = '!test'
-        commands = list(self.bot.get_commands_for_message(False, None, '!', msg))
+        commands = list(self.bot.get_commands_for_message(False, None, ['!'], msg))
+        self.assertEqual(commands[0][0], self.bot._commands[0])
+
+        msg.content = '?test a'
+        commands = list(self.bot.get_commands_for_message(False, None, ['!', '?', ';'], msg))
+        self.assertEqual(commands[0][0], self.bot._commands[1])
+        self.assertEqual(commands[1][0], self.bot._commands[0])
+
+        msg.content = '?test'
+        commands = list(self.bot.get_commands_for_message(False, None, ['!', '?', ';'], msg))
         self.assertEqual(commands[0][0], self.bot._commands[0])

tests/gateway/events.py

@@ -4,16 +4,13 @@ from disco.gateway.events import GatewayEvent, Resumed
 def create_resumed_payload():
     return GatewayEvent.from_dispatch(None, {
         't': 'RESUMED',
-        'd': {
-            '_trace': ['test', '1', '2', '3'],
-        }
+        'd': {}
     })
 
 
 def test_from_dispatch():
     event = create_resumed_payload()
     assert isinstance(event, Resumed)
-    assert event.trace == ['test', '1', '2', '3']
 
 
 def test_event_creation(benchmark):

tests/imports.py

@@ -34,8 +34,3 @@ from disco.util.logging import *
 from disco.util.serializer import *
 from disco.util.snowflake import *
 from disco.util.websocket import *
-from disco.voice.client import *
-from disco.voice.opus import *
-from disco.voice.packets import *
-from disco.voice.playable import *
-from disco.voice.player import *

tests/state.py

@@ -1,6 +1,6 @@
 from disco.state import State, StateConfig
-from holster.emitter import Emitter
 from disco.gateway.events import VoiceStateUpdate
+from disco.util.emitter import Emitter
 
 
 class MockClient(object):

tests/types/permissions.py

@@ -0,0 +1,42 @@
+from disco.types.permissions import Permissions, PermissionValue
+
+
+def test_permission_value_can():
+    admin_perms = PermissionValue(
+        Permissions.ADMINISTRATOR
+    )
+
+    assert admin_perms.administrator
+
+    # Admin can do everything
+    for key in Permissions.keys():
+        assert admin_perms.can(getattr(Permissions, key))
+
+    manage_channels_perms = PermissionValue(
+        Permissions.MANAGE_CHANNELS,
+    )
+
+    assert not manage_channels_perms.administrator
+    assert manage_channels_perms.manage_channels
+
+
+def test_permission_value_mutation():
+    no_perms = PermissionValue()
+    assert not no_perms.can(Permissions.SEND_MESSAGES)
+
+    no_perms.send_messages = True
+    assert no_perms.can(Permissions.SEND_MESSAGES)
+
+
+def test_permission_value_accepts_permission_value():
+    perms = PermissionValue(Permissions.ADMINISTRATOR)
+
+    new_perms = PermissionValue(perms)
+    assert new_perms.administrator
+
+    assert not new_perms.manage_channels
+    new_perms.add(PermissionValue(Permissions.MANAGE_CHANNELS))
+    assert new_perms.manage_channels
+
+    new_perms.sub(PermissionValue(Permissions.MANAGE_CHANNELS))
+    assert not new_perms.manage_channels

tests/types/types.py

@@ -3,7 +3,6 @@ from __future__ import print_function
 import six
 
 from unittest import TestCase
-from holster.enum import Enum
 from disco.types.base import Model, Field, enum, snowflake, ConversionError
 
 
@@ -64,11 +63,10 @@ class TestModel(TestCase):
         self.assertEqual(obj, {'a': {'d': 'wow'}, 'b': {'z': 'wtf'}, 'g': 'lmao'})
 
     def test_model_field_enum(self):
-        en = Enum(
-            A=1,
-            B=2,
-            C=3
-        )
+        class en(object):
+            A = 1
+            B = 2
+            C = 3
 
         class _M(Model):
             field = Field(enum(en))

tests/types/user.py

@@ -1,22 +1,21 @@
-from unittest import TestCase
-
 from disco.types.user import User, DefaultAvatars
 
 
-class TestChannel(TestCase):
-    def test_user_avatar(self):
-        u = User(
-            id=12345,
-            username='test123',
-            avatar='1234567890abcdefghijkl',
-            discriminator='1234',
-            bot=False)
+def test_user_avatar_url():
+    u = User(id=12345, avatar='1234567890abcdefghijkl')
+    assert u.avatar_url == 'https://cdn.discordapp.com/avatars/12345/1234567890abcdefghijkl.webp?size=1024'
+    avatar_url = u.get_avatar_url(still_format='png')
+    assert avatar_url == 'https://cdn.discordapp.com/avatars/12345/1234567890abcdefghijkl.png?size=1024'
+
+
+def test_user_animated_avatar_url():
+    u = User(id=12345, avatar='a_1234567890abcdefghijkl')
+    assert u.avatar_url == 'https://cdn.discordapp.com/avatars/12345/a_1234567890abcdefghijkl.gif?size=1024'
+    avatar_url = u.get_avatar_url(animated_format='webp')
+    assert avatar_url == 'https://cdn.discordapp.com/avatars/12345/a_1234567890abcdefghijkl.webp?size=1024'
 
-        self.assertEqual(
-            u.avatar_url, 'https://cdn.discordapp.com/avatars/12345/1234567890abcdefghijkl.webp?size=1024'
-        )
 
-    def test_user_default_avatar(self):
-        u = User(id=123456, discriminator='1234')
-        self.assertEqual(u.default_avatar, DefaultAvatars.RED)
-        self.assertEqual(u.avatar_url, 'https://cdn.discordapp.com/embed/avatars/4.png')
+def test_user_default_avatar_url():
+    u = User(id=12345, discriminator='1234')
+    assert u.default_avatar == DefaultAvatars.RED
+    assert u.avatar_url == 'https://cdn.discordapp.com/embed/avatars/4.png'

tests/voice/queue.py

@@ -1,66 +0,0 @@
-import gevent
-from unittest import TestCase
-
-from disco.voice.queue import PlayableQueue
-
-
-class TestPlayableQueue(TestCase):
-    def test_append(self):
-        q = PlayableQueue()
-        q.append(1)
-        q.append(2)
-        q.append(3)
-
-        self.assertEqual(q._data, [1, 2, 3])
-        self.assertEqual(q.get(), 1)
-        self.assertEqual(q.get(), 2)
-        self.assertEqual(q.get(), 3)
-
-    def test_len(self):
-        q = PlayableQueue()
-
-        for idx in range(1234):
-            q.append(idx)
-
-        self.assertEqual(len(q), 1234)
-
-    def test_iter(self):
-        q = PlayableQueue()
-
-        for idx in range(5):
-            q.append(idx)
-
-        self.assertEqual(sum(q), 10)
-
-    def test_blocking_get(self):
-        q = PlayableQueue()
-        result = gevent.event.AsyncResult()
-
-        def get():
-            result.set(q.get())
-
-        gevent.spawn(get)
-        q.append(5)
-        self.assertEqual(result.get(), 5)
-
-    def test_shuffle(self):
-        q = PlayableQueue()
-
-        for idx in range(10000):
-            q.append(idx)
-
-        self.assertEqual(q._data[0], 0)
-        q.shuffle()
-        self.assertNotEqual(q._data[0], 0)
-
-    def test_clear(self):
-        q = PlayableQueue()
-
-        for idx in range(100):
-            q.append(idx)
-
-        self.assertEqual(q._data[0], 0)
-        self.assertEqual(q._data[-1], 99)
-        self.assertEqual(len(q), 100)
-        q.clear()
-        self.assertEqual(len(q), 0)