Rapptz
9 years ago
6 changed files with 811 additions and 25 deletions
@ -0,0 +1,474 @@ |
|||||
|
# -*- coding: utf-8 -*- |
||||
|
|
||||
|
""" |
||||
|
The MIT License (MIT) |
||||
|
|
||||
|
Copyright (c) 2015 Rapptz |
||||
|
|
||||
|
Permission is hereby granted, free of charge, to any person obtaining a |
||||
|
copy of this software and associated documentation files (the "Software"), |
||||
|
to deal in the Software without restriction, including without limitation |
||||
|
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
||||
|
and/or sell copies of the Software, and to permit persons to whom the |
||||
|
Software is furnished to do so, subject to the following conditions: |
||||
|
|
||||
|
The above copyright notice and this permission notice shall be included in |
||||
|
all copies or substantial portions of the Software. |
||||
|
|
||||
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
||||
|
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
||||
|
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
||||
|
DEALINGS IN THE SOFTWARE. |
||||
|
""" |
||||
|
|
||||
|
from . import endpoints |
||||
|
from .user import User |
||||
|
from .channel import Channel, PrivateChannel |
||||
|
from .server import Server |
||||
|
from .message import Message |
||||
|
from .invite import Invite |
||||
|
from .object import Object |
||||
|
from .errors import * |
||||
|
from .state import ConnectionState |
||||
|
from . import utils |
||||
|
|
||||
|
import asyncio |
||||
|
import aiohttp |
||||
|
import websockets |
||||
|
|
||||
|
import logging, traceback |
||||
|
import sys, time, re, json |
||||
|
|
||||
|
log = logging.getLogger(__name__) |
||||
|
request_logging_format = '{method} {response.url} has returned {response.status}' |
||||
|
request_success_log = '{response.url} with {json} received {data}' |
||||
|
|
||||
|
def to_json(obj): |
||||
|
return json.dumps(obj, separators=(',', ':'), ensure_ascii=True) |
||||
|
|
||||
|
class Client: |
||||
|
"""Represents a client connection that connects to Discord. |
||||
|
This class is used to interact with the Discord WebSocket and API. |
||||
|
|
||||
|
A number of options can be passed to the :class:`Client`. |
||||
|
|
||||
|
Parameters |
||||
|
---------- |
||||
|
max_messages : Optional[int] |
||||
|
The maximum number of messages to store in :attr:`messages`. |
||||
|
This defaults to 5000. Passing in `None` or a value of ``<= 0`` |
||||
|
will use the default instead of the passed in value. |
||||
|
loop : Optional[event loop]. |
||||
|
The `event loop`_ to use for asynchronous operations. Defaults to ``None``, |
||||
|
in which case the default event loop is used via ``asyncio.get_event_loop()``. |
||||
|
|
||||
|
Attributes |
||||
|
----------- |
||||
|
user : Optional[:class:`User`] |
||||
|
Represents the connected client. None if not logged in. |
||||
|
servers : list of :class:`Server` |
||||
|
The servers that the connected client is a member of. |
||||
|
private_channels : list of :class:`PrivateChannel` |
||||
|
The private channels that the connected client is participating on. |
||||
|
messages : deque_ of :class:`Message` |
||||
|
A deque_ of :class:`Message` that the client has received from all |
||||
|
servers and private messages. The number of messages stored in this |
||||
|
deque is controlled by the ``max_messages`` parameter. |
||||
|
email : Optional[str] |
||||
|
The email used to login. This is only set if login is successful, |
||||
|
otherwise it's None. |
||||
|
gateway : Optional[str] |
||||
|
The websocket gateway the client is currently connected to. Could be None. |
||||
|
loop |
||||
|
The `event loop`_ that the client uses for HTTP requests and websocket operations. |
||||
|
|
||||
|
.. _deque: https://docs.python.org/3.4/library/collections.html#collections.deque |
||||
|
.. _event loop: https://docs.python.org/3/library/asyncio-eventloops.html |
||||
|
""" |
||||
|
def __init__(self, *, loop=None, **options): |
||||
|
self.ws = None |
||||
|
self.token = None |
||||
|
self.gateway = None |
||||
|
self.loop = asyncio.get_event_loop() if loop is None else loop |
||||
|
|
||||
|
max_messages = options.get('max_messages') |
||||
|
if max_messages is None or max_messages <= 0: |
||||
|
max_messages = 5000 |
||||
|
|
||||
|
self.connection = ConnectionState(self.dispatch, max_messages) |
||||
|
self.session = aiohttp.ClientSession(loop=self.loop) |
||||
|
self.headers = { |
||||
|
'content-type': 'application/json', |
||||
|
} |
||||
|
self._closed = False |
||||
|
|
||||
|
def _resolve_mentions(self, content, mentions): |
||||
|
if isinstance(mentions, list): |
||||
|
return [user.id for user in mentions] |
||||
|
elif mentions == True: |
||||
|
return re.findall(r'<@(\d+)>', content) |
||||
|
else: |
||||
|
return [] |
||||
|
|
||||
|
def _resolve_invite(self, invite): |
||||
|
if isinstance(invite, Invite) or isinstance(invite, Object): |
||||
|
return invite.id |
||||
|
else: |
||||
|
rx = r'(?:https?\:\/\/)?discord\.gg\/(.+)' |
||||
|
m = re.match(rx, invite) |
||||
|
if m: |
||||
|
return m.group(1) |
||||
|
return invite |
||||
|
|
||||
|
def _resolve_destination(self, destination): |
||||
|
if isinstance(destination, (Channel, PrivateChannel, Server)): |
||||
|
return destination.id |
||||
|
elif isinstance(destination, User): |
||||
|
found = utils.find(lambda pm: pm.user == destination, self.private_channels) |
||||
|
if found is None: |
||||
|
# Couldn't find the user, so start a PM with them first. |
||||
|
self.start_private_message(destination) |
||||
|
channel_id = self.private_channels[-1].id |
||||
|
return channel_id |
||||
|
else: |
||||
|
return found.id |
||||
|
elif isinstance(destination, Object): |
||||
|
return destination.id |
||||
|
else: |
||||
|
raise InvalidArgument('Destination must be Channel, PrivateChannel, User, or Object') |
||||
|
|
||||
|
# Compatibility shim |
||||
|
def __getattr__(self, name): |
||||
|
if name in ('user', 'email', 'servers', 'private_channels', 'messages'): |
||||
|
return getattr(self.connection, name) |
||||
|
else: |
||||
|
msg = "'{}' object has no attribute '{}'" |
||||
|
raise AttributeError(msg.format(self.__class__, name)) |
||||
|
|
||||
|
# Compatibility shim |
||||
|
def __setattr__(self, name, value): |
||||
|
if name in ('user', 'email', 'servers', 'private_channels', |
||||
|
'messages'): |
||||
|
return setattr(self.connection, name, value) |
||||
|
else: |
||||
|
object.__setattr__(self, name, value) |
||||
|
|
||||
|
@property |
||||
|
def is_logged_in(self): |
||||
|
"""bool: Indicates if the client has logged in successfully.""" |
||||
|
return self._is_logged_in |
||||
|
|
||||
|
@asyncio.coroutine |
||||
|
def _get_gateway(self): |
||||
|
resp = yield from self.session.get(endpoints.GATEWAY, headers=self.headers) |
||||
|
if resp.status != 200: |
||||
|
raise GatewayNotFound() |
||||
|
data = yield from resp.json() |
||||
|
return data.get('url') |
||||
|
|
||||
|
@asyncio.coroutine |
||||
|
def _run_event(self, event, *args, **kwargs): |
||||
|
try: |
||||
|
yield from getattr(self, event)(*args, **kwargs) |
||||
|
except Exception as e: |
||||
|
yield from self.on_error(event, *args, **kwargs) |
||||
|
|
||||
|
def dispatch(self, event, *args, **kwargs): |
||||
|
log.debug('Dispatching event {}'.format(event)) |
||||
|
method = 'on_' + event |
||||
|
handler = 'handle_' + event |
||||
|
|
||||
|
if hasattr(self, handler): |
||||
|
getattr(self, handler)(*args, **kwargs) |
||||
|
|
||||
|
if hasattr(self, method): |
||||
|
utils.create_task(self._run_event(method, *args, **kwargs), loop=self.loop) |
||||
|
|
||||
|
def get_channel(self, id): |
||||
|
"""Returns a :class:`Channel` or :class:`PrivateChannel` with the following ID. If not found, returns None.""" |
||||
|
return self.connection.get_channel(id) |
||||
|
|
||||
|
@asyncio.coroutine |
||||
|
def login(self, email, password): |
||||
|
"""|coro| |
||||
|
|
||||
|
Logs in the client with the specified credentials. |
||||
|
|
||||
|
Parameters |
||||
|
---------- |
||||
|
email : str |
||||
|
The email used to login. |
||||
|
password : str |
||||
|
The password used to login. |
||||
|
|
||||
|
Raises |
||||
|
------ |
||||
|
LoginFailure |
||||
|
The wrong credentials are passed. |
||||
|
HTTPException |
||||
|
An unknown HTTP related error occurred, |
||||
|
usually when it isn't 200 or the known incorrect credentials |
||||
|
passing status code. |
||||
|
""" |
||||
|
payload = { |
||||
|
'email': email, |
||||
|
'password': password |
||||
|
} |
||||
|
|
||||
|
data = to_json(payload) |
||||
|
resp = yield from self.session.post(endpoints.LOGIN, data=data, headers=self.headers) |
||||
|
log.debug(request_logging_format.format(method='POST', response=resp)) |
||||
|
if resp.status == 400: |
||||
|
raise LoginFailure('Improper credentials have been passed.') |
||||
|
elif resp.status != 200: |
||||
|
data = yield from resp.json() |
||||
|
raise HTTPException(resp, data.get('message')) |
||||
|
|
||||
|
log.info('logging in returned status code {}'.format(resp.status)) |
||||
|
self.email = email |
||||
|
|
||||
|
body = yield from resp.json() |
||||
|
self.token = body['token'] |
||||
|
self.headers['authorization'] = self.token |
||||
|
self._is_logged_in = True |
||||
|
|
||||
|
@asyncio.coroutine |
||||
|
def keep_alive_handler(self, interval): |
||||
|
while not self._closed: |
||||
|
payload = { |
||||
|
'op': 1, |
||||
|
'd': int(time.time()) |
||||
|
} |
||||
|
|
||||
|
msg = 'Keeping websocket alive with timestamp {}' |
||||
|
log.debug(msg.format(payload['d'])) |
||||
|
yield from self.ws.send(to_json(payload)) |
||||
|
yield from asyncio.sleep(interval) |
||||
|
|
||||
|
@asyncio.coroutine |
||||
|
def on_error(self, event_method, *args, **kwargs): |
||||
|
"""|coro| |
||||
|
|
||||
|
The default error handler provided by the client. |
||||
|
|
||||
|
By default this prints to ``sys.stderr`` however it could be |
||||
|
overridden to have a different implementation. |
||||
|
Check :func:`discord.on_error` for more details. |
||||
|
""" |
||||
|
print('Ignoring exception in {}'.format(event_method), file=sys.stderr) |
||||
|
traceback.print_exc() |
||||
|
|
||||
|
def received_message(self, msg): |
||||
|
log.debug('WebSocket Event: {}'.format(msg)) |
||||
|
self.dispatch('socket_response', msg) |
||||
|
|
||||
|
op = msg.get('op') |
||||
|
data = msg.get('d') |
||||
|
|
||||
|
if op != 0: |
||||
|
log.info('Unhandled op {}'.format(op)) |
||||
|
return |
||||
|
|
||||
|
event = msg.get('t') |
||||
|
|
||||
|
if event == 'READY': |
||||
|
interval = data['heartbeat_interval'] / 1000.0 |
||||
|
self.keep_alive = utils.create_task(self.keep_alive_handler(interval), loop=self.loop) |
||||
|
|
||||
|
if event in ('READY', 'MESSAGE_CREATE', 'MESSAGE_DELETE', |
||||
|
'MESSAGE_UPDATE', 'PRESENCE_UPDATE', 'USER_UPDATE', |
||||
|
'CHANNEL_DELETE', 'CHANNEL_UPDATE', 'CHANNEL_CREATE', |
||||
|
'GUILD_MEMBER_ADD', 'GUILD_MEMBER_REMOVE', |
||||
|
'GUILD_MEMBER_UPDATE', 'GUILD_CREATE', 'GUILD_DELETE', |
||||
|
'GUILD_ROLE_CREATE', 'GUILD_ROLE_DELETE', 'TYPING_START', |
||||
|
'GUILD_ROLE_UPDATE', 'VOICE_STATE_UPDATE'): |
||||
|
parser = 'parse_' + event.lower() |
||||
|
if hasattr(self.connection, parser): |
||||
|
getattr(self.connection, parser)(data) |
||||
|
else: |
||||
|
log.info("Unhandled event {}".format(event)) |
||||
|
|
||||
|
@asyncio.coroutine |
||||
|
def _make_websocket(self): |
||||
|
if not self.is_logged_in: |
||||
|
raise ClientException('You must be logged in to connect') |
||||
|
|
||||
|
self.gateway = yield from self._get_gateway() |
||||
|
self.ws = yield from websockets.connect(self.gateway) |
||||
|
self.ws.max_size = None |
||||
|
log.info('Created websocket connected to {0.gateway}'.format(self)) |
||||
|
payload = { |
||||
|
'op': 2, |
||||
|
'd': { |
||||
|
'token': self.token, |
||||
|
'properties': { |
||||
|
'$os': sys.platform, |
||||
|
'$browser': 'discord.py', |
||||
|
'$device': 'discord.py', |
||||
|
'$referrer': '', |
||||
|
'$referring_domain': '' |
||||
|
}, |
||||
|
'v': 3 |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
yield from self.ws.send(to_json(payload)) |
||||
|
log.info('sent the initial payload to create the websocket') |
||||
|
|
||||
|
@asyncio.coroutine |
||||
|
def connect(self): |
||||
|
"""|coro| |
||||
|
|
||||
|
Creates a websocket connection and connects to the websocket listen |
||||
|
to messages from discord. |
||||
|
|
||||
|
This function is implemented using a while loop in the background. |
||||
|
If you need to run this event listening in another thread then |
||||
|
you should run it in an executor or schedule the coroutine to |
||||
|
be executed later using ``loop.create_task``. |
||||
|
|
||||
|
This function throws :exc:`ClientException` if called before |
||||
|
logging in via :meth:`login`. |
||||
|
""" |
||||
|
yield from self._make_websocket() |
||||
|
|
||||
|
while not self._closed: |
||||
|
msg = yield from self.ws.recv() |
||||
|
if msg is None: |
||||
|
yield from self.ws.close() |
||||
|
self._closed = True |
||||
|
self.keep_alive.cancel() |
||||
|
break |
||||
|
|
||||
|
self.received_message(json.loads(msg)) |
||||
|
|
||||
|
def event(self, coro): |
||||
|
"""A decorator that registers an event to listen to. |
||||
|
|
||||
|
You can find more info about the events on the :ref:`documentation below <discord-api-events>`. |
||||
|
|
||||
|
The events must be a |corourl|_, if not, :exc:`ClientException` is raised. |
||||
|
|
||||
|
Example: :: |
||||
|
|
||||
|
@client.event |
||||
|
@asyncio.coroutine |
||||
|
def on_ready(): |
||||
|
print('Ready!') |
||||
|
""" |
||||
|
|
||||
|
if not asyncio.iscoroutinefunction(coro): |
||||
|
raise ClientException('event registered must be a coroutine function') |
||||
|
|
||||
|
setattr(self, coro.__name__, coro) |
||||
|
log.info('{0.__name__} has successfully been registered as an event'.format(coro)) |
||||
|
return coro |
||||
|
|
||||
|
@asyncio.coroutine |
||||
|
def start_private_message(self, user): |
||||
|
"""|coro| |
||||
|
|
||||
|
Starts a private message with the user. This allows you to |
||||
|
:meth:`send_message` to the user. |
||||
|
|
||||
|
Note |
||||
|
----- |
||||
|
This method should rarely be called as :meth:`send_message` |
||||
|
does it automatically for you. |
||||
|
|
||||
|
Parameters |
||||
|
----------- |
||||
|
user : :class:`User` |
||||
|
The user to start the private message with. |
||||
|
|
||||
|
Raises |
||||
|
------ |
||||
|
HTTPException |
||||
|
The request failed. |
||||
|
""" |
||||
|
|
||||
|
if not isinstance(user, User): |
||||
|
raise TypeError('user argument must be a User') |
||||
|
|
||||
|
payload = { |
||||
|
'recipient_id': user.id |
||||
|
} |
||||
|
|
||||
|
r = requests.post('{}/{}/channels'.format(endpoints.USERS, self.user.id), json=payload, headers=self.headers) |
||||
|
log.debug(request_logging_format.format(response=r)) |
||||
|
utils._verify_successful_response(r) |
||||
|
data = r.json() |
||||
|
log.debug(request_success_log.format(response=r, json=payload, data=data)) |
||||
|
self.private_channels.append(PrivateChannel(id=data['id'], user=user)) |
||||
|
|
||||
|
@asyncio.coroutine |
||||
|
def send_message(self, destination, content, *, mentions=True, tts=False): |
||||
|
"""|coro| |
||||
|
|
||||
|
Sends a message to the destination given with the content given. |
||||
|
|
||||
|
The destination could be a :class:`Channel`, :class:`PrivateChannel` or :class:`Server`. |
||||
|
For convenience it could also be a :class:`User`. If it's a :class:`User` or :class:`PrivateChannel` |
||||
|
then it sends the message via private message, otherwise it sends the message to the channel. |
||||
|
If the destination is a :class:`Server` then it's equivalent to calling |
||||
|
:meth:`Server.get_default_channel` and sending it there. If it is a :class:`Object` |
||||
|
instance then it is assumed to be the destination ID. |
||||
|
|
||||
|
.. versionchanged:: 0.9.0 |
||||
|
``str`` being allowed was removed and replaced with :class:`Object`. |
||||
|
|
||||
|
The content must be a type that can convert to a string through ``str(content)``. |
||||
|
|
||||
|
The mentions must be either an array of :class:`User` to mention or a boolean. If |
||||
|
``mentions`` is ``True`` then all the users mentioned in the content are mentioned, otherwise |
||||
|
no one is mentioned. Note that to mention someone in the content, you should use :meth:`User.mention`. |
||||
|
|
||||
|
Parameters |
||||
|
------------ |
||||
|
destination |
||||
|
The location to send the message. |
||||
|
content |
||||
|
The content of the message to send. |
||||
|
mentions |
||||
|
A list of :class:`User` to mention in the message or a boolean. Ignored for private messages. |
||||
|
tts : bool |
||||
|
Indicates if the message should be sent using text-to-speech. |
||||
|
|
||||
|
Raises |
||||
|
-------- |
||||
|
HTTPException |
||||
|
Sending the message failed. |
||||
|
InvalidArgument |
||||
|
The destination parameter is invalid. |
||||
|
|
||||
|
Returns |
||||
|
--------- |
||||
|
:class:`Message` |
||||
|
The message that was sent. |
||||
|
""" |
||||
|
|
||||
|
channel_id = self._resolve_destination(destination) |
||||
|
|
||||
|
content = str(content) |
||||
|
mentions = self._resolve_mentions(content, mentions) |
||||
|
|
||||
|
url = '{base}/{id}/messages'.format(base=endpoints.CHANNELS, id=channel_id) |
||||
|
payload = { |
||||
|
'content': content, |
||||
|
'mentions': mentions |
||||
|
} |
||||
|
|
||||
|
if tts: |
||||
|
payload['tts'] = True |
||||
|
|
||||
|
resp = yield from self.session.post(url, data=to_json(payload), headers=self.headers) |
||||
|
log.debug(request_logging_format.format(method='POST', response=resp)) |
||||
|
yield from utils._verify_successful_response(resp) |
||||
|
data = yield from resp.json() |
||||
|
log.debug(request_success_log.format(response=resp, json=payload, data=data)) |
||||
|
channel = self.get_channel(data.get('channel_id')) |
||||
|
message = Message(channel=channel, **data) |
||||
|
return message |
||||
@ -0,0 +1,295 @@ |
|||||
|
# -*- coding: utf-8 -*- |
||||
|
|
||||
|
""" |
||||
|
The MIT License (MIT) |
||||
|
|
||||
|
Copyright (c) 2015 Rapptz |
||||
|
|
||||
|
Permission is hereby granted, free of charge, to any person obtaining a |
||||
|
copy of this software and associated documentation files (the "Software"), |
||||
|
to deal in the Software without restriction, including without limitation |
||||
|
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
||||
|
and/or sell copies of the Software, and to permit persons to whom the |
||||
|
Software is furnished to do so, subject to the following conditions: |
||||
|
|
||||
|
The above copyright notice and this permission notice shall be included in |
||||
|
all copies or substantial portions of the Software. |
||||
|
|
||||
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
||||
|
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
||||
|
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
||||
|
DEALINGS IN THE SOFTWARE. |
||||
|
""" |
||||
|
|
||||
|
from .server import Server |
||||
|
from .user import User |
||||
|
from .message import Message |
||||
|
from .channel import Channel, PrivateChannel |
||||
|
from .member import Member |
||||
|
from .role import Role |
||||
|
from . import utils |
||||
|
|
||||
|
from collections import deque |
||||
|
import copy |
||||
|
import datetime |
||||
|
|
||||
|
class ConnectionState: |
||||
|
def __init__(self, dispatch, max_messages): |
||||
|
self.user = None |
||||
|
self.email = None |
||||
|
self.servers = [] |
||||
|
self.private_channels = [] |
||||
|
self.messages = deque(maxlen=max_messages) |
||||
|
self.dispatch = dispatch |
||||
|
|
||||
|
def _get_message(self, msg_id): |
||||
|
return utils.find(lambda m: m.id == msg_id, self.messages) |
||||
|
|
||||
|
def _get_server(self, guild_id): |
||||
|
return utils.find(lambda g: g.id == guild_id, self.servers) |
||||
|
|
||||
|
def _add_server(self, guild): |
||||
|
server = Server(**guild) |
||||
|
self.servers.append(server) |
||||
|
|
||||
|
def parse_ready(self, data): |
||||
|
self.user = User(**data['user']) |
||||
|
guilds = data.get('guilds') |
||||
|
|
||||
|
for guild in guilds: |
||||
|
if guild.get('unavailable', False): |
||||
|
continue |
||||
|
self._add_server(guild) |
||||
|
|
||||
|
for pm in data.get('private_channels'): |
||||
|
self.private_channels.append(PrivateChannel(id=pm['id'], |
||||
|
user=User(**pm['recipient']))) |
||||
|
|
||||
|
# we're all ready |
||||
|
self.dispatch('ready') |
||||
|
|
||||
|
def parse_message_create(self, data): |
||||
|
channel = self.get_channel(data.get('channel_id')) |
||||
|
message = Message(channel=channel, **data) |
||||
|
self.dispatch('message', message) |
||||
|
self.messages.append(message) |
||||
|
|
||||
|
def parse_message_delete(self, data): |
||||
|
channel = self.get_channel(data.get('channel_id')) |
||||
|
message_id = data.get('id') |
||||
|
found = self._get_message(message_id) |
||||
|
if found is not None: |
||||
|
self.dispatch('message_delete', found) |
||||
|
self.messages.remove(found) |
||||
|
|
||||
|
def parse_message_update(self, data): |
||||
|
older_message = self._get_message(data.get('id')) |
||||
|
if older_message is not None: |
||||
|
# create a copy of the new message |
||||
|
message = copy.copy(older_message) |
||||
|
# update the new update |
||||
|
for attr in data: |
||||
|
if attr == 'channel_id' or attr == 'author': |
||||
|
continue |
||||
|
value = data[attr] |
||||
|
if 'time' in attr: |
||||
|
setattr(message, attr, utils.parse_time(value)) |
||||
|
else: |
||||
|
setattr(message, attr, value) |
||||
|
self.dispatch('message_edit', older_message, message) |
||||
|
# update the older message |
||||
|
older_message = message |
||||
|
|
||||
|
def parse_presence_update(self, data): |
||||
|
server = self._get_server(data.get('guild_id')) |
||||
|
if server is not None: |
||||
|
status = data.get('status') |
||||
|
user = data['user'] |
||||
|
member_id = user['id'] |
||||
|
member = utils.find(lambda m: m.id == member_id, server.members) |
||||
|
if member is not None: |
||||
|
old_member = copy.copy(member) |
||||
|
member.status = data.get('status') |
||||
|
member.game_id = data.get('game_id') |
||||
|
member.name = user.get('username', member.name) |
||||
|
member.avatar = user.get('avatar', member.avatar) |
||||
|
|
||||
|
# call the event now |
||||
|
self.dispatch('status', member, old_member.game_id, old_member.status) |
||||
|
self.dispatch('member_update', old_member, member) |
||||
|
|
||||
|
def parse_user_update(self, data): |
||||
|
self.user = User(**data) |
||||
|
|
||||
|
def parse_channel_delete(self, data): |
||||
|
server = self._get_server(data.get('guild_id')) |
||||
|
if server is not None: |
||||
|
channel_id = data.get('id') |
||||
|
channel = utils.find(lambda c: c.id == channel_id, server.channels) |
||||
|
try: |
||||
|
server.channels.remove(channel) |
||||
|
self.dispatch('channel_delete', channel) |
||||
|
except ValueError: |
||||
|
return |
||||
|
|
||||
|
def parse_channel_update(self, data): |
||||
|
server = self._get_server(data.get('guild_id')) |
||||
|
if server is not None: |
||||
|
channel_id = data.get('id') |
||||
|
channel = utils.find(lambda c: c.id == channel_id, server.channels) |
||||
|
channel.update(server=server, **data) |
||||
|
self.dispatch('channel_update', channel) |
||||
|
|
||||
|
def parse_channel_create(self, data): |
||||
|
is_private = data.get('is_private', False) |
||||
|
channel = None |
||||
|
if is_private: |
||||
|
recipient = User(**data.get('recipient')) |
||||
|
pm_id = data.get('id') |
||||
|
channel = PrivateChannel(id=pm_id, user=recipient) |
||||
|
self.private_channels.append(channel) |
||||
|
else: |
||||
|
server = self._get_server(data.get('guild_id')) |
||||
|
if server is not None: |
||||
|
channel = Channel(server=server, **data) |
||||
|
server.channels.append(channel) |
||||
|
|
||||
|
self.dispatch('channel_create', channel) |
||||
|
|
||||
|
def parse_guild_member_add(self, data): |
||||
|
server = self._get_server(data.get('guild_id')) |
||||
|
member = Member(server=server, deaf=False, mute=False, **data) |
||||
|
server.members.append(member) |
||||
|
self.dispatch('member_join', member) |
||||
|
|
||||
|
def parse_guild_member_remove(self, data): |
||||
|
server = self._get_server(data.get('guild_id')) |
||||
|
if server is not None: |
||||
|
user_id = data['user']['id'] |
||||
|
member = utils.find(lambda m: m.id == user_id, server.members) |
||||
|
try: |
||||
|
server.members.remove(member) |
||||
|
self.dispatch('member_remove', member) |
||||
|
except ValueError: |
||||
|
return |
||||
|
|
||||
|
def parse_guild_member_update(self, data): |
||||
|
server = self._get_server(data.get('guild_id')) |
||||
|
user_id = data['user']['id'] |
||||
|
member = utils.find(lambda m: m.id == user_id, server.members) |
||||
|
if member is not None: |
||||
|
user = data['user'] |
||||
|
old_member = copy.copy(member) |
||||
|
member.name = user['username'] |
||||
|
member.discriminator = user['discriminator'] |
||||
|
member.avatar = user['avatar'] |
||||
|
member.roles = [] |
||||
|
# update the roles |
||||
|
for role in server.roles: |
||||
|
if role.id in data['roles']: |
||||
|
member.roles.append(role) |
||||
|
|
||||
|
self.dispatch('member_update', old_member, member) |
||||
|
|
||||
|
def parse_guild_create(self, data): |
||||
|
unavailable = data.get('unavailable') |
||||
|
if unavailable == False: |
||||
|
# GUILD_CREATE with unavailable in the response |
||||
|
# usually means that the server has become available |
||||
|
# and is therefore in the cache |
||||
|
server = self._get_server(data.get('id')) |
||||
|
if server is not None: |
||||
|
server.unavailable = False |
||||
|
self.dispatch('server_available', server) |
||||
|
return |
||||
|
|
||||
|
if unavailable == True: |
||||
|
# joined a server with unavailable == True so.. |
||||
|
return |
||||
|
|
||||
|
# if we're at this point then it was probably |
||||
|
# unavailable during the READY event and is now |
||||
|
# available, so it isn't in the cache... |
||||
|
|
||||
|
self._add_server(data) |
||||
|
self.dispatch('server_join', self.servers[-1]) |
||||
|
|
||||
|
def parse_guild_delete(self, data): |
||||
|
server = self._get_server(data.get('id')) |
||||
|
if data.get('unavailable', False) and server is not None: |
||||
|
# GUILD_DELETE with unavailable being True means that the |
||||
|
# server that was available is now currently unavailable |
||||
|
server.unavailable = True |
||||
|
self.dispatch('server_unavailable', server) |
||||
|
return |
||||
|
|
||||
|
try: |
||||
|
self.servers.remove(server) |
||||
|
self.dispatch('server_remove', server) |
||||
|
except ValueError: |
||||
|
return |
||||
|
|
||||
|
def parse_guild_role_create(self, data): |
||||
|
server = self._get_server(data.get('guild_id')) |
||||
|
role_data = data.get('role', {}) |
||||
|
everyone = server.id == role_data.get('id') |
||||
|
role = Role(everyone=everyone, **role_data) |
||||
|
server.roles.append(role) |
||||
|
self.dispatch('server_role_create', server, role) |
||||
|
|
||||
|
def parse_guild_role_delete(self, data): |
||||
|
server = self._get_server(data.get('guild_id')) |
||||
|
if server is not None: |
||||
|
role_id = data.get('role_id') |
||||
|
role = utils.find(lambda r: r.id == role_id, server.roles) |
||||
|
server.roles.remove(role) |
||||
|
self.dispatch('server_role_delete', server, role) |
||||
|
|
||||
|
def parse_guild_role_update(self, data): |
||||
|
server = self._get_server(data.get('guild_id')) |
||||
|
if server is not None: |
||||
|
role_id = data['role']['id'] |
||||
|
role = utils.find(lambda r: r.id == role_id, server.roles) |
||||
|
role.update(**data['role']) |
||||
|
self.dispatch('server_role_update', role) |
||||
|
|
||||
|
def parse_voice_state_update(self, data): |
||||
|
server = self._get_server(data.get('guild_id')) |
||||
|
if server is not None: |
||||
|
updated_member = server._update_voice_state(data) |
||||
|
self.dispatch('voice_state_update', updated_member) |
||||
|
|
||||
|
def parse_typing_start(self, data): |
||||
|
channel = self.get_channel(data.get('channel_id')) |
||||
|
if channel is not None: |
||||
|
member = None |
||||
|
user_id = data.get('user_id') |
||||
|
is_private = getattr(channel, 'is_private', None) |
||||
|
if is_private == None: |
||||
|
return |
||||
|
|
||||
|
if is_private: |
||||
|
member = channel.user |
||||
|
else: |
||||
|
members = channel.server.members |
||||
|
member = utils.find(lambda m: m.id == user_id, members) |
||||
|
|
||||
|
if member is not None: |
||||
|
timestamp = datetime.datetime.utcfromtimestamp(data.get('timestamp')) |
||||
|
self.dispatch('typing', channel, member, timestamp) |
||||
|
|
||||
|
def get_channel(self, id): |
||||
|
if id is None: |
||||
|
return None |
||||
|
|
||||
|
for server in self.servers: |
||||
|
for channel in server.channels: |
||||
|
if channel.id == id: |
||||
|
return channel |
||||
|
|
||||
|
for pm in self.private_channels: |
||||
|
if pm.id == id: |
||||
|
return pm |
||||
Loading…
Reference in new issue