Aller au contenu

Role

MergeStrategy

Bases: Enum

Stratégie pour la fusion de plusieurs objets.

Source code in etuutt_bot/services/role.py 
15
16
17
18
19
20
21
22
23
class MergeStrategy(Enum):
    """Stratégie pour la fusion de plusieurs objets."""

    Intersection = 1
    """On garde l'intersection. ex: `[a, b, c] & [b, c, d] => [b, c]`."""
    Union = 2
    """On garde l'union. ex: `[a, b, c] | [b, c, d] => [a, b, c, d]`."""
    Clear = 3
    """On ne garde rien. ex: `[a, b, c] | [b, c, d] => []`"""

Clear = 3 class-attribute instance-attribute

On ne garde rien. ex: [a, b, c] | [b, c, d] => []

Intersection = 1 class-attribute instance-attribute

On garde l'intersection. ex: [a, b, c] & [b, c, d] => [b, c].

Union = 2 class-attribute instance-attribute

On garde l'union. ex: [a, b, c] | [b, c, d] => [a, b, c, d].

RoleService

Service de gestion des rôles du serveur.

Source code in etuutt_bot/services/role.py 
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
class RoleService:
    """Service de gestion des rôles du serveur."""

    def __init__(self, bot: EtuUTTBot):
        self._bot = bot

    def get_duplicates(self, *, case_sensitive: bool = True) -> list[list[Role]]:
        """Cherche et retourne tous les rôles qui sont dupliqués.

        Returns:
            La liste des listes de duplication.
            Chaque élément de la liste est une liste dont tous les
            éléments sont des rôles dupliqués.
        """

        def sort_key(r):
            return r.name if case_sensitive else r.name.upper()

        roles = sorted(self._bot.watched_guild.roles, key=sort_key)

        res = []
        for _, group in itertools.groupby(roles, key=sort_key):
            values = list(group)
            if len(values) > 1:
                res.append(values)
        return res

    def get_duplicate(self, role: Role, *, case_sensitive: bool = True) -> list[Role]:
        """Cherche et retourne tous les rôles qui ont le même nom que le rôle donné.

        Returns:
            La liste des rôles dupliqués.
            Le rôle passé en paramètre est inclus dedans.
        """
        if case_sensitive:
            return [r for r in self._bot.watched_guild.roles if r.name == role.name]
        return [r for r in self._bot.watched_guild.roles if r.name.lower() == role.name.lower()]

    @staticmethod
    def combined_perms(roles: list[Role], *, merge_strategy: MergeStrategy) -> Permissions:
        """Calcule et renvoie le jeu de permissions correspondant à la stratégie donnée.

        Args:
            roles: les rôles dont on veut combiner les permissions
            merge_strategy: la stratégie de combinaison des permissions

        Returns:
            Le jeu de permission obtenu par la combinaison des permissions de tous les rôles
        """
        perms = [role.permissions for role in roles]
        if merge_strategy == MergeStrategy.Intersection:
            return reduce(operator.or_, perms)
        if merge_strategy == MergeStrategy.Union:
            return reduce(operator.and_, perms)
        if merge_strategy == MergeStrategy.Clear:
            return Permissions.none()
        assert_never(merge_strategy)

    async def merge(self, roles: list[Role], *, merge_perms_strategy: MergeStrategy) -> Role:
        """Fusionne les rôles donnés, avec leurs permissions et leurs membres, en un seul.

        Le rôle gardé est celui de la liste avec le plus de membres.
        Tous les membres de tous les rôles de la liste reçoivent le rôle gardé.
        Tous les autres rôles sont supprimés.

        Warning:
            Cette fonction peut nécessiter beaucoup d'appels à l'API Discord
            (un pour chaque membre qui n'a pas déjà le rôle conservé,
            plus un pour chaque rôle supprimé,
            plus un pour éditer les permissions du rôle gardé).
            Utilisez-la avec parcimonie

        Args:
            roles: la liste des rôles à fusionner
            merge_perms_strategy: la stratégie de fusion des permissions à utiliser

        Returns:
            Le rôle résultant de la fusion.
        """
        # keep the role which has the most members,
        # in order to minimize the number of api calls when merging members
        to_keep = max(roles, key=lambda r: len(r.members))
        # set of members which must be assigned to the kept role
        members = {
            member for role in roles for member in role.members if to_keep not in member.roles
        }
        for member in members:
            await member.add_roles(to_keep)
        await to_keep.edit(
            permissions=self.combined_perms(roles, merge_strategy=merge_perms_strategy)
        )
        to_delete = [r for r in roles if r != to_keep]
        for role in to_delete:
            await role.delete(reason="Fusion de rôles dupliqués")
        return to_keep

combined_perms(roles, *, merge_strategy) staticmethod

Calcule et renvoie le jeu de permissions correspondant à la stratégie donnée.

Parameters:

Name Type Description Default
roles list[Role]

les rôles dont on veut combiner les permissions

 required
merge_strategy MergeStrategy

la stratégie de combinaison des permissions

 required

Returns:

Type Description
Permissions

Le jeu de permission obtenu par la combinaison des permissions de tous les rôles
Source code in etuutt_bot/services/role.py 
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
@staticmethod
def combined_perms(roles: list[Role], *, merge_strategy: MergeStrategy) -> Permissions:
    """Calcule et renvoie le jeu de permissions correspondant à la stratégie donnée.

    Args:
        roles: les rôles dont on veut combiner les permissions
        merge_strategy: la stratégie de combinaison des permissions

    Returns:
        Le jeu de permission obtenu par la combinaison des permissions de tous les rôles
    """
    perms = [role.permissions for role in roles]
    if merge_strategy == MergeStrategy.Intersection:
        return reduce(operator.or_, perms)
    if merge_strategy == MergeStrategy.Union:
        return reduce(operator.and_, perms)
    if merge_strategy == MergeStrategy.Clear:
        return Permissions.none()
    assert_never(merge_strategy)

get_duplicate(role, *, case_sensitive=True)

Cherche et retourne tous les rôles qui ont le même nom que le rôle donné.

Returns:

Type Description
list[Role]

La liste des rôles dupliqués.
list[Role]

Le rôle passé en paramètre est inclus dedans.
Source code in etuutt_bot/services/role.py 
53
54
55
56
57
58
59
60
61
62
def get_duplicate(self, role: Role, *, case_sensitive: bool = True) -> list[Role]:
    """Cherche et retourne tous les rôles qui ont le même nom que le rôle donné.

    Returns:
        La liste des rôles dupliqués.
        Le rôle passé en paramètre est inclus dedans.
    """
    if case_sensitive:
        return [r for r in self._bot.watched_guild.roles if r.name == role.name]
    return [r for r in self._bot.watched_guild.roles if r.name.lower() == role.name.lower()]

get_duplicates(*, case_sensitive=True)

Cherche et retourne tous les rôles qui sont dupliqués.

Returns:

Type Description
list[list[Role]]

La liste des listes de duplication.
list[list[Role]]

Chaque élément de la liste est une liste dont tous les
list[list[Role]]

éléments sont des rôles dupliqués.
Source code in etuutt_bot/services/role.py 
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
def get_duplicates(self, *, case_sensitive: bool = True) -> list[list[Role]]:
    """Cherche et retourne tous les rôles qui sont dupliqués.

    Returns:
        La liste des listes de duplication.
        Chaque élément de la liste est une liste dont tous les
        éléments sont des rôles dupliqués.
    """

    def sort_key(r):
        return r.name if case_sensitive else r.name.upper()

    roles = sorted(self._bot.watched_guild.roles, key=sort_key)

    res = []
    for _, group in itertools.groupby(roles, key=sort_key):
        values = list(group)
        if len(values) > 1:
            res.append(values)
    return res

merge(roles, *, merge_perms_strategy) async

Fusionne les rôles donnés, avec leurs permissions et leurs membres, en un seul.

Le rôle gardé est celui de la liste avec le plus de membres. Tous les membres de tous les rôles de la liste reçoivent le rôle gardé. Tous les autres rôles sont supprimés.

Warning

Cette fonction peut nécessiter beaucoup d'appels à l'API Discord (un pour chaque membre qui n'a pas déjà le rôle conservé, plus un pour chaque rôle supprimé, plus un pour éditer les permissions du rôle gardé). Utilisez-la avec parcimonie

Parameters:

Name Type Description Default
roles list[Role]

la liste des rôles à fusionner

 required
merge_perms_strategy MergeStrategy

la stratégie de fusion des permissions à utiliser

 required

Returns:

Type Description
Role

Le rôle résultant de la fusion.
Source code in etuutt_bot/services/role.py 
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
async def merge(self, roles: list[Role], *, merge_perms_strategy: MergeStrategy) -> Role:
    """Fusionne les rôles donnés, avec leurs permissions et leurs membres, en un seul.

    Le rôle gardé est celui de la liste avec le plus de membres.
    Tous les membres de tous les rôles de la liste reçoivent le rôle gardé.
    Tous les autres rôles sont supprimés.

    Warning:
        Cette fonction peut nécessiter beaucoup d'appels à l'API Discord
        (un pour chaque membre qui n'a pas déjà le rôle conservé,
        plus un pour chaque rôle supprimé,
        plus un pour éditer les permissions du rôle gardé).
        Utilisez-la avec parcimonie

    Args:
        roles: la liste des rôles à fusionner
        merge_perms_strategy: la stratégie de fusion des permissions à utiliser

    Returns:
        Le rôle résultant de la fusion.
    """
    # keep the role which has the most members,
    # in order to minimize the number of api calls when merging members
    to_keep = max(roles, key=lambda r: len(r.members))
    # set of members which must be assigned to the kept role
    members = {
        member for role in roles for member in role.members if to_keep not in member.roles
    }
    for member in members:
        await member.add_roles(to_keep)
    await to_keep.edit(
        permissions=self.combined_perms(roles, merge_strategy=merge_perms_strategy)
    )
    to_delete = [r for r in roles if r != to_keep]
    for role in to_delete:
        await role.delete(reason="Fusion de rôles dupliqués")
    return to_keep