velvox
/
litecord
mirror of https://gitlab.com/litecord/litecord.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

pubsub.lazy_guild: sanity of mind 

- add more comments, always good
 - remove some unused methods and move some others to private methods
 - use _set_empty_list in close() method
This commit is contained in:
Luna 2019-02-03 23:23:07 -03:00
parent a69a2423de
commit f1127d1970
1 changed files with 112 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

207
litecord/pubsub/lazy_guild.py
View File

@ -18,12 +18,18 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
""" """
""" """
Main code for Lazy Guild implementation in litecord. lazy guilds:
the lazy guild api docs (which are heavily based off this implementation)
can be found on
https://luna.gitlab.io/discord-unofficial-docs/lazy_guilds.html
""" """
import asyncio import asyncio
from dataclasses import dataclass, asdict, field
from collections import defaultdict from collections import defaultdict
from typing import Any, List, Dict, Union from typing import Any, List, Dict, Union
from dataclasses import dataclass, asdict, field
from logbook import Logger from logbook import Logger
@ -85,11 +91,14 @@ class MemberList:
def __bool__(self): def __bool__(self):
"""Return if the current member list is fully initialized.""" """Return if the current member list is fully initialized."""
# asdict comes from dataclasses
list_dict = asdict(self) list_dict = asdict(self)
# ignore the bool status of overwrites # ignore the bool status of overwrites
return all(bool(list_dict[k]) return all(
for k in ('groups', 'data', 'presences', 'members')) bool(list_dict[k])
for k in ('groups', 'data', 'presences', 'members')
)
def __iter__(self): def __iter__(self):
"""Iterate over all groups in the correct order. """Iterate over all groups in the correct order.
@ -104,8 +113,12 @@ class MemberList:
yield group, self.data[group.gid] yield group, self.data[group.gid]
@property @property
def iter_non_empty(self): def iter_non_empty(self) -> tuple:
"""Only iterate through non-empty groups""" """Only iterate through non-empty groups.
Note that while the offline group can be empty, it is always
yielded out, to comply with Discord.
"""
for group, member_ids in self: for group, member_ids in self:
count = len(member_ids) count = len(member_ids)
@ -183,6 +196,13 @@ def _to_simple_group(presence: dict) -> str:
async def everyone_allow(gml) -> bool: async def everyone_allow(gml) -> bool:
"""Return if the '@everyone' role can access a given member list.
This is important in regards to member list IDs, since if the '@everyone'
role can access the list, then the list is downgraded to an 'everyone' list.
If the role can't access the list, then the list keeps its list ID.
"""
everyone_perms = await role_permissions( everyone_perms = await role_permissions(
gml.guild_id, gml.guild_id,
gml.guild_id, gml.guild_id,
@ -190,20 +210,7 @@ async def everyone_allow(gml) -> bool:
storage=gml.storage storage=gml.storage
) )
return everyone_perms.bits.read_messages return bool(everyone_perms.bits.read_messages)
def display_name(member_nicks: Dict[str, str], presence: Presence) -> str:
"""Return the display name of a presence.
Used to sort groups.
"""
uid = presence['user']['id']
uname = presence['user']['username']
nick = member_nicks.get(uid)
return nick or uname
def merge(member: dict, presence: Presence) -> dict: def merge(member: dict, presence: Presence) -> dict:
@ -344,7 +351,8 @@ class GuildMemberList:
return group_id return group_id
def _can_read_chan(self, group: GroupInfo): def _can_read_chan(self, group: GroupInfo) -> bool:
"""Return if a given group can acess the channel"""
# get the base role perms # get the base role perms
role_perms = group.permissions role_perms = group.permissions
@ -359,9 +367,9 @@ class GuildMemberList:
# if the role can read messages, then its # if the role can read messages, then its
# part of the group. # part of the group.
return final_perms.bits.read_messages return bool(final_perms.bits.read_messages)
async def get_role_groups(self) -> List[GroupInfo]: async def _get_role_groups(self) -> List[GroupInfo]:
"""Get role information, but only: """Get role information, but only:
- the ID - the ID
- the name - the name
@ -382,15 +390,19 @@ class GuildMemberList:
""", self.guild_id) """, self.guild_id)
hoisted = [ hoisted = [
GroupInfo(row['id'], row['name'], GroupInfo(
row['id'], row['name'],
row['position'], row['position'],
Permissions(row['permissions'])) Permissions(row['permissions'])
)
for row in roledata if row['hoist'] for row in roledata if row['hoist']
] ]
# sort role list by position # sort role list by position
hoisted = sorted(hoisted, key=lambda group: group.position, hoisted = sorted(
reverse=True) hoisted, key=lambda group: group.position,
reverse=True
)
# we need to store the overwrites since # we need to store the overwrites since
# we have incoming presences to manage. # we have incoming presences to manage.
@ -398,9 +410,9 @@ class GuildMemberList:
return list(filter(self._can_read_chan, hoisted)) return list(filter(self._can_read_chan, hoisted))
async def set_groups(self): async def _set_groups(self):
"""Get the groups for the member list.""" """Get the groups for the member list."""
role_groups = await self.get_role_groups() role_groups = await self._get_role_groups()
# inject default groups 'online' and 'offline' # inject default groups 'online' and 'offline'
# their position is always going to be the last ones. # their position is always going to be the last ones.
@ -409,7 +421,7 @@ class GuildMemberList:
GroupInfo('offline', 'offline', MAX_ROLES + 2, 0) GroupInfo('offline', 'offline', MAX_ROLES + 2, 0)
] ]
async def get_group_for_member(self, member_id: int, async def _get_group_for_member(self, member_id: int,
roles: List[Union[str, int]], roles: List[Union[str, int]],
status: str) -> GroupID: status: str) -> GroupID:
"""Return a fitting group ID for the member.""" """Return a fitting group ID for the member."""
@ -435,7 +447,7 @@ class GuildMemberList:
for member_id in member_ids: for member_id in member_ids:
presence = self.list.presences[member_id] presence = self.list.presences[member_id]
group_id = await self.get_group_for_member( group_id = await self._get_group_for_member(
member_id, presence['roles'], presence['status'] member_id, presence['roles'], presence['status']
) )
@ -451,19 +463,12 @@ class GuildMemberList:
self.list.members[member_id] = member self.list.members[member_id] = member
self.list.data[group_id].append(member_id) self.list.data[group_id].append(member_id)
async def get_member_nicks_dict(self) -> dict: def _display_name(self, member_id: int) -> str:
"""Get a dictionary with nickname information.""" """Get the display name for a given member.
members = await self.storage.get_member_data(self.guild_id)
# make a dictionary of member ids to nicknames This is more efficient than the old function (not method) of same
# so we don't need to keep querying the db on name, as we dont need to pass nickname information to it.
# every loop iteration """
member_nicks = {m['user']['id']: m.get('nick')
for m in members}
return member_nicks
def display_name(self, member_id: int):
member = self.list.members.get(member_id) member = self.list.members.get(member_id)
if not member_id: if not member_id:
@ -476,10 +481,9 @@ class GuildMemberList:
async def _sort_groups(self): async def _sort_groups(self):
for member_ids in self.list.data.values(): for member_ids in self.list.data.values():
# this should update the list in-place # this should update the list in-place
member_ids.sort( member_ids.sort(
key=self.display_name) key=self._display_name)
async def __init_member_list(self): async def __init_member_list(self):
"""Generate the main member list with groups.""" """Generate the main member list with groups."""
@ -492,7 +496,7 @@ class GuildMemberList:
self.list.presences = {int(p['user']['id']): p self.list.presences = {int(p['user']['id']): p
for p in presences} for p in presences}
await self.set_groups() await self._set_groups()
log.debug('init: {} members, {} groups', log.debug('init: {} members, {} groups',
len(member_ids), len(member_ids),
@ -514,7 +518,7 @@ class GuildMemberList:
finally: finally:
self._list_lock.release() self._list_lock.release()
def get_member_as_item(self, member_id: int) -> dict: def _get_member_as_item(self, member_id: int) -> dict:
"""Get an item representing a member.""" """Get an item representing a member."""
member = self.list.members[member_id] member = self.list.members[member_id]
presence = self.list.presences[member_id] presence = self.list.presences[member_id]
@ -550,17 +554,17 @@ class GuildMemberList:
for member_id in member_ids: for member_id in member_ids:
res.append({ res.append({
'member': self.get_member_as_item(member_id) 'member': self._get_member_as_item(member_id)
}) })
return res return res
async def sub(self, _session_id: str):
"""Subscribe a shard to the member list."""
await self._init_check()
def unsub(self, session_id: str): def unsub(self, session_id: str):
"""Unsubscribe a shard from the member list""" """Unsubscribe a shard from the member list
Subscription for the member list is handled via the
:meth:`GuildMemberList.shard_query` method.
"""
try: try:
self.state.pop(session_id) self.state.pop(session_id)
except KeyError: except KeyError:
@ -574,8 +578,11 @@ class GuildMemberList:
if not self.state: if not self.state:
self._set_empty_list() self._set_empty_list()
def get_state(self, session_id: str): def _get_state(self, session_id: str):
"""Get the state for a session id.""" """Get the state for a session id.
Wrapper for :meth:`StateManager.fetch_raw`
"""
try: try:
state = self.state_man.fetch_raw(session_id) state = self.state_man.fetch_raw(session_id)
return state return state
@ -605,7 +612,7 @@ class GuildMemberList:
] ]
} }
states = map(self.get_state, session_ids) states = map(self._get_state, session_ids)
states = filter(lambda state: state is not None, states) states = filter(lambda state: state is not None, states)
dispatched = [] dispatched = []
@ -618,7 +625,7 @@ class GuildMemberList:
return dispatched return dispatched
async def resync(self, session_ids: int, item_index: int) -> List[str]: async def _resync(self, session_ids: int, item_index: int) -> List[str]:
"""Send a SYNC event to all states that are subscribed to an item. """Send a SYNC event to all states that are subscribed to an item.
Returns Returns
@ -653,13 +660,13 @@ class GuildMemberList:
return result return result
async def resync_by_item(self, item_index: int): async def _resync_by_item(self, item_index: int):
"""Resync but only giving the item index.""" """Resync but only giving the item index."""
if item_index is None: if item_index is None:
return [] return []
return await self.resync( return await self._resync(
self.get_subs(item_index), self._get_subs(item_index),
item_index item_index
) )
@ -722,8 +729,9 @@ class GuildMemberList:
# send SYNCs to the state that requested # send SYNCs to the state that requested
await self._dispatch_sess([session_id], ops) await self._dispatch_sess([session_id], ops)
def get_item_index(self, user_id: Union[str, int]) -> int: def _get_item_index(self, user_id: Union[str, int]) -> int:
"""Get the item index a user is on.""" """Get the item index a user is on."""
# NOTE: this is inefficient
user_id = int(user_id) user_id = int(user_id)
index = 1 index = 1
@ -741,7 +749,7 @@ class GuildMemberList:
return None return None
def get_group_item_index(self, group_id: GroupID) -> int: def _get_group_item_index(self, group_id: GroupID) -> int:
"""Get the item index a group is on.""" """Get the item index a group is on."""
index = 0 index = 0
@ -753,7 +761,7 @@ class GuildMemberList:
return None return None
def state_is_subbed(self, item_index, session_id: str) -> bool: def _is_subbed(self, item_index, session_id: str) -> bool:
"""Return if a state's ranges include the given """Return if a state's ranges include the given
item index.""" item index."""
@ -765,15 +773,21 @@ class GuildMemberList:
return False return False
def get_subs(self, item_index: int) -> filter: def _get_subs(self, item_index: int) -> filter:
"""Get the list of subscribed states to a given item.""" """Get the list of subscribed states to a given item."""
return filter( return filter(
lambda sess_id: self.state_is_subbed(item_index, sess_id), lambda sess_id: self._is_subbed(item_index, sess_id),
self.state.keys() self.state.keys()
) )
async def _pres_update_simple(self, user_id: int): async def _pres_update_simple(self, user_id: int):
item_index = self.get_item_index(user_id) """Handler for simple presence updates.
Simple presence updates are just a single UPDATE operator for
the client. usually called when a user still maintains their role
list but changes to from online to idle/dnd and vice-versa.
"""
item_index = self._get_item_index(user_id)
if item_index is None: if item_index is None:
log.warning('lazy guild got invalid pres update uid={}', log.warning('lazy guild got invalid pres update uid={}',
@ -781,7 +795,7 @@ class GuildMemberList:
return [] return []
item = self.items[item_index] item = self.items[item_index]
session_ids = self.get_subs(item_index) session_ids = self._get_subs(item_index)
# simple update means we just give an UPDATE # simple update means we just give an UPDATE
# operation # operation
@ -818,8 +832,8 @@ class GuildMemberList:
ops = [] ops = []
old_user_index = self.get_item_index(user_id) old_user_index = self._get_item_index(user_id)
old_group_index = self.get_group_item_index(old_group) old_group_index = self._get_group_item_index(old_group)
ops.append(Operation('DELETE', { ops.append(Operation('DELETE', {
'index': old_user_index 'index': old_user_index
@ -831,7 +845,7 @@ class GuildMemberList:
await self._sort_groups() await self._sort_groups()
new_user_index = self.get_item_index(user_id) new_user_index = self._get_item_index(user_id)
ops.append(Operation('INSERT', { ops.append(Operation('INSERT', {
'index': new_user_index, 'index': new_user_index,
@ -845,7 +859,7 @@ class GuildMemberList:
# the first member in the group. # the first member in the group.
if self.list.is_birth(new_group) and new_group != 'offline': if self.list.is_birth(new_group) and new_group != 'offline':
ops.append(Operation('INSERT', { ops.append(Operation('INSERT', {
'index': self.get_group_item_index(new_group), 'index': self._get_group_item_index(new_group),
'item': { 'item': {
'group': str(new_group), 'count': 1 'group': str(new_group), 'count': 1
} }
@ -858,8 +872,8 @@ class GuildMemberList:
'index': old_group_index, 'index': old_group_index,
})) }))
session_ids_old = list(self.get_subs(old_user_index)) session_ids_old = list(self._get_subs(old_user_index))
session_ids_new = list(self.get_subs(new_user_index)) session_ids_new = list(self._get_subs(new_user_index))
# session_ids = set(session_ids_old + session_ids_new) # session_ids = set(session_ids_old + session_ids_new)
# NOTE: this section is what a realistic implementation # NOTE: this section is what a realistic implementation
@ -876,8 +890,8 @@ class GuildMemberList:
# ) # )
# merge both results together # merge both results together
return (await self.resync(session_ids_old, old_user_index) + return (await self._resync(session_ids_old, old_user_index) +
await self.resync(session_ids_new, new_user_index)) await self._resync(session_ids_new, new_user_index))
async def new_member(self, user_id: int): async def new_member(self, user_id: int):
"""Insert a new member.""" """Insert a new member."""
@ -906,7 +920,7 @@ class GuildMemberList:
self.list.members[user_id] = member self.list.members[user_id] = member
# find a group for the newcomer # find a group for the newcomer
group_id = await self.get_group_for_member( group_id = await self._get_group_for_member(
user_id, member['roles'], pres['status']) user_id, member['roles'], pres['status'])
if group_id is None: if group_id is None:
@ -917,13 +931,13 @@ class GuildMemberList:
self.list.data[group_id].append(user_id) self.list.data[group_id].append(user_id)
await self._sort_groups() await self._sort_groups()
user_index = self.get_item_index(user_id) user_index = self._get_item_index(user_id)
if not user_index: if not user_index:
log.warning('lazy: new uid {} was not assigned idx', log.warning('lazy: new uid {} was not assigned idx',
user_id) user_id)
return await self.resync_by_item(user_index) return await self._resync_by_item(user_index)
async def remove_member(self, user_id: int): async def remove_member(self, user_id: int):
"""Remove a member from the list.""" """Remove a member from the list."""
@ -933,17 +947,13 @@ class GuildMemberList:
return return
# we need the old index to resync later on # we need the old index to resync later on
old_idx = self.get_item_index(user_id) old_idx = self._get_item_index(user_id)
def is_valid_state(session_id):
state = self.get_state(session_id)
return state.user_id != user_id
# for now, remove any of the users' subscribed states # for now, remove any of the users' subscribed states
state_keys = self.state.keys() state_keys = self.state.keys()
for session_id in state_keys: for session_id in state_keys:
state = self.get_state(session_id) state = self._get_state(session_id)
# if unknown state, remove from the subscriber list # if unknown state, remove from the subscriber list
if state is None: if state is None:
@ -978,7 +988,7 @@ class GuildMemberList:
log.warning('lazy: unknown member uid {}', user_id) log.warning('lazy: unknown member uid {}', user_id)
return return
group_id = await self.get_group_for_member( group_id = await self._get_group_for_member(
user_id, member['roles'], pres['status']) user_id, member['roles'], pres['status'])
if not group_id: if not group_id:
@ -992,7 +1002,7 @@ class GuildMemberList:
return return
# tell everyone about the removal. # tell everyone about the removal.
await self.resync_by_item(old_idx) await self._resync_by_item(old_idx)
async def update_user(self, user_id: int): async def update_user(self, user_id: int):
"""Called for user updates such as avatar or username.""" """Called for user updates such as avatar or username."""
@ -1009,8 +1019,8 @@ class GuildMemberList:
await self.storage.get_user(user_id) await self.storage.get_user(user_id)
# redispatch # redispatch
user_idx = self.get_item_index(user_id) user_idx = self._get_item_index(user_id)
return await self.resync_by_item(user_idx) return await self._resync_by_item(user_idx)
async def pres_update(self, user_id: int, async def pres_update(self, user_id: int,
partial_presence: Presence): partial_presence: Presence):
@ -1075,7 +1085,7 @@ class GuildMemberList:
# calculate a possible new group # calculate a possible new group
# TODO: handle when new_group is None (member loses perms) # TODO: handle when new_group is None (member loses perms)
new_group = await self.get_group_for_member( new_group = await self._get_group_for_member(
user_id, roles, status) user_id, roles, status)
log.debug('pres update: gid={} cid={} old_g={} new_g={}', log.debug('pres update: gid={} cid={} old_g={} new_g={}',
@ -1171,13 +1181,13 @@ class GuildMemberList:
""" """
role_id = int(role['id']) role_id = int(role['id'])
old_index = self.get_group_item_index(role_id) old_index = self._get_group_item_index(role_id)
if not old_index: if not old_index:
log.warning('lazy role_pos_update: unknown group {}', role_id) log.warning('lazy role_pos_update: unknown group {}', role_id)
return return
old_sessions = list(self.get_subs(old_index)) old_sessions = list(self._get_subs(old_index))
groups_idx = self._get_role_as_group_idx(role_id) groups_idx = self._get_role_as_group_idx(role_id)
if groups_idx is None: if groups_idx is None:
@ -1202,10 +1212,10 @@ class GuildMemberList:
[g.gid for g in new_groups]) [g.gid for g in new_groups])
self.list.groups = new_groups self.list.groups = new_groups
new_index = self.get_group_item_index(role_id) new_index = self._get_group_item_index(role_id)
return (await self.resync(old_sessions, old_index) + return (await self._resync(old_sessions, old_index) +
await self.resync_by_item(new_index)) await self._resync_by_item(new_index))
async def role_update(self, role: dict): async def role_update(self, role: dict):
"""Update a role. """Update a role.
@ -1267,7 +1277,7 @@ class GuildMemberList:
# states we'll resend the list info to. # states we'll resend the list info to.
# find the item id for the group info # find the item id for the group info
role_item_index = self.get_group_item_index(role_id) role_item_index = self._get_group_item_index(role_id)
# we only resync when we actually have an item to resync # we only resync when we actually have an item to resync
# we don't have items to resync when we: # we don't have items to resync when we:
@ -1279,7 +1289,7 @@ class GuildMemberList:
# using a filter object would cause problems # using a filter object would cause problems
# as we only resync AFTER we delete the group # as we only resync AFTER we delete the group
sess_ids_resync = (list(self.get_subs(role_item_index)) sess_ids_resync = (list(self._get_subs(role_item_index))
if role_item_index is not None if role_item_index is not None
else []) else [])
@ -1328,7 +1338,7 @@ class GuildMemberList:
log.debug('there are {} session ids to resync (for item {})', log.debug('there are {} session ids to resync (for item {})',
len(sess_ids_resync), role_item_index) len(sess_ids_resync), role_item_index)
return await self.resync(sess_ids_resync, role_item_index) return await self._resync(sess_ids_resync, role_item_index)
async def chan_update(self): async def chan_update(self):
"""Called then a channel's data has been updated.""" """Called then a channel's data has been updated."""
@ -1359,7 +1369,7 @@ class GuildMemberList:
self.guild_id = None self.guild_id = None
self.channel_id = None self.channel_id = None
self.main = None self.main = None
self.list = MemberList self._set_empty_list()
self.state = {} self.state = {}
@ -1412,6 +1422,7 @@ class LazyGuildDispatcher(Dispatcher):
)) ))
async def unsub(self, chan_id, session_id): async def unsub(self, chan_id, session_id):
"""Unsubscribe a session from the list."""
gml = await self.get_gml(chan_id) gml = await self.get_gml(chan_id)
gml.unsub(session_id) gml.unsub(session_id)