pincer.objects.throttling

Complexity

Total Complexity

4

Size/Duplication

Total Lines	86
Duplicated Lines	0 %

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	ThrottleInterface.handle()	0	12	1
A	DefaultThrottleHandler.get_key_from_scope()	0	10	1
A	DefaultThrottleHandler.handle()	0	2	1
A	ThrottleInterface.__init__()	0	12	1

# Copyright Pincer 2021-Present

Missing module docstring

# Full MIT License can be found in `LICENSE` at the project root.
from abc import ABC, abstractmethod
from enum import Enum, auto
from typing import Dict, Any, Optional

from .context import Context
from ..utils.slidingwindow import SlidingWindow


class ThrottleScope(Enum):
    """
    On what the cooldown should be set/on what should the cooldown be
    set.

    :param GUILD:
        The cooldown is per guild.

    :param CHANNEL:
        The cooldown is per channel.

    :param USER:
        The cooldown is per user.

    :param GLOBAL:
        The cooldown is global.
    """
    GUILD = auto()
    CHANNEL = auto()
    USER = auto()
    GLOBAL = auto()


class ThrottleInterface(ABC):

Missing class docstring

    @abstractmethod
    def __init__(self, client, **kwargs):
        """
        Initializes a throttler.

        :param client:
            The current connected client, aka your bot.

        :param kwargs:
            Optional extra arguments.
        """
        self.client = client

    @abstractmethod
    async def handle(self, ctx: Context, **kwargs):
        """
        Handles a context. This method is executed before the command is.

        :param ctx:
            The context of the command.

        :param kwargs:
            The extra kwargs passed for the cooldown.
        """
        raise NotImplementedError


class DefaultThrottleHandler(ThrottleInterface, ABC):

Missing class docstring

    default_throttle_type = ThrottleScope.GLOBAL
    throttle: Dict[Any, SlidingWindow] = {}

    __throttle_scopes = {
        ThrottleScope.GLOBAL: None,
        ThrottleScope.GUILD: "guild.id",
        ThrottleScope.CHANNEL: "channel.id",
        ThrottleScope.USER: "author.id"
    }

    def get_key_from_scope(

This method could be written as a function/class method.

            self,
            ctx: Context,

The argument ctx seems to be unused.

            scope: ThrottleScope

The argument scope seems to be unused.

    ) -> Optional[int]:
        """
        Retrieve the the appropriate key from the context through the
        throttle scope.
        """
        ...

    async def handle(self, ctx: Context, **kwargs):
        ...