Add files using upload-large-folder tool

testbed/Cog-Creators__Red-DiscordBot/redbot/__init__.py

@@ -0,0 +1,376 @@
+import os as _os
+import re as _re
+import sys as _sys
+import warnings as _warnings
+from math import inf as _inf
+from typing import (
+    ClassVar as _ClassVar,
+    Dict as _Dict,
+    List as _List,
+    Optional as _Optional,
+    Pattern as _Pattern,
+    Tuple as _Tuple,
+    Union as _Union,
+)
+
+
+MIN_PYTHON_VERSION = (3, 8, 1)
+
+__all__ = [
+    "MIN_PYTHON_VERSION",
+    "__version__",
+    "version_info",
+    "VersionInfo",
+    "_update_event_loop_policy",
+]
+if _sys.version_info < MIN_PYTHON_VERSION:
+    print(
+        f"Python {'.'.join(map(str, MIN_PYTHON_VERSION))} is required to run Red, but you have "
+        f"{_sys.version}! Please update Python."
+    )
+    _sys.exit(78)
+
+
+class VersionInfo:
+    ALPHA = "alpha"
+    BETA = "beta"
+    RELEASE_CANDIDATE = "release candidate"
+    FINAL = "final"
+
+    _VERSION_STR_PATTERN: _ClassVar[_Pattern[str]] = _re.compile(
+        r"^"
+        r"(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<micro>0|[1-9]\d*)"
+        r"(?:(?P<releaselevel>a|b|rc)(?P<serial>0|[1-9]\d*))?"
+        r"(?:\.post(?P<post_release>0|[1-9]\d*))?"
+        r"(?:\.dev(?P<dev_release>0|[1-9]\d*))?"
+        r"(?:\+(?P<local_version>g[a-z0-9]+(?:\.dirty)?))?"
+        r"$",
+        flags=_re.IGNORECASE,
+    )
+    _RELEASE_LEVELS: _ClassVar[_List[str]] = [ALPHA, BETA, RELEASE_CANDIDATE, FINAL]
+    _SHORT_RELEASE_LEVELS: _ClassVar[_Dict[str, str]] = {
+        "a": ALPHA,
+        "b": BETA,
+        "rc": RELEASE_CANDIDATE,
+    }
+
+    def __init__(
+        self,
+        major: int,
+        minor: int,
+        micro: int,
+        releaselevel: str,
+        serial: _Optional[int] = None,
+        post_release: _Optional[int] = None,
+        dev_release: _Optional[int] = None,
+        local_version: _Optional[str] = None,
+    ) -> None:
+        self.major: int = major
+        self.minor: int = minor
+        self.micro: int = micro
+
+        if releaselevel not in self._RELEASE_LEVELS:
+            raise TypeError(f"'releaselevel' must be one of: {', '.join(self._RELEASE_LEVELS)}")
+
+        self.releaselevel: str = releaselevel
+        self.serial: _Optional[int] = serial
+        self.post_release: _Optional[int] = post_release
+        self.dev_release: _Optional[int] = dev_release
+        self.local_version: _Optional[str] = local_version
+
+    @property
+    def short_commit_hash(self) -> _Optional[str]:
+        if self.local_version is None:
+            return None
+        return self.local_version[1:].split(".", 1)[0]
+
+    @property
+    def dirty(self) -> bool:
+        return self.local_version is not None and self.local_version.endswith(".dirty")
+
+    @classmethod
+    def from_str(cls, version_str: str) -> "VersionInfo":
+        """Parse a string into a VersionInfo object.
+
+        Raises
+        ------
+        ValueError
+            If the version info string is invalid.
+
+        """
+        match = cls._VERSION_STR_PATTERN.match(version_str)
+        if not match:
+            raise ValueError(f"Invalid version string: {version_str}")
+
+        kwargs: _Dict[str, _Union[str, int]] = {}
+        for key in ("major", "minor", "micro"):
+            kwargs[key] = int(match[key])
+        releaselevel = match["releaselevel"]
+        if releaselevel is not None:
+            kwargs["releaselevel"] = cls._SHORT_RELEASE_LEVELS[releaselevel]
+        else:
+            kwargs["releaselevel"] = cls.FINAL
+        for key in ("serial", "post_release", "dev_release"):
+            if match[key] is not None:
+                kwargs[key] = int(match[key])
+        kwargs["local_version"] = match["local_version"]
+        return cls(**kwargs)
+
+    @classmethod
+    def from_json(
+        cls, data: _Union[_Dict[str, _Union[int, str]], _List[_Union[int, str]]]
+    ) -> "VersionInfo":
+        if isinstance(data, _List):
+            # For old versions, data was stored as a list:
+            # [MAJOR, MINOR, MICRO, RELEASELEVEL, SERIAL]
+            return cls(*data)
+        else:
+            return cls(**data)
+
+    def to_json(self) -> _Dict[str, _Union[int, str]]:
+        return {
+            "major": self.major,
+            "minor": self.minor,
+            "micro": self.micro,
+            "releaselevel": self.releaselevel,
+            "serial": self.serial,
+            "post_release": self.post_release,
+            "dev_release": self.dev_release,
+            "local_version": self.local_version,
+        }
+
+    def _generate_comparison_tuples(
+        self, other: "VersionInfo"
+    ) -> _List[
+        _Tuple[int, int, int, int, _Union[int, float], _Union[int, float], _Union[int, float], int]
+    ]:
+        tups: _List[
+            _Tuple[
+                int, int, int, int, _Union[int, float], _Union[int, float], _Union[int, float], int
+            ]
+        ] = []
+        for obj in (self, other):
+            if (
+                obj.releaselevel == obj.FINAL
+                and obj.post_release is None
+                and obj.dev_release is not None
+            ):
+                releaselevel = -1
+            else:
+                releaselevel = obj._RELEASE_LEVELS.index(obj.releaselevel)
+            tups.append(
+                (
+                    obj.major,
+                    obj.minor,
+                    obj.micro,
+                    releaselevel,
+                    obj.serial if obj.serial is not None else _inf,
+                    obj.post_release if obj.post_release is not None else -_inf,
+                    obj.dev_release if obj.dev_release is not None else _inf,
+                    int(obj.dirty),
+                )
+            )
+        return tups
+
+    def __lt__(self, other: "VersionInfo") -> bool:
+        tups = self._generate_comparison_tuples(other)
+        return tups[0] < tups[1]
+
+    def __eq__(self, other: "VersionInfo") -> bool:
+        tups = self._generate_comparison_tuples(other)
+        return tups[0] == tups[1]
+
+    def __le__(self, other: "VersionInfo") -> bool:
+        tups = self._generate_comparison_tuples(other)
+        return tups[0] <= tups[1]
+
+    def __str__(self) -> str:
+        ret = f"{self.major}.{self.minor}.{self.micro}"
+        if self.releaselevel != self.FINAL:
+            short = next(
+                k for k, v in self._SHORT_RELEASE_LEVELS.items() if v == self.releaselevel
+            )
+            ret += f"{short}{self.serial}"
+        if self.post_release is not None:
+            ret += f".post{self.post_release}"
+        if self.dev_release is not None:
+            ret += f".dev{self.dev_release}"
+        if self.local_version is not None:
+            ret += f"+{self.local_version}"
+        return ret
+
+    def __repr__(self) -> str:
+        return (
+            "VersionInfo(major={major}, minor={minor}, micro={micro}, "
+            "releaselevel={releaselevel}, serial={serial}, post={post_release}, "
+            "dev={dev_release}, local={local_version})"
+        ).format(**self.to_json())
+
+    @classmethod
+    def _get_version(cls, *, ignore_installed: bool = False) -> _Tuple[str, "VersionInfo"]:
+        if not _VERSION.endswith(".dev1"):
+            return _VERSION, cls.from_str(_VERSION)
+
+        project_root = _os.path.abspath(_os.path.dirname(_os.path.dirname(__file__)))
+
+        methods = [
+            cls._get_version_from_git_repo,
+        ]
+        # `ignore_installed` is `True` when building with setuptools.
+        if ignore_installed:
+            methods.append(cls._get_version_from_sdist_pkg_info)
+            methods.append(cls._get_version_from_git_archive)
+        else:
+            methods.append(cls._get_version_from_package_metadata)
+        exceptions = []
+        for method in methods:
+            try:
+                version = method(project_root)
+            except Exception as exc:
+                exceptions.append(exc)
+            else:
+                break
+        else:
+            import traceback
+
+            for exc in exceptions:
+                traceback.print_exception(None, exc, exc.__traceback__)
+                exc.__traceback__ = None
+
+            version = _VERSION
+
+        return version, cls.from_str(version)
+
+    @classmethod
+    def _get_version_from_git_repo(cls, project_root: str) -> str:
+        # we only want to do this for editable installs
+        if not _os.path.exists(_os.path.join(project_root, ".git")):
+            raise RuntimeError("not a git repository")
+
+        import subprocess
+
+        output = subprocess.check_output(
+            ("git", "describe", "--tags", "--long", "--dirty"),
+            stderr=subprocess.DEVNULL,
+            cwd=project_root,
+        )
+        _, count, commit, *dirty = output.decode("utf-8").strip().split("-", 3)
+        dirty_suffix = f".{dirty[0]}" if dirty else ""
+        return f"{_VERSION[:-1]}{count}+{commit}{dirty_suffix}"
+
+    @classmethod
+    def _get_version_from_git_archive(cls, project_root: str) -> str:
+        with open(_os.path.join(project_root, ".git_archive_info.txt"), encoding="utf-8") as fp:
+            commit, describe_name = fp.read().splitlines()
+            if not describe_name:
+                raise RuntimeError("git archive's describe didn't output anything")
+            if "%(describe" in describe_name:
+                # either git-archive was generated with Git < 2.35 or this is not a git-archive
+                raise RuntimeError("git archive did not support describe output")
+            _, _, suffix = describe_name.partition("-")
+            if suffix:
+                count, _, _ = suffix.partition("-")
+            else:
+                count = "0"
+            return f"{_VERSION[:-1]}{count}+g{commit}"
+
+    @classmethod
+    def _get_version_from_sdist_pkg_info(cls, project_root: str) -> str:
+        pkg_info_path = _os.path.join(project_root, "PKG-INFO")
+        if not _os.path.exists(pkg_info_path):
+            raise RuntimeError("not an sdist")
+
+        import email
+
+        with open(pkg_info_path, encoding="utf-8") as fp:
+            return email.message_from_file(fp)["Version"]
+
+    @classmethod
+    def _get_version_from_package_metadata(cls, project_root: str) -> str:
+        from importlib.metadata import version
+
+        return version("Red-DiscordBot")
+
+
+def _update_event_loop_policy():
+    if _sys.implementation.name == "cpython":
+        # Let's not force this dependency, uvloop is much faster on cpython
+        try:
+            import uvloop
+        except ImportError:
+            pass
+        else:
+            import asyncio
+
+            asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
+
+
+def _ensure_no_colorama():
+    # a hacky way to ensure that nothing initialises colorama
+    # if we're not running with legacy Windows command line mode
+    from rich.console import detect_legacy_windows
+
+    if not detect_legacy_windows():
+        try:
+            import colorama
+            import colorama.initialise
+        except ModuleNotFoundError:
+            # colorama is not Red's primary dependency so it might not be present
+            return
+
+        colorama.deinit()
+
+        def _colorama_wrap_stream(stream, *args, **kwargs):
+            return stream
+
+        colorama.wrap_stream = _colorama_wrap_stream
+        colorama.initialise.wrap_stream = _colorama_wrap_stream
+
+
+def _update_logger_class():
+    from red_commons.logging import maybe_update_logger_class
+
+    maybe_update_logger_class()
+
+
+def _early_init():
+    # This function replaces logger so we preferably (though not necessarily) want that to happen
+    # before importing anything that calls `logging.getLogger()`, i.e. `asyncio`.
+    _update_logger_class()
+    _update_event_loop_policy()
+    _ensure_no_colorama()
+
+
+# This is bumped automatically by release workflow (`.github/workflows/scripts/bump_version.py`)
+_VERSION = "3.5.0.dev1"
+
+__version__, version_info = VersionInfo._get_version()
+
+# Show DeprecationWarning
+_warnings.filterwarnings("default", category=DeprecationWarning)
+
+# TODO: Rearrange cli flags here and use the value instead of this monkeypatch
+if not any(_re.match("^-(-debug|d+|-verbose|v+)$", i) for i in _sys.argv):
+    # DEP-WARN
+    # Individual warnings - tracked in https://github.com/Cog-Creators/Red-DiscordBot/issues/3529
+    # DeprecationWarning: an integer is required (got type float).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.
+    _warnings.filterwarnings("ignore", category=DeprecationWarning, module="importlib", lineno=219)
+    # DeprecationWarning: The loop argument is deprecated since Python 3.8, and scheduled for removal in Python 3.10
+    #   stdin, stdout, stderr = await tasks.gather(stdin, stdout, stderr,
+    # this is a bug in CPython
+    _warnings.filterwarnings(
+        "ignore",
+        category=DeprecationWarning,
+        module="asyncio",
+        message="The loop argument is deprecated since Python 3.8",
+    )
+    # DEP-WARN - d.py currently uses audioop module, Danny is aware of the deprecation
+    #
+    # DeprecationWarning: 'audioop' is deprecated and slated for removal in Python 3.13
+    #   import audioop
+    _warnings.filterwarnings(
+        "ignore",
+        category=DeprecationWarning,
+        module="discord",
+        message="'audioop' is deprecated and slated for removal",
+    )

testbed/Cog-Creators__Red-DiscordBot/redbot/__main__.py

@@ -0,0 +1,554 @@
+from redbot import _early_init
+
+# this needs to be called as early as possible
+_early_init()
+
+import asyncio
+import functools
+import getpass
+import json
+import logging
+import os
+import pip
+import platform
+import shutil
+import signal
+import sys
+from argparse import Namespace
+from copy import deepcopy
+from pathlib import Path
+from typing import Any, Awaitable, Callable, NoReturn, Union
+
+import discord
+import rich
+
+import redbot.logging
+from redbot import __version__
+from redbot.core.bot import Red, ExitCodes, _NoOwnerSet
+from redbot.core.cli import interactive_config, confirm, parse_cli_flags
+from redbot.setup import get_data_dir, get_name, save_config
+from redbot.core import data_manager, drivers
+from redbot.core._debuginfo import DebugInfo
+from redbot.core._sharedlibdeprecation import SharedLibImportWarner
+
+
+log = logging.getLogger("red.main")
+
+#
+#               Red - Discord Bot v3
+#
+#         Made by Twentysix, improved by many
+#
+
+
+def _get_instance_names():
+    with data_manager.config_file.open(encoding="utf-8") as fs:
+        data = json.load(fs)
+    return sorted(data.keys())
+
+
+def list_instances():
+    if not data_manager.config_file.exists():
+        print(
+            "No instances have been configured! Configure one "
+            "using `redbot-setup` before trying to run the bot!"
+        )
+        sys.exit(ExitCodes.CONFIGURATION_ERROR)
+    else:
+        text = "Configured Instances:\n\n"
+        for instance_name in _get_instance_names():
+            text += "{}\n".format(instance_name)
+        print(text)
+        sys.exit(ExitCodes.SHUTDOWN)
+
+
+async def debug_info(*args: Any) -> None:
+    """Shows debug information useful for debugging."""
+    print(await DebugInfo().get_text())
+
+
+async def edit_instance(red, cli_flags):
+    no_prompt = cli_flags.no_prompt
+    token = cli_flags.token
+    owner = cli_flags.owner
+    prefix = cli_flags.prefix
+    old_name = cli_flags.instance_name
+    new_name = cli_flags.edit_instance_name
+    data_path = cli_flags.edit_data_path
+    copy_data = cli_flags.copy_data
+    confirm_overwrite = cli_flags.overwrite_existing_instance
+
+    if data_path is None and copy_data:
+        print("--copy-data can't be used without --edit-data-path argument")
+        sys.exit(ExitCodes.INVALID_CLI_USAGE)
+    if new_name is None and confirm_overwrite:
+        print("--overwrite-existing-instance can't be used without --edit-instance-name argument")
+        sys.exit(ExitCodes.INVALID_CLI_USAGE)
+    if (
+        no_prompt
+        and all(to_change is None for to_change in (token, owner, new_name, data_path))
+        and not prefix
+    ):
+        print(
+            "No arguments to edit were provided."
+            " Available arguments (check help for more information):"
+            " --edit-instance-name, --edit-data-path, --copy-data, --owner, --token, --prefix"
+        )
+        sys.exit(ExitCodes.INVALID_CLI_USAGE)
+
+    await _edit_token(red, token, no_prompt)
+    await _edit_prefix(red, prefix, no_prompt)
+    await _edit_owner(red, owner, no_prompt)
+
+    data = deepcopy(data_manager.basic_config)
+    name = _edit_instance_name(old_name, new_name, confirm_overwrite, no_prompt)
+    _edit_data_path(data, name, data_path, copy_data, no_prompt)
+
+    save_config(name, data)
+    if old_name != name:
+        save_config(old_name, {}, remove=True)
+
+
+async def _edit_token(red, token, no_prompt):
+    if token:
+        if not len(token) >= 50:
+            print(
+                "The provided token doesn't look a valid Discord bot token."
+                " Instance's token will remain unchanged.\n"
+            )
+            return
+        await red._config.token.set(token)
+    elif not no_prompt and confirm("Would you like to change instance's token?", default=False):
+        await interactive_config(red, False, True, print_header=False)
+        print("Token updated.\n")
+
+
+async def _edit_prefix(red, prefix, no_prompt):
+    if prefix:
+        prefixes = sorted(prefix, reverse=True)
+        await red._config.prefix.set(prefixes)
+    elif not no_prompt and confirm("Would you like to change instance's prefixes?", default=False):
+        print(
+            "Enter the prefixes, separated by a space (please note "
+            "that prefixes containing a space will need to be added with [p]set prefix)"
+        )
+        while True:
+            prefixes = input("> ").strip().split()
+            if not prefixes:
+                print("You need to pass at least one prefix!")
+                continue
+            if any(prefix.startswith("/") for prefix in prefixes):
+                print(
+                    "Prefixes cannot start with '/', as it conflicts with Discord's slash commands."
+                )
+                continue
+            prefixes = sorted(prefixes, reverse=True)
+            await red._config.prefix.set(prefixes)
+            print("Prefixes updated.\n")
+            break
+
+
+async def _edit_owner(red, owner, no_prompt):
+    if owner:
+        if not (15 <= len(str(owner)) <= 20):
+            print(
+                "The provided owner id doesn't look like a valid Discord user id."
+                " Instance's owner will remain unchanged."
+            )
+            return
+        await red._config.owner.set(owner)
+    elif not no_prompt and confirm("Would you like to change instance's owner?", default=False):
+        print(
+            "Remember:\n"
+            "ONLY the person who is hosting Red should be owner."
+            " This has SERIOUS security implications."
+            " The owner can access any data that is present on the host system.\n"
+        )
+        if confirm("Are you sure you want to change instance's owner?", default=False):
+            print("Please enter a Discord user id for new owner:")
+            while True:
+                owner_id = input("> ").strip()
+                if not (15 <= len(owner_id) <= 20 and owner_id.isdecimal()):
+                    print("That doesn't look like a valid Discord user id.")
+                    continue
+                owner_id = int(owner_id)
+                await red._config.owner.set(owner_id)
+                print("Owner updated.")
+                break
+        else:
+            print("Instance's owner will remain unchanged.")
+        print()
+
+
+def _edit_instance_name(old_name, new_name, confirm_overwrite, no_prompt):
+    if new_name:
+        name = new_name
+        if name in _get_instance_names() and not confirm_overwrite:
+            name = old_name
+            print(
+                "An instance with this name already exists.\n"
+                "If you want to remove the existing instance and replace it with this one,"
+                " run this command with --overwrite-existing-instance flag."
+            )
+    elif not no_prompt and confirm("Would you like to change the instance name?", default=False):
+        name = get_name("")
+        if name in _get_instance_names():
+            print(
+                "WARNING: An instance already exists with this name. "
+                "Continuing will overwrite the existing instance config."
+            )
+            if not confirm(
+                "Are you absolutely certain you want to continue with this instance name?",
+                default=False,
+            ):
+                print("Instance name will remain unchanged.")
+                name = old_name
+            else:
+                print("Instance name updated.")
+        else:
+            print("Instance name updated.")
+        print()
+    else:
+        name = old_name
+    return name
+
+
+def _edit_data_path(data, instance_name, data_path, copy_data, no_prompt):
+    # This modifies the passed dict.
+    if data_path:
+        new_path = Path(data_path)
+        try:
+            exists = new_path.exists()
+        except OSError:
+            print(
+                "We were unable to check your chosen directory."
+                " Provided path may contain an invalid character."
+                " Data location will remain unchanged."
+            )
+
+        if not exists:
+            try:
+                new_path.mkdir(parents=True, exist_ok=True)
+            except OSError:
+                print(
+                    "We were unable to create your chosen directory."
+                    " Data location will remain unchanged."
+                )
+        data["DATA_PATH"] = data_path
+        if copy_data and not _copy_data(data):
+            print("Can't copy data to non-empty location. Data location will remain unchanged.")
+            data["DATA_PATH"] = data_manager.basic_config["DATA_PATH"]
+    elif not no_prompt and confirm("Would you like to change the data location?", default=False):
+        data["DATA_PATH"] = get_data_dir(
+            instance_name=instance_name, data_path=None, interactive=True
+        )
+        if confirm("Do you want to copy the data from old location?", default=True):
+            if not _copy_data(data):
+                print("Can't copy the data to non-empty location.")
+                if not confirm("Do you still want to use the new data location?"):
+                    data["DATA_PATH"] = data_manager.basic_config["DATA_PATH"]
+                    print("Data location will remain unchanged.")
+                    return
+            print("Old data has been copied over to the new location.")
+        print("Data location updated.")
+
+
+def _copy_data(data):
+    if Path(data["DATA_PATH"]).exists():
+        if any(os.scandir(data["DATA_PATH"])):
+            return False
+        else:
+            # this is needed because copytree doesn't work when destination folder exists
+            # Python 3.8 has `dirs_exist_ok` option for that
+            os.rmdir(data["DATA_PATH"])
+    shutil.copytree(data_manager.basic_config["DATA_PATH"], data["DATA_PATH"])
+    return True
+
+
+def early_exit_runner(
+    cli_flags: Namespace,
+    func: Union[Callable[[], Awaitable[Any]], Callable[[Red, Namespace], Awaitable[Any]]],
+) -> None:
+    """
+    This one exists to not log all the things like it's a full run of the bot.
+    """
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    try:
+        if not cli_flags.instance_name:
+            loop.run_until_complete(func())
+            return
+
+        data_manager.load_basic_configuration(cli_flags.instance_name)
+        red = Red(cli_flags=cli_flags, description="Red V3", dm_help=None)
+        driver_cls = drivers.get_driver_class()
+        loop.run_until_complete(driver_cls.initialize(**data_manager.storage_details()))
+        loop.run_until_complete(func(red, cli_flags))
+        loop.run_until_complete(driver_cls.teardown())
+    except (KeyboardInterrupt, EOFError):
+        print("Aborted!")
+    finally:
+        loop.run_until_complete(asyncio.sleep(1))
+        asyncio.set_event_loop(None)
+        loop.stop()
+        loop.close()
+
+
+async def run_bot(red: Red, cli_flags: Namespace) -> None:
+    """
+    This runs the bot.
+
+    Any shutdown which is a result of not being able to log in needs to raise
+    a SystemExit exception.
+
+    If the bot starts normally, the bot should be left to handle the exit case.
+    It will raise SystemExit in a task, which will reach the event loop and
+    interrupt running forever, then trigger our cleanup process, and does not
+    need additional handling in this function.
+    """
+
+    driver_cls = drivers.get_driver_class()
+
+    await driver_cls.initialize(**data_manager.storage_details())
+
+    redbot.logging.init_logging(
+        level=cli_flags.logging_level,
+        location=data_manager.core_data_path() / "logs",
+        cli_flags=cli_flags,
+    )
+
+    log.debug("====Basic Config====")
+    log.debug("Data Path: %s", data_manager._base_data_path())
+    log.debug("Storage Type: %s", data_manager.storage_type())
+
+    # lib folder has to be in sys.path before trying to load any 3rd-party cog (GH-3061)
+    # We might want to change handling of requirements in Downloader at later date
+    LIB_PATH = data_manager.cog_data_path(raw_name="Downloader") / "lib"
+    LIB_PATH.mkdir(parents=True, exist_ok=True)
+    if str(LIB_PATH) not in sys.path:
+        sys.path.append(str(LIB_PATH))
+
+        # "It's important to note that the global `working_set` object is initialized from
+        # `sys.path` when `pkg_resources` is first imported, but is only updated if you do
+        # all future `sys.path` manipulation via `pkg_resources` APIs. If you manually modify
+        # `sys.path`, you must invoke the appropriate methods on the `working_set` instance
+        # to keep it in sync."
+        # Source: https://setuptools.readthedocs.io/en/latest/pkg_resources.html#workingset-objects
+        pkg_resources = sys.modules.get("pkg_resources")
+        if pkg_resources is not None:
+            pkg_resources.working_set.add_entry(str(LIB_PATH))
+    sys.meta_path.insert(0, SharedLibImportWarner())
+
+    if cli_flags.token:
+        token = cli_flags.token
+    else:
+        token = os.environ.get("RED_TOKEN", None)
+        if not token:
+            token = await red._config.token()
+
+    prefix = cli_flags.prefix or await red._config.prefix()
+
+    if not (token and prefix):
+        if cli_flags.no_prompt is False:
+            new_token = await interactive_config(
+                red, token_set=bool(token), prefix_set=bool(prefix)
+            )
+            if new_token:
+                token = new_token
+        else:
+            log.critical("Token and prefix must be set in order to login.")
+            sys.exit(ExitCodes.CONFIGURATION_ERROR)
+
+    if cli_flags.dry_run:
+        sys.exit(ExitCodes.SHUTDOWN)
+    try:
+        # `async with red:` is unnecessary here because we call red.close() in shutdown handler
+        await red.start(token)
+    except discord.LoginFailure:
+        log.critical("This token doesn't seem to be valid.")
+        db_token = await red._config.token()
+        if db_token and not cli_flags.no_prompt:
+            if confirm("\nDo you want to reset the token?"):
+                await red._config.token.set("")
+                print("Token has been reset.")
+                sys.exit(ExitCodes.SHUTDOWN)
+        sys.exit(ExitCodes.CONFIGURATION_ERROR)
+    except discord.PrivilegedIntentsRequired:
+        console = rich.get_console()
+        console.print(
+            "Red requires all Privileged Intents to be enabled.\n"
+            "You can find out how to enable Privileged Intents with this guide:\n"
+            "https://docs.discord.red/en/stable/bot_application_guide.html#enabling-privileged-intents",
+            style="red",
+        )
+        sys.exit(ExitCodes.CONFIGURATION_ERROR)
+    except _NoOwnerSet:
+        print(
+            "Bot doesn't have any owner set!\n"
+            "This can happen when your bot's application is owned by team"
+            " as team members are NOT owners by default.\n\n"
+            "Remember:\n"
+            "ONLY the person who is hosting Red should be owner."
+            " This has SERIOUS security implications."
+            " The owner can access any data that is present on the host system.\n"
+            "With that out of the way, depending on who you want to be considered as owner,"
+            " you can:\n"
+            "a) pass --team-members-are-owners when launching Red"
+            " - in this case Red will treat all members of the bot application's team as owners\n"
+            f"b) set owner manually with `redbot --edit {cli_flags.instance_name}`\n"
+            "c) pass owner ID(s) when launching Red with --owner"
+            " (and --co-owner if you need more than one) flag\n"
+        )
+        sys.exit(ExitCodes.CONFIGURATION_ERROR)
+
+    return None
+
+
+def handle_early_exit_flags(cli_flags: Namespace):
+    if cli_flags.list_instances:
+        list_instances()
+    elif cli_flags.version:
+        print("Red V3")
+        print("Current Version: {}".format(__version__))
+        sys.exit(ExitCodes.SHUTDOWN)
+    elif cli_flags.debuginfo:
+        early_exit_runner(cli_flags, debug_info)
+    elif not cli_flags.instance_name and (not cli_flags.no_instance or cli_flags.edit):
+        print("Error: No instance name was provided!")
+        sys.exit(ExitCodes.INVALID_CLI_USAGE)
+
+
+async def shutdown_handler(red, signal_type=None, exit_code=None):
+    if signal_type:
+        log.info("%s received. Quitting...", signal_type)
+        # Do not collapse the below line into other logic
+        # We need to renter this function
+        # after it interrupts the event loop.
+        sys.exit(ExitCodes.SHUTDOWN)
+    elif exit_code is None:
+        log.info("Shutting down from unhandled exception")
+        red._shutdown_mode = ExitCodes.CRITICAL
+
+    if exit_code is not None:
+        red._shutdown_mode = exit_code
+
+    try:
+        if not red.is_closed():
+            await red.close()
+    finally:
+        # Then cancels all outstanding tasks other than ourselves
+        pending = [t for t in asyncio.all_tasks() if t is not asyncio.current_task()]
+        [task.cancel() for task in pending]
+        await asyncio.gather(*pending, return_exceptions=True)
+
+
+def global_exception_handler(red, loop, context):
+    """
+    Logs unhandled exceptions in other tasks
+    """
+    exc = context.get("exception")
+    # These will get handled later when it *also* kills loop.run_forever
+    if exc is not None and isinstance(exc, (KeyboardInterrupt, SystemExit)):
+        return
+    loop.default_exception_handler(context)
+
+
+def red_exception_handler(red, red_task: asyncio.Future):
+    """
+    This is set as a done callback for Red
+
+    must be used with functools.partial
+
+    If the main bot.run dies for some reason,
+    we don't want to swallow the exception and hang.
+    """
+    try:
+        red_task.result()
+    except (SystemExit, KeyboardInterrupt, asyncio.CancelledError):
+        pass  # Handled by the global_exception_handler, or cancellation
+    except Exception as exc:
+        log.critical("The main bot task didn't handle an exception and has crashed", exc_info=exc)
+        log.warning("Attempting to die as gracefully as possible...")
+        asyncio.create_task(shutdown_handler(red))
+
+
+def main():
+    red = None  # Error handling for users misusing the bot
+    cli_flags = parse_cli_flags(sys.argv[1:])
+    handle_early_exit_flags(cli_flags)
+    if cli_flags.edit:
+        early_exit_runner(cli_flags, edit_instance)
+        return
+    try:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+
+        if cli_flags.no_instance:
+            print(
+                "\033[1m"
+                "Warning: The data will be placed in a temporary folder and removed on next system "
+                "reboot."
+                "\033[0m"
+            )
+            cli_flags.instance_name = "temporary_red"
+            data_manager.create_temp_config()
+
+        data_manager.load_basic_configuration(cli_flags.instance_name)
+
+        red = Red(cli_flags=cli_flags, description="Red V3", dm_help=None)
+
+        if os.name != "nt":
+            # None of this works on windows.
+            # At least it's not a redundant handler...
+            signals = (signal.SIGHUP, signal.SIGTERM, signal.SIGINT)
+            for s in signals:
+                loop.add_signal_handler(
+                    s, lambda s=s: asyncio.create_task(shutdown_handler(red, s))
+                )
+
+        exc_handler = functools.partial(global_exception_handler, red)
+        loop.set_exception_handler(exc_handler)
+        # We actually can't (just) use asyncio.run here
+        # We probably could if we didn't support windows, but we might run into
+        # a scenario where this isn't true if anyone works on RPC more in the future
+        fut = loop.create_task(run_bot(red, cli_flags))
+        r_exc_handler = functools.partial(red_exception_handler, red)
+        fut.add_done_callback(r_exc_handler)
+        loop.run_forever()
+    except KeyboardInterrupt:
+        # We still have to catch this here too. (*joy*)
+        log.warning("Please do not use Ctrl+C to Shutdown Red! (attempting to die gracefully...)")
+        log.error("Received KeyboardInterrupt, treating as interrupt")
+        if red is not None:
+            loop.run_until_complete(shutdown_handler(red, signal.SIGINT))
+    except SystemExit as exc:
+        # We also have to catch this one here. Basically any exception which normally
+        # Kills the python interpreter (Base Exceptions minus asyncio.cancelled)
+        # We need to do something with prior to having the loop close
+        log.info("Shutting down with exit code: %s", exc.code)
+        if red is not None:
+            loop.run_until_complete(shutdown_handler(red, None, exc.code))
+    except Exception as exc:  # Non standard case.
+        log.exception("Unexpected exception (%s): ", type(exc), exc_info=exc)
+        if red is not None:
+            loop.run_until_complete(shutdown_handler(red, None, ExitCodes.CRITICAL))
+    finally:
+        # Allows transports to close properly, and prevent new ones from being opened.
+        # Transports may still not be closed correctly on windows, see below
+        loop.run_until_complete(loop.shutdown_asyncgens())
+        # *we* aren't cleaning up more here, but it prevents
+        # a runtime error at the event loop on windows
+        # with resources which require longer to clean up.
+        # With other event loops, a failure to cleanup prior to here
+        # results in a resource warning instead
+        log.info("Please wait, cleaning up a bit more")
+        loop.run_until_complete(asyncio.sleep(2))
+        asyncio.set_event_loop(None)
+        loop.stop()
+        loop.close()
+    exit_code = red._shutdown_mode if red is not None else ExitCodes.CRITICAL
+    sys.exit(exit_code)
+
+
+if __name__ == "__main__":
+    main()

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/audio/__init__.py

@@ -0,0 +1,9 @@
+from redbot.core.bot import Red
+
+from .core import Audio
+
+
+async def setup(bot: Red) -> None:
+    cog = Audio(bot)
+    await bot.add_cog(cog)
+    cog.start_up_task()

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/audio/errors.py

@@ -0,0 +1,162 @@
+from pathlib import Path
+
+import aiohttp
+
+from redbot.core.i18n import Translator
+
+_ = Translator("Audio", Path(__file__))
+
+
+class AudioError(Exception):
+    """Base exception for errors in the Audio cog."""
+
+
+class ManagedLavalinkNodeException(AudioError):
+    """Base Exception for Managed Lavalink Node Exceptions"""
+
+
+class NodeUnhealthy(ManagedLavalinkNodeException):
+    """Exception Raised when the node health checks fail"""
+
+
+class InvalidArchitectureException(ManagedLavalinkNodeException):
+    """Error thrown when the Managed Lavalink node is started on an invalid arch."""
+
+
+class ManagedLavalinkAlreadyRunningException(ManagedLavalinkNodeException):
+    """Exception thrown when a managed Lavalink node is already running"""
+
+
+class ManagedLavalinkStartFailure(ManagedLavalinkNodeException):
+    """Exception thrown when a managed Lavalink node fails to start"""
+
+
+class ManagedLavalinkPreviouslyShutdownException(ManagedLavalinkNodeException):
+    """Exception thrown when a managed Lavalink node already has been shutdown"""
+
+
+class EarlyExitException(ManagedLavalinkNodeException):
+    """some placeholder text I cannot be bothered to add a meaning message atm"""
+
+
+class UnsupportedJavaException(ManagedLavalinkNodeException):
+    """Exception thrown when a managed Lavalink node doesn't have a supported Java"""
+
+
+class UnexpectedJavaResponseException(ManagedLavalinkNodeException):
+    """Exception thrown when Java returns an unexpected response"""
+
+
+class NoProcessFound(ManagedLavalinkNodeException):
+    """Exception thrown when the managed node process is not found"""
+
+
+class LavalinkDownloadFailed(ManagedLavalinkNodeException, RuntimeError):
+    """Downloading the Lavalink jar failed.
+
+    Attributes
+    ----------
+    response : aiohttp.ClientResponse
+        The response from the server to the failed GET request.
+    should_retry : bool
+        Whether or not the Audio cog should retry downloading the jar.
+    """
+
+    def __init__(self, *args, response: aiohttp.ClientResponse, should_retry: bool = False):
+        super().__init__(*args)
+        self.response = response
+        self.should_retry = should_retry
+
+    def __repr__(self) -> str:
+        str_args = [*map(str, self.args), self._response_repr()]
+        return f"LavalinkDownloadFailed({', '.join(str_args)}"
+
+    def __str__(self) -> str:
+        return f"{super().__str__()} {self._response_repr()}"
+
+    def _response_repr(self) -> str:
+        return f"[{self.response.status} {self.response.reason}]"
+
+
+class QueryUnauthorized(AudioError):
+    """Provided an unauthorized query to audio."""
+
+    def __init__(self, message, *args):
+        self.message = message
+        super().__init__(*args)
+
+
+class TrackEnqueueError(AudioError):
+    """Unable to play track."""
+
+
+class PlayListError(AudioError):
+    """Base exception for errors related to playlists."""
+
+
+class InvalidPlaylistScope(PlayListError):
+    """Provided playlist scope is not valid."""
+
+
+class MissingGuild(PlayListError):
+    """Trying to access the Guild scope without a guild."""
+
+
+class MissingAuthor(PlayListError):
+    """Trying to access the User scope without an user id."""
+
+
+class TooManyMatches(PlayListError):
+    """Too many playlist match user input."""
+
+
+class NoMatchesFound(PlayListError):
+    """No entries found for this input."""
+
+
+class NotAllowed(PlayListError):
+    """Too many playlist match user input."""
+
+
+class ApiError(AudioError):
+    """Base exception for API errors in the Audio cog."""
+
+
+class SpotifyApiError(ApiError):
+    """Base exception for Spotify API errors."""
+
+
+class SpotifyFetchError(SpotifyApiError):
+    """Fetching Spotify data failed."""
+
+    def __init__(self, message, *args):
+        self.message = message
+        super().__init__(*args)
+
+
+class YouTubeApiError(ApiError):
+    """Base exception for YouTube Data API errors."""
+
+    def __init__(self, message, *args):
+        self.message = message
+        super().__init__(*args)
+
+
+class DatabaseError(AudioError):
+    """Base exception for database errors in the Audio cog."""
+
+
+class InvalidTableError(DatabaseError):
+    """Provided table to query is not a valid table."""
+
+
+class LocalTrackError(AudioError):
+    """Base exception for local track errors."""
+
+
+class InvalidLocalTrack(LocalTrackError):
+    """Base exception for local track errors."""
+
+
+class InvalidLocalTrackFolder(LocalTrackError):
+    """Base exception for local track errors."""

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/audio/locales/vi-VN.po

@@ -0,0 +1,76 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-02-11 12:29+0000\n"
+"Last-Translator: \n"
+"Language-Team: Vietnamese\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: vi\n"
+"X-Crowdin-File-ID: 51\n"
+"Language: vi_VN\n"
+
+#: redbot/cogs/audio/converters.py:35
+msgid "\n"
+"Scope must be a valid version of one of the following:\n"
+"​ ​ ​ ​ Global\n"
+"​ ​ ​ ​ Guild\n"
+"​ ​ ​ ​ User\n"
+msgstr ""
+
+#: redbot/cogs/audio/converters.py:43
+msgid "\n"
+"Author must be a valid version of one of the following:\n"
+"​ ​ ​ ​ User ID\n"
+"​ ​ ​ ​ User Mention\n"
+"​ ​ ​ ​ User Name#123\n"
+msgstr ""
+
+#: redbot/cogs/audio/converters.py:51
+msgid "\n"
+"Guild must be a valid version of one of the following:\n"
+"​ ​ ​ ​ Guild ID\n"
+"​ ​ ​ ​ Exact guild name\n"
+msgstr ""
+
+#: redbot/cogs/audio/converters.py:87
+msgid "\"{arg}\" was not found. It must be the ID or complete name of a server which the bot can see."
+msgstr ""
+
+#: redbot/cogs/audio/converters.py:96 redbot/cogs/audio/converters.py:136
+msgid "\"{arg}\" does not refer to a unique server. Please use the ID for the server you're trying to specify."
+msgstr ""
+
+#: redbot/cogs/audio/converters.py:127
+msgid "\"{arg}\" was not found. It must be the ID or name or mention a user which the bot can see."
+msgstr ""
+
+#: redbot/cogs/audio/converters.py:176
+msgid "Could not match '{}' to a playlist."
+msgstr ""
+
+#: redbot/cogs/audio/converters.py:241 redbot/cogs/audio/converters.py:263
+#: redbot/cogs/audio/converters.py:283 redbot/cogs/audio/converters.py:368
+#: redbot/cogs/audio/converters.py:380 redbot/cogs/audio/converters.py:405
+#: redbot/cogs/audio/converters.py:431 redbot/cogs/audio/converters.py:453
+#: redbot/cogs/audio/converters.py:480
+msgid "Nothing"
+msgstr ""
+
+#: redbot/cogs/audio/converters.py:261
+msgid "You cannot use `--guild`"
+msgstr ""
+
+#: redbot/cogs/audio/converters.py:402
+msgid "You cannot use `--to-server`"
+msgstr ""
+
+#: redbot/cogs/audio/converters.py:428
+msgid "You cannot use `--from-server`"
+msgstr ""
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/audio/manager.py

@@ -0,0 +1,702 @@
+import asyncio
+import asyncio.subprocess  # disables for # https://github.com/PyCQA/pylint/issues/1469
+import contextlib
+import itertools
+import json
+import pathlib
+import platform
+import re
+import shlex
+import shutil
+import tempfile
+from typing import ClassVar, Final, List, Optional, Pattern, Tuple, Union, TYPE_CHECKING
+
+import aiohttp
+import lavalink
+import rich.progress
+import yaml
+from discord.backoff import ExponentialBackoff
+from red_commons.logging import getLogger
+
+from redbot.core import data_manager, Config
+from redbot.core.i18n import Translator
+
+from .errors import (
+    LavalinkDownloadFailed,
+    InvalidArchitectureException,
+    ManagedLavalinkAlreadyRunningException,
+    ManagedLavalinkPreviouslyShutdownException,
+    UnsupportedJavaException,
+    ManagedLavalinkStartFailure,
+    UnexpectedJavaResponseException,
+    EarlyExitException,
+    ManagedLavalinkNodeException,
+    NoProcessFound,
+    NodeUnhealthy,
+)
+from .utils import (
+    change_dict_naming_convention,
+    get_max_allocation_size,
+    replace_p_with_prefix,
+)
+from ...core.utils import AsyncIter
+
+if TYPE_CHECKING:
+    from . import Audio
+
+
+_ = Translator("Audio", pathlib.Path(__file__))
+log = getLogger("red.Audio.manager")
+LAVALINK_DOWNLOAD_DIR: Final[pathlib.Path] = data_manager.cog_data_path(raw_name="Audio")
+LAVALINK_JAR_FILE: Final[pathlib.Path] = LAVALINK_DOWNLOAD_DIR / "Lavalink.jar"
+LAVALINK_APP_YML: Final[pathlib.Path] = LAVALINK_DOWNLOAD_DIR / "application.yml"
+
+_FAILED_TO_START: Final[Pattern] = re.compile(rb"Web server failed to start\. (.*)")
+
+# Version regexes
+#
+# We expect the output to look something like:
+#     $ java -version
+#     ...
+#     ... version "VERSION STRING HERE" ...
+#     ...
+#
+# There are two version formats that we might get here:
+#
+# - Version scheme pre JEP 223 - used by Java 8 and older
+#
+# examples:
+# 1.8.0
+# 1.8.0_275
+# 1.8.0_272-b10
+# 1.8.0_202-internal-201903130451-b08
+# 1.8.0_272-ea-202010231715-b10
+# 1.8.0_272-ea-b10
+#
+# Implementation based on J2SE SDK/JRE Version String Naming Convention document:
+# https://www.oracle.com/java/technologies/javase/versioning-naming.html
+_RE_JAVA_VERSION_LINE_PRE223: Final[Pattern] = re.compile(
+    r'version "1\.(?P<major>[0-8])\.(?P<minor>0)(?:_(?:\d+))?(?:-.*)?"'
+)
+# - Version scheme introduced by JEP 223 - used by Java 9 and newer
+#
+# examples:
+# 11
+# 11.0.9
+# 11.0.9.1
+# 11.0.9-ea
+# 11.0.9-202011050024
+#
+# Implementation based on JEP 223 document:
+# https://openjdk.java.net/jeps/223
+_RE_JAVA_VERSION_LINE_223: Final[Pattern] = re.compile(
+    r'version "(?P<major>\d+)(?:\.(?P<minor>\d+))?(?:\.\d+)*(\-[a-zA-Z0-9]+)?"'
+)
+
+LAVALINK_BRANCH_LINE: Final[Pattern] = re.compile(rb"^Branch\s+(?P<branch>\S+)$", re.MULTILINE)
+LAVALINK_JAVA_LINE: Final[Pattern] = re.compile(rb"^JVM:\s+(?P<jvm>\S+)$", re.MULTILINE)
+LAVALINK_LAVAPLAYER_LINE: Final[Pattern] = re.compile(
+    rb"^Lavaplayer\s+(?P<lavaplayer>\S+)$", re.MULTILINE
+)
+LAVALINK_BUILD_TIME_LINE: Final[Pattern] = re.compile(
+    rb"^Build time:\s+(?P<build_time>\d+[.\d+]*).*$", re.MULTILINE
+)
+# present until Lavalink 3.5-rc4
+LAVALINK_BUILD_LINE: Final[Pattern] = re.compile(rb"^Build:\s+(?P<build>\d+)$", re.MULTILINE)
+# we don't actually care about what the version format before 3.5-rc4 is exactly
+# as the comparison is based entirely on the build number
+LAVALINK_VERSION_LINE_PRE35: Final[Pattern] = re.compile(
+    rb"^Version:\s+(?P<version>\S+)$", re.MULTILINE | re.VERBOSE
+)
+# used for LL 3.5-rc4 and newer
+LAVALINK_VERSION_LINE: Final[Pattern] = re.compile(
+    rb"""
+    ^
+    Version:\s+
+    (?P<version>
+        (?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)
+        # Before LL 3.6, when patch version == 0, it was stripped from the version string
+        (?:\.(?P<patch>0|[1-9]\d*))?
+        (?:-rc(?P<rc>0|[1-9]\d*))?
+        # only used by our downstream Lavalink if we need to make a release before upstream
+        (?:_red(?P<red>[1-9]\d*))?
+    )
+    $
+    """,
+    re.MULTILINE | re.VERBOSE,
+)
+
+
+class LavalinkOldVersion:
+    def __init__(self, raw_version: str, *, build_number: int) -> None:
+        self.raw_version = raw_version
+        self.build_number = build_number
+
+    def __str__(self) -> None:
+        return f"{self.raw_version}_{self.build_number}"
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, LavalinkOldVersion):
+            return self.build_number == other.build_number
+        if isinstance(other, LavalinkVersion):
+            return False
+        return NotImplemented
+
+    def __lt__(self, other: object) -> bool:
+        if isinstance(other, LavalinkOldVersion):
+            return self.build_number < other.build_number
+        if isinstance(other, LavalinkVersion):
+            return True
+        return NotImplemented
+
+    def __le__(self, other: object) -> bool:
+        if isinstance(other, LavalinkOldVersion):
+            return self.build_number <= other.build_number
+        if isinstance(other, LavalinkVersion):
+            return True
+        return NotImplemented
+
+    def __gt__(self, other: object) -> bool:
+        if isinstance(other, LavalinkOldVersion):
+            return self.build_number > other.build_number
+        if isinstance(other, LavalinkVersion):
+            return False
+        return NotImplemented
+
+    def __ge__(self, other: object) -> bool:
+        if isinstance(other, LavalinkOldVersion):
+            return self.build_number >= other.build_number
+        if isinstance(other, LavalinkVersion):
+            return False
+        return NotImplemented
+
+
+class LavalinkVersion:
+    def __init__(
+        self,
+        major: int,
+        minor: int,
+        patch: int = 0,
+        *,
+        rc: Optional[int] = None,
+        red: int = 0,
+    ) -> None:
+        self.major = major
+        self.minor = minor
+        self.patch = patch
+        self.rc = rc
+        self.red = red
+
+    def __str__(self) -> None:
+        version = f"{self.major}.{self.minor}.{self.patch}"
+        if self.rc is not None:
+            version += f"-rc{self.rc}"
+        if self.red:
+            version += f"_red{self.red}"
+        return version
+
+    def _get_comparison_tuple(self) -> Tuple[int, int, int, bool, int, int]:
+        return self.major, self.minor, self.patch, self.rc is None, self.rc or 0, self.red
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, LavalinkVersion):
+            return self._get_comparison_tuple() == other._get_comparison_tuple()
+        if isinstance(other, LavalinkOldVersion):
+            return False
+        return NotImplemented
+
+    def __lt__(self, other: object) -> bool:
+        if isinstance(other, LavalinkVersion):
+            return self._get_comparison_tuple() < other._get_comparison_tuple()
+        if isinstance(other, LavalinkOldVersion):
+            return False
+        return NotImplemented
+
+    def __le__(self, other: object) -> bool:
+        if isinstance(other, LavalinkVersion):
+            return self._get_comparison_tuple() <= other._get_comparison_tuple()
+        if isinstance(other, LavalinkOldVersion):
+            return False
+        return NotImplemented
+
+    def __gt__(self, other: object) -> bool:
+        if isinstance(other, LavalinkVersion):
+            return self._get_comparison_tuple() > other._get_comparison_tuple()
+        if isinstance(other, LavalinkOldVersion):
+            return True
+        return NotImplemented
+
+    def __ge__(self, other: object) -> bool:
+        if isinstance(other, LavalinkVersion):
+            return self._get_comparison_tuple() >= other._get_comparison_tuple()
+        if isinstance(other, LavalinkOldVersion):
+            return True
+        return NotImplemented
+
+
+class ServerManager:
+    JAR_VERSION: Final[str] = LavalinkOldVersion("3.4.0", build_number=1350)
+    LAVALINK_DOWNLOAD_URL: Final[str] = (
+        "https://github.com/Cog-Creators/Lavalink-Jars/releases/download/"
+        f"{JAR_VERSION}/"
+        "Lavalink.jar"
+    )
+
+    _java_available: ClassVar[Optional[bool]] = None
+    _java_version: ClassVar[Optional[Tuple[int, int]]] = None
+    _up_to_date: ClassVar[Optional[bool]] = None
+    _blacklisted_archs: List[str] = []
+
+    _lavaplayer: ClassVar[Optional[str]] = None
+    _lavalink_version: ClassVar[Optional[Union[LavalinkOldVersion, LavalinkVersion]]] = None
+    _jvm: ClassVar[Optional[str]] = None
+    _lavalink_branch: ClassVar[Optional[str]] = None
+    _buildtime: ClassVar[Optional[str]] = None
+    _java_exc: ClassVar[str] = "java"
+
+    def __init__(self, config: Config, cog: "Audio", timeout: Optional[int] = None) -> None:
+        self.ready: asyncio.Event = asyncio.Event()
+        self._config = config
+        self._proc: Optional[asyncio.subprocess.Process] = None  # pylint:disable=no-member
+        self._shutdown: bool = False
+        self.start_monitor_task = None
+        self.timeout = timeout
+        self.cog = cog
+        self._args = []
+        self._pipe_task = None
+
+    @property
+    def path(self) -> Optional[str]:
+        return self._java_exc
+
+    @property
+    def jvm(self) -> Optional[str]:
+        return self._jvm
+
+    @property
+    def lavaplayer(self) -> Optional[str]:
+        return self._lavaplayer
+
+    @property
+    def ll_version(self) -> Optional[Union[LavalinkOldVersion, LavalinkVersion]]:
+        return self._lavalink_version
+
+    @property
+    def ll_branch(self) -> Optional[str]:
+        return self._lavalink_branch
+
+    @property
+    def build_time(self) -> Optional[str]:
+        return self._buildtime
+
+    async def _pipe_output(self):
+        with contextlib.suppress(asyncio.CancelledError):
+            async for __ in self._proc.stdout:
+                pass
+
+    async def _start(self, java_path: str) -> None:
+        arch_name = platform.machine()
+        self._java_exc = java_path
+        if arch_name in self._blacklisted_archs:
+            raise InvalidArchitectureException(
+                "You are attempting to run the managed Lavalink node on an unsupported machine architecture."
+            )
+
+        if self._proc is not None:
+            if self._proc.returncode is None:
+                raise ManagedLavalinkAlreadyRunningException(
+                    "Managed Lavalink node is already running"
+                )
+            elif self._shutdown:
+                raise ManagedLavalinkPreviouslyShutdownException(
+                    "Server manager has already been used - create another one"
+                )
+        await self.process_settings()
+        await self.maybe_download_jar()
+        args, msg = await self._get_jar_args()
+        if msg is not None:
+            log.warning(msg)
+        command_string = shlex.join(args)
+        log.info("Managed Lavalink node startup command: %s", command_string)
+        if "-Xmx" not in command_string and msg is None:
+            log.warning(
+                await replace_p_with_prefix(
+                    self.cog.bot,
+                    "Managed Lavalink node maximum allowed RAM not set or higher than available RAM, "
+                    "please use '[p]llset heapsize' to set a maximum value to avoid out of RAM crashes.",
+                )
+            )
+        try:
+            self._proc = (
+                await asyncio.subprocess.create_subprocess_exec(  # pylint:disable=no-member
+                    *args,
+                    cwd=str(LAVALINK_DOWNLOAD_DIR),
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.STDOUT,
+                )
+            )
+            log.info("Managed Lavalink node started. PID: %s", self._proc.pid)
+            try:
+                await asyncio.wait_for(self._wait_for_launcher(), timeout=self.timeout)
+            except asyncio.TimeoutError:
+                log.warning(
+                    "Timeout occurred whilst waiting for managed Lavalink node to be ready"
+                )
+                raise
+        except asyncio.TimeoutError:
+            await self._partial_shutdown()
+        except Exception:
+            await self._partial_shutdown()
+            raise
+
+    async def process_settings(self):
+        data = change_dict_naming_convention(await self._config.yaml.all())
+        with open(LAVALINK_APP_YML, "w") as f:
+            yaml.safe_dump(data, f)
+
+    async def _get_jar_args(self) -> Tuple[List[str], Optional[str]]:
+        (java_available, java_version) = await self._has_java()
+
+        if not java_available:
+            if self._java_version is None:
+                extras = ""
+            else:
+                extras = f" however you have version {self._java_version} (executable: {self._java_exc})"
+            raise UnsupportedJavaException(
+                await replace_p_with_prefix(
+                    self.cog.bot,
+                    f"The managed Lavalink node requires Java 11 to run{extras};\n"
+                    "Either install version 11 and restart the bot or connect to an external Lavalink node "
+                    "(https://docs.discord.red/en/stable/install_guides/index.html)\n"
+                    "If you already have Java 11 installed then then you will need to specify the executable path, "
+                    "use '[p]llset java' to set the correct Java 11 executable.",
+                )  # TODO: Replace with Audio docs when they are out
+            )
+        java_xms, java_xmx = list((await self._config.java.all()).values())
+        match = re.match(r"^(\d+)([MG])$", java_xmx, flags=re.IGNORECASE)
+        command_args = [
+            self._java_exc,
+            "-Djdk.tls.client.protocols=TLSv1.2",
+            f"-Xms{java_xms}",
+        ]
+        meta = 0, None
+        invalid = None
+        if match and (
+            (int(match.group(1)) * 1024 ** (2 if match.group(2).lower() == "m" else 3))
+            <= (meta := get_max_allocation_size(self._java_exc))[0]
+        ):
+            command_args.append(f"-Xmx{java_xmx}")
+        elif meta[0] is not None:
+            invalid = await replace_p_with_prefix(
+                self.cog.bot,
+                "Managed Lavalink node RAM allocation ignored due to system limitations, "
+                "please fix this by setting the correct value with '[p]llset heapsize'.",
+            )
+
+        command_args.extend(["-jar", str(LAVALINK_JAR_FILE)])
+        self._args = command_args
+        return command_args, invalid
+
+    async def _has_java(self) -> Tuple[bool, Optional[Tuple[int, int]]]:
+        if self._java_available:
+            # Return cached value if we've checked this before
+            return self._java_available, self._java_version
+        java_exec = shutil.which(self._java_exc)
+        java_available = java_exec is not None
+        if not java_available:
+            self._java_available = False
+            self._java_version = None
+        else:
+            self._java_version = await self._get_java_version()
+            self._java_available = (11, 0) <= self._java_version < (12, 0)
+            self._java_exc = java_exec
+        return self._java_available, self._java_version
+
+    async def _get_java_version(self) -> Tuple[int, int]:
+        """This assumes we've already checked that java exists."""
+        _proc: asyncio.subprocess.Process = (
+            await asyncio.create_subprocess_exec(  # pylint:disable=no-member
+                self._java_exc,
+                "-version",
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+        )
+        # java -version outputs to stderr
+        _, err = await _proc.communicate()
+
+        version_info: str = err.decode("utf-8")
+        lines = version_info.splitlines()
+        for line in lines:
+            match = _RE_JAVA_VERSION_LINE_PRE223.search(line)
+            if match is None:
+                match = _RE_JAVA_VERSION_LINE_223.search(line)
+            if match is None:
+                continue
+            major = int(match["major"])
+            minor = 0
+            if minor_str := match["minor"]:
+                minor = int(minor_str)
+
+            return major, minor
+
+        raise UnexpectedJavaResponseException(
+            f"The output of `{self._java_exc} -version` was unexpected\n{version_info}."
+        )
+
+    async def _wait_for_launcher(self) -> None:
+        log.info("Waiting for Managed Lavalink node to be ready")
+        for i in itertools.cycle(range(50)):
+            line = await self._proc.stdout.readline()
+            if b"Lavalink is ready to accept connections." in line:
+                self.ready.set()
+                log.info("Managed Lavalink node is ready to receive requests.")
+                self._pipe_task = asyncio.create_task(self._pipe_output())
+                break
+            if _FAILED_TO_START.search(line):
+                raise ManagedLavalinkStartFailure(
+                    f"Lavalink failed to start: {line.decode().strip()}"
+                )
+            if self._proc.returncode is not None:
+                # Avoid Console spam only print once every 2 seconds
+                raise EarlyExitException("Managed Lavalink node server exited early.")
+            if i == 49:
+                # Sleep after 50 lines to prevent busylooping
+                await asyncio.sleep(0.1)
+
+    async def shutdown(self) -> None:
+        if self.start_monitor_task is not None:
+            self.start_monitor_task.cancel()
+        await self._partial_shutdown()
+
+    async def _partial_shutdown(self) -> None:
+        self.ready.clear()
+        if self._shutdown is True:
+            # For convenience, calling this method more than once or calling it before starting it
+            # does nothing.
+            return
+        if self._pipe_task:
+            self._pipe_task.cancel()
+        if self._proc is not None:
+            self._proc.terminate()
+            await self._proc.wait()
+        self._proc = None
+        self._shutdown = True
+
+    async def _download_jar(self) -> None:
+        log.info("Downloading Lavalink.jar...")
+        async with aiohttp.ClientSession(json_serialize=json.dumps) as session:
+            async with session.get(self.LAVALINK_DOWNLOAD_URL) as response:
+                if response.status == 404:
+                    # A 404 means our LAVALINK_DOWNLOAD_URL is invalid, so likely the jar version
+                    # hasn't been published yet
+                    raise LavalinkDownloadFailed(
+                        f"Lavalink jar version {self.JAR_VERSION} hasn't been published yet",
+                        response=response,
+                        should_retry=False,
+                    )
+                elif 400 <= response.status < 600:
+                    # Other bad responses should be raised but we should retry just incase
+                    raise LavalinkDownloadFailed(response=response, should_retry=True)
+                fd, path = tempfile.mkstemp()
+                file = open(fd, "wb")
+                nbytes = 0
+                with rich.progress.Progress(
+                    rich.progress.SpinnerColumn(),
+                    rich.progress.TextColumn("[progress.description]{task.description}"),
+                    rich.progress.BarColumn(),
+                    rich.progress.TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+                    rich.progress.TimeRemainingColumn(),
+                    rich.progress.TimeElapsedColumn(),
+                ) as progress:
+                    progress_task_id = progress.add_task(
+                        "[red]Downloading Lavalink.jar", total=response.content_length
+                    )
+                    try:
+                        chunk = await response.content.read(1024)
+                        while chunk:
+                            chunk_size = file.write(chunk)
+                            nbytes += chunk_size
+                            progress.update(progress_task_id, advance=chunk_size)
+                            chunk = await response.content.read(1024)
+                        file.flush()
+                    finally:
+                        file.close()
+
+                shutil.move(path, str(LAVALINK_JAR_FILE), copy_function=shutil.copyfile)
+
+        log.info("Successfully downloaded Lavalink.jar (%s bytes written)", format(nbytes, ","))
+        await self._is_up_to_date()
+
+    async def _is_up_to_date(self):
+        if self._up_to_date is True:
+            # Return cached value if we've checked this before
+            return True
+        args, _ = await self._get_jar_args()
+        args.append("--version")
+        _proc = await asyncio.subprocess.create_subprocess_exec(  # pylint:disable=no-member
+            *args,
+            cwd=str(LAVALINK_DOWNLOAD_DIR),
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.STDOUT,
+        )
+        stdout = (await _proc.communicate())[0]
+        if (branch := LAVALINK_BRANCH_LINE.search(stdout)) is None:
+            # Output is unexpected, suspect corrupted jarfile
+            return False
+        if (java := LAVALINK_JAVA_LINE.search(stdout)) is None:
+            # Output is unexpected, suspect corrupted jarfile
+            return False
+        if (lavaplayer := LAVALINK_LAVAPLAYER_LINE.search(stdout)) is None:
+            # Output is unexpected, suspect corrupted jarfile
+            return False
+        if (buildtime := LAVALINK_BUILD_TIME_LINE.search(stdout)) is None:
+            # Output is unexpected, suspect corrupted jarfile
+            return False
+
+        if (build := LAVALINK_BUILD_LINE.search(stdout)) is not None:
+            if (version := LAVALINK_VERSION_LINE_PRE35.search(stdout)) is None:
+                # Output is unexpected, suspect corrupted jarfile
+                return False
+            self._lavalink_version = LavalinkOldVersion(
+                raw_version=version["version"].decode(),
+                build_number=int(build["build"]),
+            )
+        elif (version := LAVALINK_VERSION_LINE.search(stdout)) is not None:
+            self._lavalink_version = LavalinkVersion(
+                major=int(version["major"]),
+                minor=int(version["minor"]),
+                patch=int(version["patch"] or 0),
+                rc=int(version["rc"]) if version["rc"] is not None else None,
+                red=int(version["red"] or 0),
+            )
+        else:
+            # Output is unexpected, suspect corrupted jarfile
+            return False
+        date = buildtime["build_time"].decode()
+        date = date.replace(".", "/")
+        self._lavalink_branch = branch["branch"].decode()
+        self._jvm = java["jvm"].decode()
+        self._lavaplayer = lavaplayer["lavaplayer"].decode()
+        self._buildtime = date
+        self._up_to_date = self._lavalink_version >= self.JAR_VERSION
+        return self._up_to_date
+
+    async def maybe_download_jar(self):
+        if not (LAVALINK_JAR_FILE.exists() and await self._is_up_to_date()):
+            await self._download_jar()
+
+    async def wait_until_ready(self, timeout: Optional[float] = None):
+        await asyncio.wait_for(self.ready.wait(), timeout=timeout or self.timeout)
+
+    async def start_monitor(self, java_path: str):
+        retry_count = 0
+        backoff = ExponentialBackoff(base=7)
+        while True:
+            try:
+                self._shutdown = False
+                if self._proc is None or self._proc.returncode is not None:
+                    self.ready.clear()
+                    await self._start(java_path=java_path)
+                while True:
+                    await self.wait_until_ready(timeout=self.timeout)
+                    if self._proc.returncode is not None:
+                        raise NoProcessFound
+                    try:
+                        node = lavalink.get_all_nodes()[0]
+                        if node.ready:
+                            # Hoping this throws an exception which will then trigger a restart
+                            await node._ws.ping()
+                            backoff = ExponentialBackoff(
+                                base=7
+                            )  # Reassign Backoff to reset it on successful ping.
+                            # ExponentialBackoff.reset() would be a nice method to have
+                            await asyncio.sleep(1)
+                        else:
+                            await asyncio.sleep(5)
+                    except IndexError:
+                        # In case lavalink.get_all_nodes() returns 0 Nodes
+                        #  (During a connect or multiple connect failures)
+                        try:
+                            log.debug(
+                                "Managed node monitor detected RLL is not connected to any nodes"
+                            )
+                            await lavalink.wait_until_ready(timeout=60, wait_if_no_node=60)
+                        except asyncio.TimeoutError:
+                            self.cog.lavalink_restart_connect(manual=True)
+                            return  # lavalink_restart_connect will cause a new monitor task to be created.
+                    except Exception as exc:
+                        log.debug(exc, exc_info=exc)
+                        raise NodeUnhealthy(str(exc))
+            except NoProcessFound:
+                await self._partial_shutdown()
+            except asyncio.TimeoutError:
+                delay = backoff.delay()
+                await self._partial_shutdown()
+                log.warning(
+                    "Lavalink Managed node health check timeout, restarting in %s seconds",
+                    delay,
+                )
+                await asyncio.sleep(delay)
+            except NodeUnhealthy:
+                delay = backoff.delay()
+                await self._partial_shutdown()
+                log.warning(
+                    "Lavalink Managed node health check failed, restarting in %s seconds",
+                    delay,
+                )
+                await asyncio.sleep(delay)
+            except LavalinkDownloadFailed as exc:
+                delay = backoff.delay()
+                if exc.should_retry:
+                    log.warning(
+                        "Lavalink Managed node download failed retrying in %s seconds\n%s",
+                        delay,
+                        exc.response,
+                    )
+                    retry_count += 1
+                    await self._partial_shutdown()
+                    await asyncio.sleep(delay)
+                else:
+                    log.critical(
+                        "Fatal exception whilst starting managed Lavalink node, "
+                        "aborting...\n%s",
+                        exc.response,
+                    )
+                    self.cog.lavalink_connection_aborted = True
+                    return await self.shutdown()
+            except InvalidArchitectureException:
+                log.critical("Invalid machine architecture, cannot run a managed Lavalink node.")
+                self.cog.lavalink_connection_aborted = True
+                return await self.shutdown()
+            except (UnsupportedJavaException, UnexpectedJavaResponseException) as exc:
+                log.critical(exc)
+                self.cog.lavalink_connection_aborted = True
+                return await self.shutdown()
+            except ManagedLavalinkNodeException as exc:
+                delay = backoff.delay()
+                log.critical(
+                    exc,
+                )
+                await self._partial_shutdown()
+                log.warning(
+                    "Lavalink Managed node startup failed retrying in %s seconds",
+                    delay,
+                )
+                await asyncio.sleep(delay)
+            except asyncio.CancelledError:
+                return
+            except Exception as exc:
+                delay = backoff.delay()
+                log.warning(
+                    "Lavalink Managed node startup failed retrying in %s seconds",
+                    delay,
+                )
+                log.debug(exc, exc_info=exc)
+                await self._partial_shutdown()
+                await asyncio.sleep(delay)
+
+    async def start(self, java_path: str):
+        if self.start_monitor_task is not None:
+            await self.shutdown()
+        self.start_monitor_task = asyncio.create_task(self.start_monitor(java_path))

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/audio/sql_statements.py

@@ -0,0 +1,646 @@
+from typing import Final
+
+# TODO: https://github.com/Cog-Creators/Red-DiscordBot/pull/3195#issuecomment-567821701
+# Thanks a lot Sinbad!
+
+__all__ = [
+    # PRAGMA Statements
+    "PRAGMA_SET_temp_store",
+    "PRAGMA_SET_journal_mode",
+    "PRAGMA_SET_read_uncommitted",
+    "PRAGMA_FETCH_user_version",
+    "PRAGMA_SET_user_version",
+    # Data Deletion statement
+    "HANDLE_DISCORD_DATA_DELETION_QUERY",
+    # Playlist table statements
+    "PLAYLIST_CREATE_TABLE",
+    "PLAYLIST_DELETE",
+    "PLAYLIST_DELETE_SCOPE",
+    "PLAYLIST_DELETE_SCHEDULED",
+    "PLAYLIST_FETCH_ALL",
+    "PLAYLIST_FETCH_ALL_WITH_FILTER",
+    "PLAYLIST_FETCH_ALL_CONVERTER",
+    "PLAYLIST_FETCH",
+    "PLAYLIST_UPSERT",
+    "PLAYLIST_CREATE_INDEX",
+    # YouTube table statements
+    "YOUTUBE_DROP_TABLE",
+    "YOUTUBE_CREATE_TABLE",
+    "YOUTUBE_CREATE_INDEX",
+    "YOUTUBE_UPSERT",
+    "YOUTUBE_UPDATE",
+    "YOUTUBE_QUERY",
+    "YOUTUBE_QUERY_ALL",
+    "YOUTUBE_DELETE_OLD_ENTRIES",
+    "YOUTUBE_QUERY_LAST_FETCHED_RANDOM",
+    # Spotify table statements
+    "SPOTIFY_DROP_TABLE",
+    "SPOTIFY_CREATE_INDEX",
+    "SPOTIFY_CREATE_TABLE",
+    "SPOTIFY_UPSERT",
+    "SPOTIFY_QUERY",
+    "SPOTIFY_QUERY_ALL",
+    "SPOTIFY_UPDATE",
+    "SPOTIFY_DELETE_OLD_ENTRIES",
+    "SPOTIFY_QUERY_LAST_FETCHED_RANDOM",
+    # Lavalink table statements
+    "LAVALINK_DROP_TABLE",
+    "LAVALINK_CREATE_TABLE",
+    "LAVALINK_CREATE_INDEX",
+    "LAVALINK_UPSERT",
+    "LAVALINK_UPDATE",
+    "LAVALINK_QUERY",
+    "LAVALINK_QUERY_ALL",
+    "LAVALINK_QUERY_LAST_FETCHED_RANDOM",
+    "LAVALINK_DELETE_OLD_ENTRIES",
+    "LAVALINK_FETCH_ALL_ENTRIES_GLOBAL",
+    # Persisting Queue statements
+    "PERSIST_QUEUE_DROP_TABLE",
+    "PERSIST_QUEUE_CREATE_TABLE",
+    "PERSIST_QUEUE_CREATE_INDEX",
+    "PERSIST_QUEUE_PLAYED",
+    "PERSIST_QUEUE_DELETE_SCHEDULED",
+    "PERSIST_QUEUE_FETCH_ALL",
+    "PERSIST_QUEUE_UPSERT",
+    "PERSIST_QUEUE_BULK_PLAYED",
+]
+
+# PRAGMA Statements
+
+PRAGMA_SET_temp_store: Final[
+    str
+] = """
+PRAGMA temp_store = 2;
+"""
+PRAGMA_SET_journal_mode: Final[
+    str
+] = """
+PRAGMA journal_mode = wal;
+"""
+PRAGMA_SET_read_uncommitted: Final[
+    str
+] = """
+PRAGMA read_uncommitted = 1;
+"""
+PRAGMA_FETCH_user_version: Final[
+    str
+] = """
+pragma user_version;
+"""
+PRAGMA_SET_user_version: Final[
+    str
+] = """
+pragma user_version=3;
+"""
+
+# Data Deletion
+# This is intentionally 2 seperate transactions due to concerns
+# Draper had. This should prevent it from being a large issue,
+# as this is no different than triggering a bulk deletion now.
+HANDLE_DISCORD_DATA_DELETION_QUERY: Final[
+    str
+] = """
+BEGIN TRANSACTION;
+
+UPDATE playlists
+SET deleted = true
+WHERE scope_id = :user_id ;
+
+UPDATE playlists
+SET author_id = 0xde1
+WHERE author_id = :user_id ;
+
+COMMIT TRANSACTION;
+
+BEGIN TRANSACTION;
+
+DELETE FROM PLAYLISTS
+WHERE deleted=true;
+
+COMMIT TRANSACTION;
+"""
+
+# Playlist table statements
+PLAYLIST_CREATE_TABLE: Final[
+    str
+] = """
+CREATE TABLE IF NOT EXISTS playlists (
+    scope_type INTEGER NOT NULL,
+    playlist_id INTEGER NOT NULL,
+    playlist_name TEXT NOT NULL,
+    scope_id INTEGER NOT NULL,
+    author_id INTEGER NOT NULL,
+    deleted BOOLEAN DEFAULT false,
+    playlist_url TEXT,
+    tracks JSON,
+    PRIMARY KEY (playlist_id, scope_id, scope_type)
+);
+"""
+PLAYLIST_DELETE: Final[
+    str
+] = """
+UPDATE playlists
+    SET
+        deleted = true
+WHERE
+    (
+        scope_type = :scope_type
+        AND playlist_id = :playlist_id
+        AND scope_id = :scope_id
+    )
+;
+"""
+PLAYLIST_DELETE_SCOPE: Final[
+    str
+] = """
+DELETE
+FROM
+    playlists
+WHERE
+    scope_type = :scope_type ;
+"""
+PLAYLIST_DELETE_SCHEDULED: Final[
+    str
+] = """
+DELETE
+FROM
+    playlists
+WHERE
+    deleted = true;
+"""
+PLAYLIST_FETCH_ALL: Final[
+    str
+] = """
+SELECT
+    playlist_id,
+    playlist_name,
+    scope_id,
+    author_id,
+    playlist_url,
+    tracks
+FROM
+    playlists
+WHERE
+    scope_type = :scope_type
+    AND scope_id = :scope_id
+    AND deleted = false
+    ;
+"""
+PLAYLIST_FETCH_ALL_WITH_FILTER: Final[
+    str
+] = """
+SELECT
+    playlist_id,
+    playlist_name,
+    scope_id,
+    author_id,
+    playlist_url,
+    tracks
+FROM
+    playlists
+WHERE
+    (
+        scope_type = :scope_type
+        AND scope_id = :scope_id
+        AND author_id = :author_id
+        AND deleted = false
+    )
+;
+"""
+PLAYLIST_FETCH_ALL_CONVERTER: Final[
+    str
+] = """
+SELECT
+    playlist_id,
+    playlist_name,
+    scope_id,
+    author_id,
+    playlist_url,
+    tracks
+FROM
+    playlists
+WHERE
+    (
+        scope_type = :scope_type
+        AND
+        (
+        playlist_id = :playlist_id
+        OR
+        LOWER(playlist_name) LIKE "%" || COALESCE(LOWER(:playlist_name), "") || "%"
+        )
+        AND deleted = false
+    )
+;
+"""
+PLAYLIST_FETCH: Final[
+    str
+] = """
+SELECT
+    playlist_id,
+    playlist_name,
+    scope_id,
+    author_id,
+    playlist_url,
+    tracks
+FROM
+    playlists
+WHERE
+    (
+        scope_type = :scope_type
+        AND playlist_id = :playlist_id
+        AND scope_id = :scope_id
+        AND deleted = false
+    )
+LIMIT 1;
+"""
+PLAYLIST_UPSERT: Final[
+    str
+] = """
+INSERT INTO
+    playlists ( scope_type, playlist_id, playlist_name, scope_id, author_id, playlist_url, tracks )
+VALUES
+    (
+        :scope_type, :playlist_id, :playlist_name, :scope_id, :author_id, :playlist_url, :tracks
+    )
+    ON CONFLICT (scope_type, playlist_id, scope_id) DO
+    UPDATE
+    SET
+        playlist_name = excluded.playlist_name,
+        playlist_url = excluded.playlist_url,
+        tracks = excluded.tracks;
+"""
+PLAYLIST_CREATE_INDEX: Final[
+    str
+] = """
+CREATE INDEX IF NOT EXISTS name_index ON playlists (
+scope_type, playlist_id, playlist_name, scope_id
+);
+"""
+
+# YouTube table statements
+YOUTUBE_DROP_TABLE: Final[
+    str
+] = """
+DROP TABLE IF EXISTS youtube;
+"""
+YOUTUBE_CREATE_TABLE: Final[
+    str
+] = """
+CREATE TABLE IF NOT EXISTS youtube(
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    track_info TEXT,
+    youtube_url TEXT,
+    last_updated INTEGER,
+    last_fetched INTEGER
+);
+"""
+YOUTUBE_CREATE_INDEX: Final[
+    str
+] = """
+CREATE UNIQUE INDEX IF NOT EXISTS idx_youtube_url
+ON youtube (track_info, youtube_url);
+"""
+YOUTUBE_UPSERT: Final[
+    str
+] = """INSERT INTO
+youtube
+  (
+    track_info,
+    youtube_url,
+    last_updated,
+    last_fetched
+  )
+VALUES
+  (
+   :track_info,
+   :track_url,
+   :last_updated,
+   :last_fetched
+  )
+ON CONFLICT
+  (
+  track_info,
+  youtube_url
+  )
+DO UPDATE
+  SET
+    track_info = excluded.track_info,
+    last_updated = excluded.last_updated
+"""
+YOUTUBE_UPDATE: Final[
+    str
+] = """
+UPDATE youtube
+SET last_fetched=:last_fetched
+WHERE track_info=:track;
+"""
+YOUTUBE_QUERY: Final[
+    str
+] = """
+SELECT youtube_url, last_updated
+FROM youtube
+WHERE
+    track_info=:track
+    AND last_updated > :maxage
+LIMIT 1;
+"""
+YOUTUBE_QUERY_ALL: Final[
+    str
+] = """
+SELECT youtube_url, last_updated
+FROM youtube
+"""
+YOUTUBE_DELETE_OLD_ENTRIES: Final[
+    str
+] = """
+DELETE FROM youtube
+WHERE
+    last_updated < :maxage
+    ;
+"""
+YOUTUBE_QUERY_LAST_FETCHED_RANDOM: Final[
+    str
+] = """
+SELECT youtube_url, last_updated
+FROM youtube
+WHERE
+    last_fetched > :day
+    AND last_updated > :maxage
+LIMIT 100
+;
+"""
+
+# Spotify table statements
+SPOTIFY_DROP_TABLE: Final[
+    str
+] = """
+DROP TABLE IF EXISTS spotify;
+"""
+SPOTIFY_CREATE_TABLE: Final[
+    str
+] = """
+CREATE TABLE IF NOT EXISTS spotify(
+    id TEXT,
+    type TEXT,
+    uri TEXT,
+    track_name TEXT,
+    artist_name TEXT,
+    song_url TEXT,
+    track_info TEXT,
+    last_updated INTEGER,
+    last_fetched INTEGER
+);
+"""
+SPOTIFY_CREATE_INDEX: Final[
+    str
+] = """
+CREATE UNIQUE INDEX IF NOT EXISTS idx_spotify_uri
+ON spotify (id, type, uri);
+"""
+SPOTIFY_UPSERT: Final[
+    str
+] = """INSERT INTO
+spotify
+  (
+    id, type, uri, track_name, artist_name,
+    song_url, track_info, last_updated, last_fetched
+  )
+VALUES
+  (
+    :id, :type, :uri, :track_name, :artist_name,
+    :song_url, :track_info, :last_updated, :last_fetched
+  )
+ON CONFLICT
+  (
+    id,
+    type,
+    uri
+  )
+DO UPDATE
+  SET
+    track_name = excluded.track_name,
+    artist_name = excluded.artist_name,
+    song_url = excluded.song_url,
+    track_info = excluded.track_info,
+    last_updated = excluded.last_updated;
+"""
+SPOTIFY_UPDATE: Final[
+    str
+] = """
+UPDATE spotify
+SET last_fetched=:last_fetched
+WHERE uri=:uri;
+"""
+SPOTIFY_QUERY: Final[
+    str
+] = """
+SELECT track_info, last_updated
+FROM spotify
+WHERE
+    uri=:uri
+    AND last_updated > :maxage
+LIMIT 1;
+"""
+SPOTIFY_QUERY_ALL: Final[
+    str
+] = """
+SELECT track_info, last_updated
+FROM spotify
+"""
+SPOTIFY_DELETE_OLD_ENTRIES: Final[
+    str
+] = """
+DELETE FROM spotify
+WHERE
+    last_updated < :maxage
+    ;
+"""
+SPOTIFY_QUERY_LAST_FETCHED_RANDOM: Final[
+    str
+] = """
+SELECT track_info, last_updated
+FROM spotify
+WHERE
+    last_fetched > :day
+    AND last_updated > :maxage
+LIMIT 100
+;
+"""
+
+# Lavalink table statements
+LAVALINK_DROP_TABLE: Final[
+    str
+] = """
+DROP TABLE IF EXISTS lavalink ;
+"""
+LAVALINK_CREATE_TABLE: Final[
+    str
+] = """
+CREATE TABLE IF NOT EXISTS lavalink(
+    query TEXT,
+    data JSON,
+    last_updated INTEGER,
+    last_fetched INTEGER
+
+);
+"""
+LAVALINK_CREATE_INDEX: Final[
+    str
+] = """
+CREATE UNIQUE INDEX IF NOT EXISTS idx_lavalink_query
+ON lavalink (query);
+"""
+LAVALINK_UPSERT: Final[
+    str
+] = """INSERT INTO
+lavalink
+  (
+    query,
+    data,
+    last_updated,
+    last_fetched
+  )
+VALUES
+  (
+   :query,
+   :data,
+   :last_updated,
+   :last_fetched
+  )
+ON CONFLICT
+  (
+    query
+  )
+DO UPDATE
+  SET
+    data = excluded.data,
+    last_updated = excluded.last_updated;
+"""
+LAVALINK_UPDATE: Final[
+    str
+] = """
+UPDATE lavalink
+SET last_fetched=:last_fetched
+WHERE query=:query;
+"""
+LAVALINK_QUERY: Final[
+    str
+] = """
+SELECT data, last_updated
+FROM lavalink
+WHERE
+    query=:query
+    AND last_updated > :maxage
+LIMIT 1;
+"""
+LAVALINK_QUERY_ALL: Final[
+    str
+] = """
+SELECT data, last_updated
+FROM lavalink
+"""
+LAVALINK_QUERY_LAST_FETCHED_RANDOM: Final[
+    str
+] = """
+SELECT data, last_updated
+FROM lavalink
+WHERE
+    last_fetched > :day
+    AND last_updated > :maxage
+LIMIT 100
+;
+"""
+LAVALINK_DELETE_OLD_ENTRIES: Final[
+    str
+] = """
+DELETE FROM lavalink
+WHERE
+    last_updated < :maxage
+    ;
+"""
+LAVALINK_FETCH_ALL_ENTRIES_GLOBAL: Final[
+    str
+] = """
+SELECT query, data 
+FROM lavalink
+"""
+
+# Persisting Queue statements
+PERSIST_QUEUE_DROP_TABLE: Final[
+    str
+] = """
+DROP TABLE IF EXISTS persist_queue ;
+"""
+PERSIST_QUEUE_CREATE_TABLE: Final[
+    str
+] = """
+CREATE TABLE IF NOT EXISTS persist_queue(
+    guild_id INTEGER NOT NULL,
+    room_id INTEGER NOT NULL,
+    track JSON NOT NULL,
+    played BOOLEAN DEFAULT false,
+    track_id TEXT NOT NULL,
+    time INTEGER NOT NULL,
+    PRIMARY KEY (guild_id, room_id, track_id)
+);
+"""
+PERSIST_QUEUE_CREATE_INDEX: Final[
+    str
+] = """
+CREATE INDEX IF NOT EXISTS track_index ON persist_queue (guild_id, track_id);
+"""
+PERSIST_QUEUE_PLAYED: Final[
+    str
+] = """
+UPDATE persist_queue
+    SET
+        played = true
+WHERE
+    (
+        guild_id = :guild_id
+        AND track_id = :track_id
+    )
+;
+"""
+PERSIST_QUEUE_BULK_PLAYED: Final[
+    str
+] = """
+UPDATE persist_queue
+    SET
+        played = true
+WHERE guild_id = :guild_id
+;
+"""
+PERSIST_QUEUE_DELETE_SCHEDULED: Final[
+    str
+] = """
+DELETE
+FROM
+    persist_queue
+WHERE
+    played = true;
+"""
+PERSIST_QUEUE_FETCH_ALL: Final[
+    str
+] = """
+SELECT
+    guild_id, room_id, track
+FROM
+    persist_queue
+WHERE played = false
+ORDER BY time ASC;
+"""
+PERSIST_QUEUE_UPSERT: Final[
+    str
+] = """
+INSERT INTO
+    persist_queue (guild_id, room_id, track, played, track_id, time)
+VALUES
+    (
+        :guild_id, :room_id, :track, :played, :track_id, :time
+    )
+ON CONFLICT (guild_id, room_id, track_id) DO
+UPDATE
+    SET
+        time = excluded.time
+"""

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/cleanup/__init__.py

@@ -0,0 +1,6 @@
+from .cleanup import Cleanup
+from redbot.core.bot import Red
+
+
+async def setup(bot: Red) -> None:
+    await bot.add_cog(Cleanup(bot))

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/cleanup/checks.py

@@ -0,0 +1,15 @@
+from redbot.core.commands import Context, permissions_check
+from redbot.core.utils.mod import is_mod_or_superior, check_permissions
+
+
+def check_self_permissions():
+    async def predicate(ctx: Context):
+        if not ctx.guild:
+            return True
+        if await check_permissions(ctx, {"manage_messages": True}) or await is_mod_or_superior(
+            ctx.bot, ctx.author
+        ):
+            return True
+        return False
+
+    return permissions_check(predicate)

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/cleanup/cleanup.py

@@ -0,0 +1,759 @@
+import contextlib
+import logging
+from datetime import datetime, timedelta, timezone
+from typing import Callable, List, Optional, Set, Union
+
+import discord
+
+from redbot.core import commands, Config
+from redbot.core.bot import Red
+from redbot.core.commands import RawUserIdConverter
+from redbot.core.i18n import Translator, cog_i18n
+from redbot.core.utils.chat_formatting import humanize_number
+from redbot.core.utils.mod import slow_deletion, mass_purge
+from redbot.core.utils.predicates import MessagePredicate
+from .checks import check_self_permissions
+from .converters import PositiveInt, RawMessageIds, positive_int
+
+_ = Translator("Cleanup", __file__)
+
+log = logging.getLogger("red.cleanup")
+
+
+@cog_i18n(_)
+class Cleanup(commands.Cog):
+    """This cog contains commands used for "cleaning up" (deleting) messages.
+
+    This is designed as a moderator tool and offers many convenient use cases.
+    All cleanup commands only apply to the channel the command is executed in.
+
+    Messages older than two weeks cannot be mass deleted.
+    This is a limitation of the API.
+    """
+
+    def __init__(self, bot: Red):
+        super().__init__()
+        self.bot = bot
+        self.config = Config.get_conf(self, 8927348724, force_registration=True)
+        self.config.register_guild(notify=True)
+
+    async def red_delete_data_for_user(self, **kwargs):
+        """Nothing to delete"""
+        return
+
+    @staticmethod
+    async def check_100_plus(ctx: commands.Context, number: int) -> bool:
+        """
+        Called when trying to delete more than 100 messages at once.
+
+        Prompts the user to choose whether they want to continue or not.
+
+        Tries its best to cleanup after itself if the response is positive.
+        """
+
+        if ctx.assume_yes:
+            return True
+
+        prompt = await ctx.send(
+            _("Are you sure you want to delete {number} messages?").format(
+                number=humanize_number(number)
+            )
+            + " (yes/no)"
+        )
+        response = await ctx.bot.wait_for("message", check=MessagePredicate.same_context(ctx))
+
+        if response.content.lower().startswith("y"):
+            with contextlib.suppress(discord.NotFound):
+                await prompt.delete()
+            with contextlib.suppress(discord.HTTPException):
+                await response.delete()
+            return True
+        else:
+            await ctx.send(_("Cancelled."))
+            return False
+
+    @staticmethod
+    async def get_messages_for_deletion(
+        *,
+        channel: Union[
+            discord.TextChannel, discord.VoiceChannel, discord.DMChannel, discord.Thread
+        ],
+        number: Optional[PositiveInt] = None,
+        check: Callable[[discord.Message], bool] = lambda x: True,
+        limit: Optional[PositiveInt] = None,
+        before: Union[discord.Message, datetime] = None,
+        after: Union[discord.Message, datetime] = None,
+        delete_pinned: bool = False,
+    ) -> List[discord.Message]:
+        """
+        Gets a list of messages meeting the requirements to be deleted.
+        Generally, the requirements are:
+        - We don't have the number of messages to be deleted already
+        - The message passes a provided check (if no check is provided,
+          this is automatically true)
+        - The message is less than 14 days old
+        - The message is not pinned
+
+        Warning: Due to the way the API hands messages back in chunks,
+        passing after and a number together is not advisable.
+        If you need to accomplish this, you should filter messages on
+        the entire applicable range, rather than use this utility.
+        """
+
+        # This isn't actually two weeks ago to allow some wiggle room on API limits
+        two_weeks_ago = datetime.now(timezone.utc) - timedelta(days=14, minutes=-5)
+
+        def message_filter(message):
+            return (
+                check(message)
+                and message.created_at > two_weeks_ago
+                and (delete_pinned or not message.pinned)
+            )
+
+        if after:
+            if isinstance(after, discord.Message):
+                after = after.created_at
+            after = max(after, two_weeks_ago)
+
+        collected = []
+        async for message in channel.history(
+            limit=limit, before=before, after=after, oldest_first=False
+        ):
+            if message.created_at < two_weeks_ago:
+                break
+            if message_filter(message):
+                collected.append(message)
+                if number is not None and number <= len(collected):
+                    break
+
+        return collected
+
+    async def send_optional_notification(
+        self,
+        num: int,
+        channel: Union[
+            discord.TextChannel, discord.VoiceChannel, discord.DMChannel, discord.Thread
+        ],
+        *,
+        subtract_invoking: bool = False,
+    ) -> None:
+        """
+        Sends a notification to the channel that a certain number of messages have been deleted.
+        """
+        if not hasattr(channel, "guild") or await self.config.guild(channel.guild).notify():
+            if subtract_invoking:
+                num -= 1
+            if num == 1:
+                await channel.send(_("1 message was deleted."), delete_after=5)
+            else:
+                await channel.send(
+                    _("{num} messages were deleted.").format(num=humanize_number(num)),
+                    delete_after=5,
+                )
+
+    @staticmethod
+    async def get_message_from_reference(
+        channel: Union[discord.TextChannel, discord.VoiceChannel, discord.Thread],
+        reference: discord.MessageReference,
+    ) -> Optional[discord.Message]:
+        message = None
+        resolved = reference.resolved
+        if resolved and isinstance(resolved, discord.Message):
+            message = resolved
+        elif message := reference.cached_message:
+            pass
+        else:
+            try:
+                message = await channel.fetch_message(reference.message_id)
+            except discord.NotFound:
+                pass
+        return message
+
+    @commands.group()
+    async def cleanup(self, ctx: commands.Context):
+        """Base command for deleting messages."""
+        pass
+
+    @cleanup.command()
+    @commands.guild_only()
+    @commands.mod_or_permissions(manage_messages=True)
+    @commands.bot_has_permissions(manage_messages=True)
+    async def text(
+        self, ctx: commands.Context, text: str, number: positive_int, delete_pinned: bool = False
+    ):
+        """Delete the last X messages matching the specified text in the current channel.
+
+        Example:
+            - `[p]cleanup text "test" 5`
+
+        Remember to use double quotes.
+
+        **Arguments:**
+
+        - `<number>` The max number of messages to cleanup. Must be a positive integer.
+        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False
+        """
+
+        channel = ctx.channel
+
+        author = ctx.author
+
+        if number > 100:
+            cont = await self.check_100_plus(ctx, number)
+            if not cont:
+                return
+
+        def check(m):
+            if text in m.content:
+                return True
+            else:
+                return False
+
+        to_delete = await self.get_messages_for_deletion(
+            channel=channel,
+            number=number,
+            check=check,
+            before=ctx.message,
+            delete_pinned=delete_pinned,
+        )
+        to_delete.append(ctx.message)
+
+        reason = "{}({}) deleted {} messages containing '{}' in channel #{}.".format(
+            author.name,
+            author.id,
+            humanize_number(len(to_delete), override_locale="en_us"),
+            text,
+            channel.id,
+        )
+        log.info(reason)
+
+        await mass_purge(to_delete, channel, reason=reason)
+        await self.send_optional_notification(len(to_delete), channel, subtract_invoking=True)
+
+    @cleanup.command()
+    @commands.guild_only()
+    @commands.mod_or_permissions(manage_messages=True)
+    @commands.bot_has_permissions(manage_messages=True)
+    async def user(
+        self,
+        ctx: commands.Context,
+        user: Union[discord.Member, RawUserIdConverter],
+        number: positive_int,
+        delete_pinned: bool = False,
+    ):
+        """Delete the last X messages from a specified user in the current channel.
+
+        Examples:
+            - `[p]cleanup user @Twentysix 2`
+            - `[p]cleanup user Red 6`
+
+        **Arguments:**
+
+        - `<user>` The user whose messages are to be cleaned up.
+        - `<number>` The max number of messages to cleanup. Must be a positive integer.
+        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False
+        """
+        channel = ctx.channel
+
+        member = None
+        if isinstance(user, discord.Member):
+            member = user
+            _id = member.id
+        else:
+            _id = user
+
+        author = ctx.author
+
+        if number > 100:
+            cont = await self.check_100_plus(ctx, number)
+            if not cont:
+                return
+
+        def check(m):
+            if m.author.id == _id:
+                return True
+            else:
+                return False
+
+        to_delete = await self.get_messages_for_deletion(
+            channel=channel,
+            number=number,
+            check=check,
+            before=ctx.message,
+            delete_pinned=delete_pinned,
+        )
+        to_delete.append(ctx.message)
+
+        reason = (
+            "{}({}) deleted {} messages"
+            " made by {}({}) in channel #{}."
+            "".format(
+                author.name,
+                author.id,
+                humanize_number(len(to_delete), override_locale="en_US"),
+                member or "???",
+                _id,
+                channel.name,
+            )
+        )
+        log.info(reason)
+
+        await mass_purge(to_delete, channel, reason=reason)
+        await self.send_optional_notification(len(to_delete), channel, subtract_invoking=True)
+
+    @cleanup.command()
+    @commands.guild_only()
+    @commands.mod_or_permissions(manage_messages=True)
+    @commands.bot_has_permissions(manage_messages=True)
+    async def after(
+        self,
+        ctx: commands.Context,
+        message_id: Optional[RawMessageIds],
+        delete_pinned: bool = False,
+    ):
+        """Delete all messages after a specified message.
+
+        To get a message id, enable developer mode in Discord's
+        settings, 'appearance' tab. Then right click a message
+        and copy its id.
+        Replying to a message will cleanup all messages after it.
+
+        **Arguments:**
+
+        - `<message_id>` The id of the message to cleanup after. This message won't be deleted.
+        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False
+        """
+
+        channel = ctx.channel
+        author = ctx.author
+        after = None
+
+        if message_id:
+            try:
+                after = await channel.fetch_message(message_id)
+            except discord.NotFound:
+                return await ctx.send(_("Message not found."))
+        elif ref := ctx.message.reference:
+            after = await self.get_message_from_reference(channel, ref)
+
+        if after is None:
+            raise commands.BadArgument
+
+        to_delete = await self.get_messages_for_deletion(
+            channel=channel, number=None, after=after, delete_pinned=delete_pinned
+        )
+
+        reason = "{}({}) deleted {} messages in channel #{}.".format(
+            author.name,
+            author.id,
+            humanize_number(len(to_delete), override_locale="en_US"),
+            channel.name,
+        )
+        log.info(reason)
+
+        await mass_purge(to_delete, channel, reason=reason)
+        await self.send_optional_notification(len(to_delete), channel)
+
+    @cleanup.command()
+    @commands.guild_only()
+    @commands.mod_or_permissions(manage_messages=True)
+    @commands.bot_has_permissions(manage_messages=True)
+    async def before(
+        self,
+        ctx: commands.Context,
+        message_id: Optional[RawMessageIds],
+        number: positive_int,
+        delete_pinned: bool = False,
+    ):
+        """Deletes X messages before the specified message.
+
+        To get a message id, enable developer mode in Discord's
+        settings, 'appearance' tab. Then right click a message
+        and copy its id.
+        Replying to a message will cleanup all messages before it.
+
+        **Arguments:**
+
+        - `<message_id>` The id of the message to cleanup before. This message won't be deleted.
+        - `<number>` The max number of messages to cleanup. Must be a positive integer.
+        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False
+        """
+
+        channel = ctx.channel
+        author = ctx.author
+        before = None
+
+        if message_id:
+            try:
+                before = await channel.fetch_message(message_id)
+            except discord.NotFound:
+                return await ctx.send(_("Message not found."))
+        elif ref := ctx.message.reference:
+            before = await self.get_message_from_reference(channel, ref)
+
+        if before is None:
+            raise commands.BadArgument
+
+        to_delete = await self.get_messages_for_deletion(
+            channel=channel, number=number, before=before, delete_pinned=delete_pinned
+        )
+        to_delete.append(ctx.message)
+
+        reason = "{}({}) deleted {} messages in channel #{}.".format(
+            author.name,
+            author.id,
+            humanize_number(len(to_delete), override_locale="en_US"),
+            channel.name,
+        )
+        log.info(reason)
+
+        await mass_purge(to_delete, channel, reason=reason)
+        await self.send_optional_notification(len(to_delete), channel, subtract_invoking=True)
+
+    @cleanup.command()
+    @commands.guild_only()
+    @commands.mod_or_permissions(manage_messages=True)
+    @commands.bot_has_permissions(manage_messages=True)
+    async def between(
+        self,
+        ctx: commands.Context,
+        one: RawMessageIds,
+        two: RawMessageIds,
+        delete_pinned: bool = False,
+    ):
+        """Delete the messages between Message One and Message Two, providing the messages IDs.
+
+        The first message ID should be the older message and the second one the newer.
+
+        Example:
+            - `[p]cleanup between 123456789123456789 987654321987654321`
+
+        **Arguments:**
+
+        - `<one>` The id of the message to cleanup after. This message won't be deleted.
+        - `<two>` The id of the message to cleanup before. This message won't be deleted.
+        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False
+        """
+        channel = ctx.channel
+        author = ctx.author
+        try:
+            mone = await channel.fetch_message(one)
+        except discord.errors.NotFound:
+            return await ctx.send(
+                _("Could not find a message with the ID of {id}.".format(id=one))
+            )
+        try:
+            mtwo = await channel.fetch_message(two)
+        except discord.errors.NotFound:
+            return await ctx.send(
+                _("Could not find a message with the ID of {id}.".format(id=two))
+            )
+        to_delete = await self.get_messages_for_deletion(
+            channel=channel, before=mtwo, after=mone, delete_pinned=delete_pinned
+        )
+        to_delete.append(ctx.message)
+        reason = "{}({}) deleted {} messages in channel #{}.".format(
+            author.name,
+            author.id,
+            humanize_number(len(to_delete), override_locale="en_US"),
+            channel.name,
+        )
+        log.info(reason)
+
+        await mass_purge(to_delete, channel, reason=reason)
+        await self.send_optional_notification(len(to_delete), channel, subtract_invoking=True)
+
+    @cleanup.command()
+    @commands.guild_only()
+    @commands.mod_or_permissions(manage_messages=True)
+    @commands.bot_has_permissions(manage_messages=True)
+    async def messages(
+        self, ctx: commands.Context, number: positive_int, delete_pinned: bool = False
+    ):
+        """Delete the last X messages in the current channel.
+
+        Example:
+            - `[p]cleanup messages 26`
+
+        **Arguments:**
+
+        - `<number>` The max number of messages to cleanup. Must be a positive integer.
+        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False
+        """
+
+        channel = ctx.channel
+        author = ctx.author
+
+        if number > 100:
+            cont = await self.check_100_plus(ctx, number)
+            if not cont:
+                return
+
+        to_delete = await self.get_messages_for_deletion(
+            channel=channel, number=number, before=ctx.message, delete_pinned=delete_pinned
+        )
+        to_delete.append(ctx.message)
+
+        reason = "{}({}) deleted {} messages in channel #{}.".format(
+            author.name, author.id, len(to_delete), channel.name
+        )
+        log.info(reason)
+
+        await mass_purge(to_delete, channel, reason=reason)
+        await self.send_optional_notification(len(to_delete), channel, subtract_invoking=True)
+
+    @cleanup.command(name="bot")
+    @commands.guild_only()
+    @commands.mod_or_permissions(manage_messages=True)
+    @commands.bot_has_permissions(manage_messages=True)
+    async def cleanup_bot(
+        self, ctx: commands.Context, number: positive_int, delete_pinned: bool = False
+    ):
+        """Clean up command messages and messages from the bot in the current channel.
+
+        Can only cleanup custom commands and alias commands if those cogs are loaded.
+
+        **Arguments:**
+
+        - `<number>` The max number of messages to cleanup. Must be a positive integer.
+        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False
+        """
+
+        channel = ctx.channel
+        author = ctx.message.author
+
+        if number > 100:
+            cont = await self.check_100_plus(ctx, number)
+            if not cont:
+                return
+
+        prefixes = await self.bot.get_prefix(ctx.message)  # This returns all server prefixes
+        if isinstance(prefixes, str):
+            prefixes = [prefixes]
+
+        # In case some idiot sets a null prefix
+        if "" in prefixes:
+            prefixes.remove("")
+
+        cc_cog = self.bot.get_cog("CustomCommands")
+        if cc_cog is not None:
+            command_names: Set[str] = await cc_cog.get_command_names(ctx.guild)
+            is_cc = lambda name: name in command_names
+        else:
+            is_cc = lambda name: False
+        alias_cog = self.bot.get_cog("Alias")
+        if alias_cog is not None:
+            alias_names: Set[str] = set(
+                a.name for a in await alias_cog._aliases.get_global_aliases()
+            ) | set(a.name for a in await alias_cog._aliases.get_guild_aliases(ctx.guild))
+            is_alias = lambda name: name in alias_names
+        else:
+            is_alias = lambda name: False
+
+        bot_id = self.bot.user.id
+
+        def check(m):
+            if m.author.id == bot_id:
+                return True
+            elif m == ctx.message:
+                return True
+            p = discord.utils.find(m.content.startswith, prefixes)
+            if p and len(p) > 0:
+                cmd_name = m.content[len(p) :].split(" ")[0]
+                return (
+                    bool(self.bot.get_command(cmd_name)) or is_alias(cmd_name) or is_cc(cmd_name)
+                )
+            return False
+
+        to_delete = await self.get_messages_for_deletion(
+            channel=channel,
+            number=number,
+            check=check,
+            before=ctx.message,
+            delete_pinned=delete_pinned,
+        )
+        to_delete.append(ctx.message)
+
+        reason = (
+            "{}({}) deleted {}"
+            " command messages in channel #{}."
+            "".format(
+                author.name,
+                author.id,
+                humanize_number(len(to_delete), override_locale="en_US"),
+                channel.name,
+            )
+        )
+        log.info(reason)
+
+        await mass_purge(to_delete, channel, reason=reason)
+        await self.send_optional_notification(len(to_delete), channel, subtract_invoking=True)
+
+    @cleanup.command(name="self")
+    @check_self_permissions()
+    async def cleanup_self(
+        self,
+        ctx: commands.Context,
+        number: positive_int,
+        match_pattern: str = None,
+        delete_pinned: bool = False,
+    ):
+        """Clean up messages owned by the bot in the current channel.
+
+        By default, all messages are cleaned. If a second argument is specified,
+        it is used for pattern matching - only messages containing the given text will be deleted.
+
+        Examples:
+            - `[p]cleanup self 6`
+            - `[p]cleanup self 10 Pong`
+            - `[p]cleanup self 7 "" True`
+
+        **Arguments:**
+
+        - `<number>` The max number of messages to cleanup. Must be a positive integer.
+        - `<match_pattern>` The text that messages must contain to be deleted. Use "" to skip this.
+        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False
+        """
+        channel = ctx.channel
+        author = ctx.message.author
+
+        if number > 100:
+            cont = await self.check_100_plus(ctx, number)
+            if not cont:
+                return
+
+        # You can always delete your own messages, this is needed to purge
+        can_mass_purge = False
+        if type(author) is discord.Member:
+            me = ctx.guild.me
+            can_mass_purge = ctx.bot_permissions.manage_messages
+
+        if match_pattern:
+
+            def content_match(c):
+                return match_pattern in c
+
+        else:
+
+            def content_match(_):
+                return True
+
+        def check(m):
+            if m.author.id != self.bot.user.id:
+                return False
+            elif content_match(m.content):
+                return True
+            return False
+
+        to_delete = await self.get_messages_for_deletion(
+            channel=channel,
+            number=number,
+            check=check,
+            before=ctx.message,
+            delete_pinned=delete_pinned,
+        )
+        if can_mass_purge:
+            to_delete.append(ctx.message)
+
+        if ctx.guild:
+            channel_name = "channel " + channel.name
+        else:
+            channel_name = str(channel)
+
+        reason = (
+            "{}({}) deleted {} messages "
+            "sent by the bot in {}."
+            "".format(
+                author.name,
+                author.id,
+                humanize_number(len(to_delete), override_locale="en_US"),
+                channel_name,
+            )
+        )
+        log.info(reason)
+
+        if can_mass_purge:
+            await mass_purge(to_delete, channel, reason=reason)
+        else:
+            await slow_deletion(to_delete)
+        await self.send_optional_notification(
+            len(to_delete), channel, subtract_invoking=can_mass_purge
+        )
+
+    @cleanup.command(name="duplicates", aliases=["spam"])
+    @commands.guild_only()
+    @commands.mod_or_permissions(manage_messages=True)
+    @commands.bot_has_permissions(manage_messages=True)
+    async def cleanup_duplicates(
+        self, ctx: commands.Context, number: positive_int = PositiveInt(50)
+    ):
+        """Deletes duplicate messages in the channel from the last X messages and keeps only one copy.
+
+        Defaults to 50.
+
+        **Arguments:**
+
+        - `<number>` The number of messages to check for duplicates. Must be a positive integer.
+        """
+        msgs = []
+        spam = []
+
+        def check(m):
+            if m.attachments:
+                return False
+            c = (
+                m.author.id,
+                m.content,
+                [embed.to_dict() for embed in m.embeds],
+                [sticker.id for sticker in m.stickers],
+            )
+            if c in msgs:
+                spam.append(m)
+                return True
+            else:
+                msgs.append(c)
+                return False
+
+        to_delete = await self.get_messages_for_deletion(
+            channel=ctx.channel, limit=number, check=check, before=ctx.message
+        )
+
+        if len(to_delete) > 100:
+            cont = await self.check_100_plus(ctx, len(to_delete))
+            if not cont:
+                return
+
+        log.info(
+            "%s (%s) deleted %s spam messages in channel %s (%s).",
+            ctx.author,
+            ctx.author.id,
+            len(to_delete),
+            ctx.channel,
+            ctx.channel.id,
+        )
+
+        to_delete.append(ctx.message)
+        await mass_purge(to_delete, ctx.channel, reason="Duplicate message cleanup")
+        await self.send_optional_notification(len(to_delete), ctx.channel, subtract_invoking=True)
+
+    @commands.group()
+    @commands.admin_or_permissions(manage_messages=True)
+    async def cleanupset(self, ctx: commands.Context):
+        """Manage the settings for the cleanup command."""
+        pass
+
+    @commands.guild_only()
+    @cleanupset.command(name="notify")
+    async def cleanupset_notify(self, ctx: commands.Context):
+        """Toggle clean up notification settings.
+
+        When enabled, a message will be sent per cleanup, showing how many messages were deleted.
+        This message will be deleted after 5 seconds.
+        """
+        toggle = await self.config.guild(ctx.guild).notify()
+        if toggle:
+            await self.config.guild(ctx.guild).notify.set(False)
+            await ctx.send(_("I will no longer notify of message deletions."))
+        else:
+            await self.config.guild(ctx.guild).notify.set(True)
+            await ctx.send(_("I will now notify of message deletions."))

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/cleanup/converters.py

@@ -0,0 +1,32 @@
+from typing import NewType, TYPE_CHECKING
+
+from redbot.core.commands import BadArgument, Context, Converter
+from redbot.core.i18n import Translator
+from redbot.core.utils.chat_formatting import inline
+
+_ = Translator("Cleanup", __file__)
+
+SNOWFLAKE_THRESHOLD = 2**63
+
+
+class RawMessageIds(Converter):
+    async def convert(self, ctx: Context, argument: str) -> int:
+        if argument.isnumeric() and len(argument) >= 17 and int(argument) < SNOWFLAKE_THRESHOLD:
+            return int(argument)
+
+        raise BadArgument(_("{} doesn't look like a valid message ID.").format(argument))
+
+
+PositiveInt = NewType("PositiveInt", int)
+if TYPE_CHECKING:
+    positive_int = PositiveInt
+else:
+
+    def positive_int(arg: str) -> int:
+        try:
+            ret = int(arg)
+        except ValueError:
+            raise BadArgument(_("{arg} is not an integer.").format(arg=inline(arg)))
+        if ret <= 0:
+            raise BadArgument(_("{arg} is not a positive integer.").format(arg=inline(arg)))
+        return ret

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/cleanup/locales/ar-SA.po

@@ -0,0 +1,167 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-05-23 14:25+0000\n"
+"Last-Translator: \n"
+"Language-Team: Arabic\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=6; plural=(n==0 ? 0 : n==1 ? 1 : n==2 ? 2 : n%100>=3 && n%100<=10 ? 3 : n%100>=11 && n%100<=99 ? 4 : 5);\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: ar\n"
+"X-Crowdin-File-ID: 31\n"
+"Language: ar_SA\n"
+
+#: redbot/cogs/cleanup/cleanup.py:23
+#, docstring
+msgid "This cog contains commands used for \"cleaning up\" (deleting) messages.\n\n"
+"    This is designed as a moderator tool and offers many convenient use cases.\n"
+"    All cleanup commands only apply to the channel the command is executed in.\n\n"
+"    Messages older than two weeks cannot be mass deleted.\n"
+"    This is a limitation of the API.\n"
+"    "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:54
+msgid "Are you sure you want to delete {number} messages? (y/n)"
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:68
+msgid "Cancelled."
+msgstr "تم الإلغاء."
+
+#: redbot/cogs/cleanup/cleanup.py:144
+#, docstring
+msgid "Base command for deleting messages."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:154
+#, docstring
+msgid "Delete the last X messages matching the specified text in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup text \"test\" 5`\n\n"
+"        Remember to use double quotes.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:209
+#, docstring
+msgid "Delete the last X messages from a specified user in the current channel.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup user @Twentysix 2`\n"
+"            - `[p]cleanup user Red 6`\n\n"
+"        **Arguments:**\n\n"
+"        - `<user>` The user whose messages are to be cleaned up.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:282
+#, docstring
+msgid "Delete all messages after a specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages after it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:303 redbot/cogs/cleanup/cleanup.py:357
+msgid "Message not found."
+msgstr "الرسالة غير موجودة."
+
+#: redbot/cogs/cleanup/cleanup.py:335
+#, docstring
+msgid "Deletes X messages before the specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages before it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:390
+#, docstring
+msgid "Delete the messages between Message One and Message Two, providing the messages IDs.\n\n"
+"        The first message ID should be the older message and the second one the newer.\n\n"
+"        Example:\n"
+"            - `[p]cleanup between 123456789123456789 987654321987654321`\n\n"
+"        **Arguments:**\n\n"
+"        - `<one>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<two>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:438
+#, docstring
+msgid "Delete the last X messages in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup messages 26`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:476
+#, docstring
+msgid "Clean up command messages and messages from the bot in the current channel.\n\n"
+"        Can only cleanup custom commands and alias commands if those cogs are loaded.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:564
+#, docstring
+msgid "Clean up messages owned by the bot in the current channel.\n\n"
+"        By default, all messages are cleaned. If a second argument is specified,\n"
+"        it is used for pattern matching - only messages containing the given text will be deleted.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup self 6`\n"
+"            - `[p]cleanup self 10 Pong`\n"
+"            - `[p]cleanup self 7 \"\" True`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<match_pattern>` The text that messages must contain to be deleted. Use \"\" to skip this.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:650
+#, docstring
+msgid "Deletes duplicate messages in the channel from the last X messages and keeps only one copy.\n\n"
+"        Defaults to 50.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The number of messages to check for duplicates. Must be a positive integer.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:17
+msgid "{} doesn't look like a valid message ID."
+msgstr "{} لا يبدو معرف رسالة صالح."
+
+#: redbot/cogs/cleanup/converters.py:29
+msgid "{arg} is not an integer."
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:31
+msgid "{arg} is not a positive integer."
+msgstr ""
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/cleanup/locales/da-DK.po

@@ -0,0 +1,167 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-05-23 14:25+0000\n"
+"Last-Translator: \n"
+"Language-Team: Danish\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: da\n"
+"X-Crowdin-File-ID: 31\n"
+"Language: da_DK\n"
+
+#: redbot/cogs/cleanup/cleanup.py:23
+#, docstring
+msgid "This cog contains commands used for \"cleaning up\" (deleting) messages.\n\n"
+"    This is designed as a moderator tool and offers many convenient use cases.\n"
+"    All cleanup commands only apply to the channel the command is executed in.\n\n"
+"    Messages older than two weeks cannot be mass deleted.\n"
+"    This is a limitation of the API.\n"
+"    "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:54
+msgid "Are you sure you want to delete {number} messages? (y/n)"
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:68
+msgid "Cancelled."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:144
+#, docstring
+msgid "Base command for deleting messages."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:154
+#, docstring
+msgid "Delete the last X messages matching the specified text in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup text \"test\" 5`\n\n"
+"        Remember to use double quotes.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:209
+#, docstring
+msgid "Delete the last X messages from a specified user in the current channel.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup user @Twentysix 2`\n"
+"            - `[p]cleanup user Red 6`\n\n"
+"        **Arguments:**\n\n"
+"        - `<user>` The user whose messages are to be cleaned up.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:282
+#, docstring
+msgid "Delete all messages after a specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages after it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:303 redbot/cogs/cleanup/cleanup.py:357
+msgid "Message not found."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:335
+#, docstring
+msgid "Deletes X messages before the specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages before it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:390
+#, docstring
+msgid "Delete the messages between Message One and Message Two, providing the messages IDs.\n\n"
+"        The first message ID should be the older message and the second one the newer.\n\n"
+"        Example:\n"
+"            - `[p]cleanup between 123456789123456789 987654321987654321`\n\n"
+"        **Arguments:**\n\n"
+"        - `<one>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<two>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:438
+#, docstring
+msgid "Delete the last X messages in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup messages 26`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:476
+#, docstring
+msgid "Clean up command messages and messages from the bot in the current channel.\n\n"
+"        Can only cleanup custom commands and alias commands if those cogs are loaded.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:564
+#, docstring
+msgid "Clean up messages owned by the bot in the current channel.\n\n"
+"        By default, all messages are cleaned. If a second argument is specified,\n"
+"        it is used for pattern matching - only messages containing the given text will be deleted.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup self 6`\n"
+"            - `[p]cleanup self 10 Pong`\n"
+"            - `[p]cleanup self 7 \"\" True`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<match_pattern>` The text that messages must contain to be deleted. Use \"\" to skip this.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:650
+#, docstring
+msgid "Deletes duplicate messages in the channel from the last X messages and keeps only one copy.\n\n"
+"        Defaults to 50.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The number of messages to check for duplicates. Must be a positive integer.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:17
+msgid "{} doesn't look like a valid message ID."
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:29
+msgid "{arg} is not an integer."
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:31
+msgid "{arg} is not a positive integer."
+msgstr ""
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/cleanup/locales/de-DE.po

@@ -0,0 +1,167 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-05-23 14:25+0000\n"
+"Last-Translator: \n"
+"Language-Team: German\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: de\n"
+"X-Crowdin-File-ID: 31\n"
+"Language: de_DE\n"
+
+#: redbot/cogs/cleanup/cleanup.py:23
+#, docstring
+msgid "This cog contains commands used for \"cleaning up\" (deleting) messages.\n\n"
+"    This is designed as a moderator tool and offers many convenient use cases.\n"
+"    All cleanup commands only apply to the channel the command is executed in.\n\n"
+"    Messages older than two weeks cannot be mass deleted.\n"
+"    This is a limitation of the API.\n"
+"    "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:54
+msgid "Are you sure you want to delete {number} messages? (y/n)"
+msgstr "Bist du dir sicher, dass du {number} Nachrichten löschen möchtest? (y/n)"
+
+#: redbot/cogs/cleanup/cleanup.py:68
+msgid "Cancelled."
+msgstr "Abgebrochen."
+
+#: redbot/cogs/cleanup/cleanup.py:144
+#, docstring
+msgid "Base command for deleting messages."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:154
+#, docstring
+msgid "Delete the last X messages matching the specified text in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup text \"test\" 5`\n\n"
+"        Remember to use double quotes.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:209
+#, docstring
+msgid "Delete the last X messages from a specified user in the current channel.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup user @Twentysix 2`\n"
+"            - `[p]cleanup user Red 6`\n\n"
+"        **Arguments:**\n\n"
+"        - `<user>` The user whose messages are to be cleaned up.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:282
+#, docstring
+msgid "Delete all messages after a specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages after it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:303 redbot/cogs/cleanup/cleanup.py:357
+msgid "Message not found."
+msgstr "Nachricht nicht gefunden."
+
+#: redbot/cogs/cleanup/cleanup.py:335
+#, docstring
+msgid "Deletes X messages before the specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages before it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:390
+#, docstring
+msgid "Delete the messages between Message One and Message Two, providing the messages IDs.\n\n"
+"        The first message ID should be the older message and the second one the newer.\n\n"
+"        Example:\n"
+"            - `[p]cleanup between 123456789123456789 987654321987654321`\n\n"
+"        **Arguments:**\n\n"
+"        - `<one>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<two>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:438
+#, docstring
+msgid "Delete the last X messages in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup messages 26`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:476
+#, docstring
+msgid "Clean up command messages and messages from the bot in the current channel.\n\n"
+"        Can only cleanup custom commands and alias commands if those cogs are loaded.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:564
+#, docstring
+msgid "Clean up messages owned by the bot in the current channel.\n\n"
+"        By default, all messages are cleaned. If a second argument is specified,\n"
+"        it is used for pattern matching - only messages containing the given text will be deleted.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup self 6`\n"
+"            - `[p]cleanup self 10 Pong`\n"
+"            - `[p]cleanup self 7 \"\" True`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<match_pattern>` The text that messages must contain to be deleted. Use \"\" to skip this.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:650
+#, docstring
+msgid "Deletes duplicate messages in the channel from the last X messages and keeps only one copy.\n\n"
+"        Defaults to 50.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The number of messages to check for duplicates. Must be a positive integer.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:17
+msgid "{} doesn't look like a valid message ID."
+msgstr "{} scheint keine gültige Nachrichten-ID zu sein."
+
+#: redbot/cogs/cleanup/converters.py:29
+msgid "{arg} is not an integer."
+msgstr "{arg} ist keine ganze Zahl."
+
+#: redbot/cogs/cleanup/converters.py:31
+msgid "{arg} is not a positive integer."
+msgstr "{arg} ist keine positive ganze Zahl."
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/cleanup/locales/es-ES.po

@@ -0,0 +1,238 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-05-23 14:25+0000\n"
+"Last-Translator: \n"
+"Language-Team: Spanish\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: es-ES\n"
+"X-Crowdin-File-ID: 31\n"
+"Language: es_ES\n"
+
+#: redbot/cogs/cleanup/cleanup.py:23
+#, docstring
+msgid "This cog contains commands used for \"cleaning up\" (deleting) messages.\n\n"
+"    This is designed as a moderator tool and offers many convenient use cases.\n"
+"    All cleanup commands only apply to the channel the command is executed in.\n\n"
+"    Messages older than two weeks cannot be mass deleted.\n"
+"    This is a limitation of the API.\n"
+"    "
+msgstr "Este módulo contiene comandos usados para \"limpiar\" (eliminar) mensajes.\n\n"
+"    Esto está diseñado como una herramienta de moderación y ofrece muchos casos de uso convenientes.\n"
+"    Todos los comandos de limpieza sólo se aplican al canal en el que se ejecuta el comando.\n\n"
+"    Los mensajes anteriores a dos semanas no pueden ser eliminados en masa.\n"
+"    Esto es una limitación de la API.\n"
+"    "
+
+#: redbot/cogs/cleanup/cleanup.py:54
+msgid "Are you sure you want to delete {number} messages? (y/n)"
+msgstr "Estas seguro que quieres borrar {number} mensajes? (y/n)"
+
+#: redbot/cogs/cleanup/cleanup.py:68
+msgid "Cancelled."
+msgstr "Cancelado."
+
+#: redbot/cogs/cleanup/cleanup.py:144
+#, docstring
+msgid "Base command for deleting messages."
+msgstr "Comando base para eliminar mensajes."
+
+#: redbot/cogs/cleanup/cleanup.py:154
+#, docstring
+msgid "Delete the last X messages matching the specified text in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup text \"test\" 5`\n\n"
+"        Remember to use double quotes.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr "Elimina los últimos x mensajes que coincidían con el texto que has especificado en este canal. \n\n"
+"             Ejemplo:\n"
+"             - `[p]cleanup text \"prueba\" 5`\n\n"
+"        Recuerda usar las doble comillas.\n\n"
+"        **Argumentos:**\n\n"
+"        - `<number>`El número máximo de mensajes para borrar. Tiene que ser un numero entero positivo.\n"
+"        - `<delete_pinned>` Para eliminar un mensaje fijado o no. Por defecto es false \n"
+"        "
+
+#: redbot/cogs/cleanup/cleanup.py:209
+#, docstring
+msgid "Delete the last X messages from a specified user in the current channel.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup user @Twentysix 2`\n"
+"            - `[p]cleanup user Red 6`\n\n"
+"        **Arguments:**\n\n"
+"        - `<user>` The user whose messages are to be cleaned up.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr "Eliminar los últimos X mensajes de un usuario especificado.\n\n"
+"        Ejemplos:\n"
+"            - `[p]cleanup user @Twentysix 2`\n"
+"            - `[p]cleanup user Red 6`\n\n"
+"        **Argumentos:**\n\n"
+"        - `<user>` El usuario cuyos mensajes serán limpiados.\n"
+"        - `<number>` El número máximo de mensajes a limpiar. Debe ser un entero positivo.\n"
+"        - `<delete_pinned>` Si eliminar mensajes fijados o no. Por defecto es False\n"
+"        "
+
+#: redbot/cogs/cleanup/cleanup.py:282
+#, docstring
+msgid "Delete all messages after a specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages after it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr "Borrar todos los mensajes después de un mensaje especificado.\n\n"
+"        Para obtener un id de mensaje habilitar el modo de desarrollador en la configuración\n"
+"        de Discord, pestaña de 'apariencia'. Luego haga clic derecho en un mensaje\n"
+"        y copie su id.\n"
+"        Responder a un mensaje limpiará todos los mensajes después de él.\n\n"
+"        **Argumentos:**\n\n"
+"        - `<message_id>` El id del mensaje a limpiar después. Este mensaje no se eliminará.\n"
+"        - `<delete_pinned>` Si borrar o no los mensajes fijados. Por defecto es False\n"
+"        "
+
+#: redbot/cogs/cleanup/cleanup.py:303 redbot/cogs/cleanup/cleanup.py:357
+msgid "Message not found."
+msgstr "Mensaje no encontrado."
+
+#: redbot/cogs/cleanup/cleanup.py:335
+#, docstring
+msgid "Deletes X messages before the specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages before it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr "Elimina X mensajes antes del mensaje especificado.\n\n"
+"        Para obtener un id de mensaje habilitar el modo de desarrollador en la configuración\n"
+"        de Discord, pestaña de 'apariencia'. Luego haga clic derecho en un mensaje\n"
+"        y copie su id.\n"
+"        Responder a un mensaje limpiará todos los mensajes antes de él.\n\n"
+"        **Argumentos:**\n\n"
+"        - `<message_id>` El id del mensaje a limpiar antes. Este mensaje no se eliminará.\n"
+"        - `<number>` El número máximo de mensajes a limpiar. Debe ser un entero positivo.\n"
+"        - `<delete_pinned>` Si eliminar o no los mensajes fijos. Por defecto es False\n"
+"        "
+
+#: redbot/cogs/cleanup/cleanup.py:390
+#, docstring
+msgid "Delete the messages between Message One and Message Two, providing the messages IDs.\n\n"
+"        The first message ID should be the older message and the second one the newer.\n\n"
+"        Example:\n"
+"            - `[p]cleanup between 123456789123456789 987654321987654321`\n\n"
+"        **Arguments:**\n\n"
+"        - `<one>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<two>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr "Elimine los mensajes entre el mensaje Uno y el mensaje dos, proporcionando los identificadores de los mensajes.\n\n"
+"        El primer ID del mensaje debe ser el mensaje más antiguo y el segundo el más nuevo.\n\n"
+"        Ejemplo:\n"
+"            - `[p]limpieza entre 123456789123456789 987654321987654321`\n\n"
+"        **Argumentos:**\n\n"
+"        - `<one>` El id del mensaje a limpiar después. Este mensaje no se eliminará.\n"
+"        - `<two>` El id del mensaje a limpiar antes. Este mensaje no se eliminará.\n"
+"        - `<delete_pinned>` Si eliminar mensajes fijados o no. Por defecto es False\n"
+"        "
+
+#: redbot/cogs/cleanup/cleanup.py:438
+#, docstring
+msgid "Delete the last X messages in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup messages 26`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr "Eliminar los últimos mensajes X en el canal actual.\n\n"
+"        Ejemplo:\n"
+"            - `[p]cleanup message 26`\n\n"
+"        **Argumentos:**\n\n"
+"        - `<number>` El número máximo de mensajes a limpiar. Debe ser un entero positivo.\n"
+"        - `<delete_pinned>` Si desea eliminar mensajes fijados o no. Por defecto es False\n"
+"        "
+
+#: redbot/cogs/cleanup/cleanup.py:476
+#, docstring
+msgid "Clean up command messages and messages from the bot in the current channel.\n\n"
+"        Can only cleanup custom commands and alias commands if those cogs are loaded.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr "Limpiar mensajes de comandos y mensajes del bot en el canal actual.\n\n"
+"        Sólo puede limpiar comandos personalizados y comandos de alias si se cargan esos programas.\n\n"
+"        **Argumentos:**\n\n"
+"        - `<number>` El número máximo de mensajes a limpiar. Debe ser un entero positivo.\n"
+"        - `<delete_pinned>` Si eliminar mensajes fijados o no. Por defecto es False\n"
+"        "
+
+#: redbot/cogs/cleanup/cleanup.py:564
+#, docstring
+msgid "Clean up messages owned by the bot in the current channel.\n\n"
+"        By default, all messages are cleaned. If a second argument is specified,\n"
+"        it is used for pattern matching - only messages containing the given text will be deleted.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup self 6`\n"
+"            - `[p]cleanup self 10 Pong`\n"
+"            - `[p]cleanup self 7 \"\" True`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<match_pattern>` The text that messages must contain to be deleted. Use \"\" to skip this.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr "Limpia los mensajes enviados por el bot en el canal actual.\n\n"
+"        Por defecto, todos los mensajes se limpian. Si se especifica un segundo argumento,\n"
+"        se utiliza para la coincidencia de patrones - sólo los mensajes que contengan el texto dado serán eliminados.\n\n"
+"        Ejemplos:\n"
+"            - `[p]cleanup self 6`\n"
+"            - `[p]cleanup self 10 Pong`\n"
+"            - `[p]cleanup self 7 \"\" True`\n\n"
+"        **Argumentos:**\n\n"
+"        - `<number>` El número máximo de mensajes a limpiar. Debe ser un entero positivo.\n"
+"        - `<match_pattern>` El texto que los mensajes deben contener para ser eliminados. Usa \"\" para omitir esto.\n"
+"        - `<delete_pinned>` Si eliminar mensajes fijados o no. Por defecto es False\n"
+"        "
+
+#: redbot/cogs/cleanup/cleanup.py:650
+#, docstring
+msgid "Deletes duplicate messages in the channel from the last X messages and keeps only one copy.\n\n"
+"        Defaults to 50.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The number of messages to check for duplicates. Must be a positive integer.\n"
+"        "
+msgstr "Elimina mensajes duplicados en el canal de los últimos X mensajes  y conserva sólo una copia.\n\n"
+"        Por defecto es 50.\n\n"
+"        **Argumentos:**\n\n"
+"        - `<number>` El número de mensajes a buscar duplicados. Debe ser un entero positivo.\n"
+"        "
+
+#: redbot/cogs/cleanup/converters.py:17
+msgid "{} doesn't look like a valid message ID."
+msgstr "{} no parece una ID de mensaje válido."
+
+#: redbot/cogs/cleanup/converters.py:29
+msgid "{arg} is not an integer."
+msgstr "{arg} no es un entero."
+
+#: redbot/cogs/cleanup/converters.py:31
+msgid "{arg} is not a positive integer."
+msgstr "{arg} no es un entero positivo."
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/cleanup/locales/fi-FI.po

@@ -0,0 +1,167 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-05-23 14:25+0000\n"
+"Last-Translator: \n"
+"Language-Team: Finnish\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: fi\n"
+"X-Crowdin-File-ID: 31\n"
+"Language: fi_FI\n"
+
+#: redbot/cogs/cleanup/cleanup.py:23
+#, docstring
+msgid "This cog contains commands used for \"cleaning up\" (deleting) messages.\n\n"
+"    This is designed as a moderator tool and offers many convenient use cases.\n"
+"    All cleanup commands only apply to the channel the command is executed in.\n\n"
+"    Messages older than two weeks cannot be mass deleted.\n"
+"    This is a limitation of the API.\n"
+"    "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:54
+msgid "Are you sure you want to delete {number} messages? (y/n)"
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:68
+msgid "Cancelled."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:144
+#, docstring
+msgid "Base command for deleting messages."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:154
+#, docstring
+msgid "Delete the last X messages matching the specified text in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup text \"test\" 5`\n\n"
+"        Remember to use double quotes.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:209
+#, docstring
+msgid "Delete the last X messages from a specified user in the current channel.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup user @Twentysix 2`\n"
+"            - `[p]cleanup user Red 6`\n\n"
+"        **Arguments:**\n\n"
+"        - `<user>` The user whose messages are to be cleaned up.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:282
+#, docstring
+msgid "Delete all messages after a specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages after it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:303 redbot/cogs/cleanup/cleanup.py:357
+msgid "Message not found."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:335
+#, docstring
+msgid "Deletes X messages before the specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages before it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:390
+#, docstring
+msgid "Delete the messages between Message One and Message Two, providing the messages IDs.\n\n"
+"        The first message ID should be the older message and the second one the newer.\n\n"
+"        Example:\n"
+"            - `[p]cleanup between 123456789123456789 987654321987654321`\n\n"
+"        **Arguments:**\n\n"
+"        - `<one>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<two>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:438
+#, docstring
+msgid "Delete the last X messages in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup messages 26`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:476
+#, docstring
+msgid "Clean up command messages and messages from the bot in the current channel.\n\n"
+"        Can only cleanup custom commands and alias commands if those cogs are loaded.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:564
+#, docstring
+msgid "Clean up messages owned by the bot in the current channel.\n\n"
+"        By default, all messages are cleaned. If a second argument is specified,\n"
+"        it is used for pattern matching - only messages containing the given text will be deleted.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup self 6`\n"
+"            - `[p]cleanup self 10 Pong`\n"
+"            - `[p]cleanup self 7 \"\" True`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<match_pattern>` The text that messages must contain to be deleted. Use \"\" to skip this.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:650
+#, docstring
+msgid "Deletes duplicate messages in the channel from the last X messages and keeps only one copy.\n\n"
+"        Defaults to 50.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The number of messages to check for duplicates. Must be a positive integer.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:17
+msgid "{} doesn't look like a valid message ID."
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:29
+msgid "{arg} is not an integer."
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:31
+msgid "{arg} is not a positive integer."
+msgstr ""
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/cleanup/locales/fr-FR.po

@@ -0,0 +1,176 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-05-23 14:25+0000\n"
+"Last-Translator: \n"
+"Language-Team: French\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=2; plural=(n > 1);\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: fr\n"
+"X-Crowdin-File-ID: 31\n"
+"Language: fr_FR\n"
+
+#: redbot/cogs/cleanup/cleanup.py:23
+#, docstring
+msgid "This cog contains commands used for \"cleaning up\" (deleting) messages.\n\n"
+"    This is designed as a moderator tool and offers many convenient use cases.\n"
+"    All cleanup commands only apply to the channel the command is executed in.\n\n"
+"    Messages older than two weeks cannot be mass deleted.\n"
+"    This is a limitation of the API.\n"
+"    "
+msgstr "Ce cog contient des commandes utilisées pour \"nettoyer\" (supprimer) des messages.\n\n"
+"    Il a été conçu comme un outil de modérateur et offre de nombreux cas d'usage.\n"
+"    Toutes les commandes de suppression s'appliquent seulement dans le salon dans lequel la commande est exécutée.\n\n"
+"    Les messages de plus de deux semaines ne peuvent pas être supprimés en masse.\n"
+"    Ceci est une limitation de l'API.\n"
+"    "
+
+#: redbot/cogs/cleanup/cleanup.py:54
+msgid "Are you sure you want to delete {number} messages? (y/n)"
+msgstr "Êtes vous sûr de supprimer {number} messages ? (y/n)"
+
+#: redbot/cogs/cleanup/cleanup.py:68
+msgid "Cancelled."
+msgstr "Annulé."
+
+#: redbot/cogs/cleanup/cleanup.py:144
+#, docstring
+msgid "Base command for deleting messages."
+msgstr "Commande de base pour supprimer les messages."
+
+#: redbot/cogs/cleanup/cleanup.py:154
+#, docstring
+msgid "Delete the last X messages matching the specified text in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup text \"test\" 5`\n\n"
+"        Remember to use double quotes.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:209
+#, docstring
+msgid "Delete the last X messages from a specified user in the current channel.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup user @Twentysix 2`\n"
+"            - `[p]cleanup user Red 6`\n\n"
+"        **Arguments:**\n\n"
+"        - `<user>` The user whose messages are to be cleaned up.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:282
+#, docstring
+msgid "Delete all messages after a specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages after it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:303 redbot/cogs/cleanup/cleanup.py:357
+msgid "Message not found."
+msgstr "Message introuvable."
+
+#: redbot/cogs/cleanup/cleanup.py:335
+#, docstring
+msgid "Deletes X messages before the specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages before it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:390
+#, docstring
+msgid "Delete the messages between Message One and Message Two, providing the messages IDs.\n\n"
+"        The first message ID should be the older message and the second one the newer.\n\n"
+"        Example:\n"
+"            - `[p]cleanup between 123456789123456789 987654321987654321`\n\n"
+"        **Arguments:**\n\n"
+"        - `<one>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<two>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:438
+#, docstring
+msgid "Delete the last X messages in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup messages 26`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:476
+#, docstring
+msgid "Clean up command messages and messages from the bot in the current channel.\n\n"
+"        Can only cleanup custom commands and alias commands if those cogs are loaded.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:564
+#, docstring
+msgid "Clean up messages owned by the bot in the current channel.\n\n"
+"        By default, all messages are cleaned. If a second argument is specified,\n"
+"        it is used for pattern matching - only messages containing the given text will be deleted.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup self 6`\n"
+"            - `[p]cleanup self 10 Pong`\n"
+"            - `[p]cleanup self 7 \"\" True`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<match_pattern>` The text that messages must contain to be deleted. Use \"\" to skip this.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:650
+#, docstring
+msgid "Deletes duplicate messages in the channel from the last X messages and keeps only one copy.\n\n"
+"        Defaults to 50.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The number of messages to check for duplicates. Must be a positive integer.\n"
+"        "
+msgstr "Supprime les messages dupliquées dans le salon depuis les X derniers messages et garde une seule copie.\n\n"
+"        Par défaut à 50.\n\n"
+"**Arguments:**\n\n"
+"        - `<number>` Le nombre de message à vérifier comme doublon. Doit être un nombre positif.\n"
+"        "
+
+#: redbot/cogs/cleanup/converters.py:17
+msgid "{} doesn't look like a valid message ID."
+msgstr "{} ne ressemble pas à un ID de message valide."
+
+#: redbot/cogs/cleanup/converters.py:29
+msgid "{arg} is not an integer."
+msgstr "{arg} n'est pas un nombre."
+
+#: redbot/cogs/cleanup/converters.py:31
+msgid "{arg} is not a positive integer."
+msgstr "{arg} n'est pas un nombre positif."
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/cleanup/locales/hu-HU.po

@@ -0,0 +1,184 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-05-23 14:25+0000\n"
+"Last-Translator: \n"
+"Language-Team: Hungarian\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: hu\n"
+"X-Crowdin-File-ID: 31\n"
+"Language: hu_HU\n"
+
+#: redbot/cogs/cleanup/cleanup.py:23
+#, docstring
+msgid "This cog contains commands used for \"cleaning up\" (deleting) messages.\n\n"
+"    This is designed as a moderator tool and offers many convenient use cases.\n"
+"    All cleanup commands only apply to the channel the command is executed in.\n\n"
+"    Messages older than two weeks cannot be mass deleted.\n"
+"    This is a limitation of the API.\n"
+"    "
+msgstr "Ez a cog üzenetek \"tisztogatására\" (törlésére) szolgáló parancsokat tartalmaz.\n\n"
+"    Ez egy moderációs eszköznek lett tervezve, és számos kényelmes funckiót tartalmaz.\n"
+"    Az összes tisztogató parancs arra a csatornára vonatkozik, ahol az ki volt adva.\n\n"
+"    A két hétnél régebbi üzenetek nem törölhetőek csoportosan.\n"
+"    Ez az API limitációja.\n"
+"    "
+
+#: redbot/cogs/cleanup/cleanup.py:54
+msgid "Are you sure you want to delete {number} messages? (y/n)"
+msgstr "Biztosan törölni akarsz {number} üzenetet? (y/n)"
+
+#: redbot/cogs/cleanup/cleanup.py:68
+msgid "Cancelled."
+msgstr "Megszakítva."
+
+#: redbot/cogs/cleanup/cleanup.py:144
+#, docstring
+msgid "Base command for deleting messages."
+msgstr "Alap parancs üzenetek törlésére."
+
+#: redbot/cogs/cleanup/cleanup.py:154
+#, docstring
+msgid "Delete the last X messages matching the specified text in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup text \"test\" 5`\n\n"
+"        Remember to use double quotes.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:209
+#, docstring
+msgid "Delete the last X messages from a specified user in the current channel.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup user @Twentysix 2`\n"
+"            - `[p]cleanup user Red 6`\n\n"
+"        **Arguments:**\n\n"
+"        - `<user>` The user whose messages are to be cleaned up.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:282
+#, docstring
+msgid "Delete all messages after a specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages after it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:303 redbot/cogs/cleanup/cleanup.py:357
+msgid "Message not found."
+msgstr "Üzenet nem található."
+
+#: redbot/cogs/cleanup/cleanup.py:335
+#, docstring
+msgid "Deletes X messages before the specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages before it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:390
+#, docstring
+msgid "Delete the messages between Message One and Message Two, providing the messages IDs.\n\n"
+"        The first message ID should be the older message and the second one the newer.\n\n"
+"        Example:\n"
+"            - `[p]cleanup between 123456789123456789 987654321987654321`\n\n"
+"        **Arguments:**\n\n"
+"        - `<one>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<two>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr "Törli az üzeneteket a két megadott üzenet között.\n\n"
+"        Az első üzenet ID a régebbi, a második az újabb kell legyen.\n\n"
+"        Például:\n"
+"        - `[p]cleanup between 123456789123456789 987654321987654321`\n\n"
+"        **Paraméterek:**\n\n"
+"        - `<one>` Az első üzenet ID-je. Ez még nem lesz törölve.\n"
+"        - `<two>` A második üzenet ID-je. Ez már nem lesz törölve.\n"
+"        - `<delete_pinned>` Törölje-e a kitűzött üzeneteket is. Alapértelmezetten hamis (False)\n"
+"        "
+
+#: redbot/cogs/cleanup/cleanup.py:438
+#, docstring
+msgid "Delete the last X messages in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup messages 26`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:476
+#, docstring
+msgid "Clean up command messages and messages from the bot in the current channel.\n\n"
+"        Can only cleanup custom commands and alias commands if those cogs are loaded.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:564
+#, docstring
+msgid "Clean up messages owned by the bot in the current channel.\n\n"
+"        By default, all messages are cleaned. If a second argument is specified,\n"
+"        it is used for pattern matching - only messages containing the given text will be deleted.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup self 6`\n"
+"            - `[p]cleanup self 10 Pong`\n"
+"            - `[p]cleanup self 7 \"\" True`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<match_pattern>` The text that messages must contain to be deleted. Use \"\" to skip this.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:650
+#, docstring
+msgid "Deletes duplicate messages in the channel from the last X messages and keeps only one copy.\n\n"
+"        Defaults to 50.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The number of messages to check for duplicates. Must be a positive integer.\n"
+"        "
+msgstr "A legutóbbi X üzenet közül törli a duplikált üzeneteket a csatornában, és csak egy üzenetet tart meg belőle.\n\n"
+"        Alapértelmezetten 50 üzenet közül.\n\n"
+"        **Paraméterek**:\n\n"
+"        - `<number>` Az üzenetek száma, amik között a duplikáltakat keresi. Pozitív egész szám kell legyen.\n"
+"        "
+
+#: redbot/cogs/cleanup/converters.py:17
+msgid "{} doesn't look like a valid message ID."
+msgstr "{} nem tűnik valós üzenet ID-nek."
+
+#: redbot/cogs/cleanup/converters.py:29
+msgid "{arg} is not an integer."
+msgstr "{arg} nem egy egész szám."
+
+#: redbot/cogs/cleanup/converters.py:31
+msgid "{arg} is not a positive integer."
+msgstr "{arg} nem egy pozitív egész szám."
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/cleanup/locales/id-ID.po

@@ -0,0 +1,167 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-05-23 14:25+0000\n"
+"Last-Translator: \n"
+"Language-Team: Indonesian\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: id\n"
+"X-Crowdin-File-ID: 31\n"
+"Language: id_ID\n"
+
+#: redbot/cogs/cleanup/cleanup.py:23
+#, docstring
+msgid "This cog contains commands used for \"cleaning up\" (deleting) messages.\n\n"
+"    This is designed as a moderator tool and offers many convenient use cases.\n"
+"    All cleanup commands only apply to the channel the command is executed in.\n\n"
+"    Messages older than two weeks cannot be mass deleted.\n"
+"    This is a limitation of the API.\n"
+"    "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:54
+msgid "Are you sure you want to delete {number} messages? (y/n)"
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:68
+msgid "Cancelled."
+msgstr "Dibatalkan."
+
+#: redbot/cogs/cleanup/cleanup.py:144
+#, docstring
+msgid "Base command for deleting messages."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:154
+#, docstring
+msgid "Delete the last X messages matching the specified text in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup text \"test\" 5`\n\n"
+"        Remember to use double quotes.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:209
+#, docstring
+msgid "Delete the last X messages from a specified user in the current channel.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup user @Twentysix 2`\n"
+"            - `[p]cleanup user Red 6`\n\n"
+"        **Arguments:**\n\n"
+"        - `<user>` The user whose messages are to be cleaned up.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:282
+#, docstring
+msgid "Delete all messages after a specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages after it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:303 redbot/cogs/cleanup/cleanup.py:357
+msgid "Message not found."
+msgstr "Pesan tidak ditemukan."
+
+#: redbot/cogs/cleanup/cleanup.py:335
+#, docstring
+msgid "Deletes X messages before the specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages before it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:390
+#, docstring
+msgid "Delete the messages between Message One and Message Two, providing the messages IDs.\n\n"
+"        The first message ID should be the older message and the second one the newer.\n\n"
+"        Example:\n"
+"            - `[p]cleanup between 123456789123456789 987654321987654321`\n\n"
+"        **Arguments:**\n\n"
+"        - `<one>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<two>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:438
+#, docstring
+msgid "Delete the last X messages in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup messages 26`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:476
+#, docstring
+msgid "Clean up command messages and messages from the bot in the current channel.\n\n"
+"        Can only cleanup custom commands and alias commands if those cogs are loaded.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:564
+#, docstring
+msgid "Clean up messages owned by the bot in the current channel.\n\n"
+"        By default, all messages are cleaned. If a second argument is specified,\n"
+"        it is used for pattern matching - only messages containing the given text will be deleted.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup self 6`\n"
+"            - `[p]cleanup self 10 Pong`\n"
+"            - `[p]cleanup self 7 \"\" True`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<match_pattern>` The text that messages must contain to be deleted. Use \"\" to skip this.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:650
+#, docstring
+msgid "Deletes duplicate messages in the channel from the last X messages and keeps only one copy.\n\n"
+"        Defaults to 50.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The number of messages to check for duplicates. Must be a positive integer.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:17
+msgid "{} doesn't look like a valid message ID."
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:29
+msgid "{arg} is not an integer."
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:31
+msgid "{arg} is not a positive integer."
+msgstr ""
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/cleanup/locales/it-IT.po

@@ -0,0 +1,167 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-05-23 14:25+0000\n"
+"Last-Translator: \n"
+"Language-Team: Italian\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: it\n"
+"X-Crowdin-File-ID: 31\n"
+"Language: it_IT\n"
+
+#: redbot/cogs/cleanup/cleanup.py:23
+#, docstring
+msgid "This cog contains commands used for \"cleaning up\" (deleting) messages.\n\n"
+"    This is designed as a moderator tool and offers many convenient use cases.\n"
+"    All cleanup commands only apply to the channel the command is executed in.\n\n"
+"    Messages older than two weeks cannot be mass deleted.\n"
+"    This is a limitation of the API.\n"
+"    "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:54
+msgid "Are you sure you want to delete {number} messages? (y/n)"
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:68
+msgid "Cancelled."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:144
+#, docstring
+msgid "Base command for deleting messages."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:154
+#, docstring
+msgid "Delete the last X messages matching the specified text in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup text \"test\" 5`\n\n"
+"        Remember to use double quotes.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:209
+#, docstring
+msgid "Delete the last X messages from a specified user in the current channel.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup user @Twentysix 2`\n"
+"            - `[p]cleanup user Red 6`\n\n"
+"        **Arguments:**\n\n"
+"        - `<user>` The user whose messages are to be cleaned up.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:282
+#, docstring
+msgid "Delete all messages after a specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages after it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:303 redbot/cogs/cleanup/cleanup.py:357
+msgid "Message not found."
+msgstr "Messaggio non trovato."
+
+#: redbot/cogs/cleanup/cleanup.py:335
+#, docstring
+msgid "Deletes X messages before the specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages before it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:390
+#, docstring
+msgid "Delete the messages between Message One and Message Two, providing the messages IDs.\n\n"
+"        The first message ID should be the older message and the second one the newer.\n\n"
+"        Example:\n"
+"            - `[p]cleanup between 123456789123456789 987654321987654321`\n\n"
+"        **Arguments:**\n\n"
+"        - `<one>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<two>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:438
+#, docstring
+msgid "Delete the last X messages in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup messages 26`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:476
+#, docstring
+msgid "Clean up command messages and messages from the bot in the current channel.\n\n"
+"        Can only cleanup custom commands and alias commands if those cogs are loaded.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:564
+#, docstring
+msgid "Clean up messages owned by the bot in the current channel.\n\n"
+"        By default, all messages are cleaned. If a second argument is specified,\n"
+"        it is used for pattern matching - only messages containing the given text will be deleted.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup self 6`\n"
+"            - `[p]cleanup self 10 Pong`\n"
+"            - `[p]cleanup self 7 \"\" True`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<match_pattern>` The text that messages must contain to be deleted. Use \"\" to skip this.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:650
+#, docstring
+msgid "Deletes duplicate messages in the channel from the last X messages and keeps only one copy.\n\n"
+"        Defaults to 50.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The number of messages to check for duplicates. Must be a positive integer.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:17
+msgid "{} doesn't look like a valid message ID."
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:29
+msgid "{arg} is not an integer."
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:31
+msgid "{arg} is not a positive integer."
+msgstr ""
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/cleanup/locales/ja-JP.po

@@ -0,0 +1,167 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-05-23 14:25+0000\n"
+"Last-Translator: \n"
+"Language-Team: Japanese\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: ja\n"
+"X-Crowdin-File-ID: 31\n"
+"Language: ja_JP\n"
+
+#: redbot/cogs/cleanup/cleanup.py:23
+#, docstring
+msgid "This cog contains commands used for \"cleaning up\" (deleting) messages.\n\n"
+"    This is designed as a moderator tool and offers many convenient use cases.\n"
+"    All cleanup commands only apply to the channel the command is executed in.\n\n"
+"    Messages older than two weeks cannot be mass deleted.\n"
+"    This is a limitation of the API.\n"
+"    "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:54
+msgid "Are you sure you want to delete {number} messages? (y/n)"
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:68
+msgid "Cancelled."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:144
+#, docstring
+msgid "Base command for deleting messages."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:154
+#, docstring
+msgid "Delete the last X messages matching the specified text in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup text \"test\" 5`\n\n"
+"        Remember to use double quotes.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:209
+#, docstring
+msgid "Delete the last X messages from a specified user in the current channel.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup user @Twentysix 2`\n"
+"            - `[p]cleanup user Red 6`\n\n"
+"        **Arguments:**\n\n"
+"        - `<user>` The user whose messages are to be cleaned up.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:282
+#, docstring
+msgid "Delete all messages after a specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages after it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:303 redbot/cogs/cleanup/cleanup.py:357
+msgid "Message not found."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:335
+#, docstring
+msgid "Deletes X messages before the specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages before it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:390
+#, docstring
+msgid "Delete the messages between Message One and Message Two, providing the messages IDs.\n\n"
+"        The first message ID should be the older message and the second one the newer.\n\n"
+"        Example:\n"
+"            - `[p]cleanup between 123456789123456789 987654321987654321`\n\n"
+"        **Arguments:**\n\n"
+"        - `<one>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<two>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:438
+#, docstring
+msgid "Delete the last X messages in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup messages 26`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:476
+#, docstring
+msgid "Clean up command messages and messages from the bot in the current channel.\n\n"
+"        Can only cleanup custom commands and alias commands if those cogs are loaded.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:564
+#, docstring
+msgid "Clean up messages owned by the bot in the current channel.\n\n"
+"        By default, all messages are cleaned. If a second argument is specified,\n"
+"        it is used for pattern matching - only messages containing the given text will be deleted.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup self 6`\n"
+"            - `[p]cleanup self 10 Pong`\n"
+"            - `[p]cleanup self 7 \"\" True`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<match_pattern>` The text that messages must contain to be deleted. Use \"\" to skip this.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:650
+#, docstring
+msgid "Deletes duplicate messages in the channel from the last X messages and keeps only one copy.\n\n"
+"        Defaults to 50.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The number of messages to check for duplicates. Must be a positive integer.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:17
+msgid "{} doesn't look like a valid message ID."
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:29
+msgid "{arg} is not an integer."
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:31
+msgid "{arg} is not a positive integer."
+msgstr ""
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/cleanup/locales/nb-NO.po

@@ -0,0 +1,201 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-05-23 14:25+0000\n"
+"Last-Translator: \n"
+"Language-Team: Norwegian Bokmal\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: nb\n"
+"X-Crowdin-File-ID: 31\n"
+"Language: nb_NO\n"
+
+#: redbot/cogs/cleanup/cleanup.py:23
+#, docstring
+msgid "This cog contains commands used for \"cleaning up\" (deleting) messages.\n\n"
+"    This is designed as a moderator tool and offers many convenient use cases.\n"
+"    All cleanup commands only apply to the channel the command is executed in.\n\n"
+"    Messages older than two weeks cannot be mass deleted.\n"
+"    This is a limitation of the API.\n"
+"    "
+msgstr "Denne cog'en inneholder kommandoer som brukes for \"rengjøre\" (slette) meldinger.\n\n"
+"    Denne er utformet som et moderatorverktøy og tilbyr mange praktiske brukstilfeller.\n"
+"    Alle oppryddingskommandoer gjelder bare for kanalen kommandoen brukes i.\n\n"
+"    Meldinger eldre enn to uker kan ikke masseslettes.\n"
+"    Dette er en begrensning i APIet.\n"
+"    "
+
+#: redbot/cogs/cleanup/cleanup.py:54
+msgid "Are you sure you want to delete {number} messages? (y/n)"
+msgstr "Er du sikker på at du vil slette {number} meldinger? (y/n)"
+
+#: redbot/cogs/cleanup/cleanup.py:68
+msgid "Cancelled."
+msgstr "Kansellert."
+
+#: redbot/cogs/cleanup/cleanup.py:144
+#, docstring
+msgid "Base command for deleting messages."
+msgstr "Basiskommando for sletting av meldinger."
+
+#: redbot/cogs/cleanup/cleanup.py:154
+#, docstring
+msgid "Delete the last X messages matching the specified text in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup text \"test\" 5`\n\n"
+"        Remember to use double quotes.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:209
+#, docstring
+msgid "Delete the last X messages from a specified user in the current channel.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup user @Twentysix 2`\n"
+"            - `[p]cleanup user Red 6`\n\n"
+"        **Arguments:**\n\n"
+"        - `<user>` The user whose messages are to be cleaned up.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:282
+#, docstring
+msgid "Delete all messages after a specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages after it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr "Slett alle meldinger etter en spesifisert melding.\n\n"
+"        For å få beskjed id aktiver utviklermodus i Discord's\n"
+"        innstillinger, 'utseende' fanen. Deretter klikker du en melding\n"
+"        og kopierer sin id.\n"
+"        svarer på en melding kommer til å rydde opp alle meldinger etter den.\n\n"
+"        **Argumenter:**\n\n"
+"        - `<message_id>` beskjeden er id for å rydde opp senere. Denne meldingen vil ikke bli slettet.\n"
+"        - `<delete_pinned>` om å slette låste meldinger eller ikke. Standarder på False\n"
+"        "
+
+#: redbot/cogs/cleanup/cleanup.py:303 redbot/cogs/cleanup/cleanup.py:357
+msgid "Message not found."
+msgstr "Melding ikke funnet."
+
+#: redbot/cogs/cleanup/cleanup.py:335
+#, docstring
+msgid "Deletes X messages before the specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages before it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr "Sletter X meldinger før den angitte meldingen.\n\n"
+"        For å få beskjed ID aktiver utviklermodus i Discord's\n"
+"        innstillinger, 'utseende' fanen. Deretter klikker du en melding\n"
+"        og kopierer ID\n"
+"        Svar på en melding for å slette alle meldinger før den\n\n"
+"        **Argumenter:**\n\n"
+"        - `<message_id>` ID-en til meldingen for å rydde opp før. Denne meldingen vil ikke bli slettet.\n"
+"        - `<number>` Maks antall meldinger som skal opp. Må være et positivt heltall.\n"
+"        - `<delete_pinned>` om å slette låste meldinger eller ikke. Standarder til usant\n"
+"        "
+
+#: redbot/cogs/cleanup/cleanup.py:390
+#, docstring
+msgid "Delete the messages between Message One and Message Two, providing the messages IDs.\n\n"
+"        The first message ID should be the older message and the second one the newer.\n\n"
+"        Example:\n"
+"            - `[p]cleanup between 123456789123456789 987654321987654321`\n\n"
+"        **Arguments:**\n\n"
+"        - `<one>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<two>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr "Slett meldingene mellom Melding En og Melding Two, og gjør om meldings-IDer.\n\n"
+"        Den første melding-ID skal være den eldre meldingen og den nest den nyere.\n\n"
+"        Eksempel:\n"
+"            - `[p]cleanup between 123456789123456789 987654321987654321`\n\n"
+"        **Arguments:**\n\n"
+"        - `<one>` Inniden av meldingen til opprydding etterpå. Denne meldingen vil ikke bli slettet.\n"
+"        - `<two>` beskjeden for å rydde opp før. Denne meldingen vil ikke bli slettet.\n"
+"        - `<delete_pinned>` om å slette låste meldinger eller ikke. Standarder til usant\n"
+"        "
+
+#: redbot/cogs/cleanup/cleanup.py:438
+#, docstring
+msgid "Delete the last X messages in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup messages 26`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:476
+#, docstring
+msgid "Clean up command messages and messages from the bot in the current channel.\n\n"
+"        Can only cleanup custom commands and alias commands if those cogs are loaded.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:564
+#, docstring
+msgid "Clean up messages owned by the bot in the current channel.\n\n"
+"        By default, all messages are cleaned. If a second argument is specified,\n"
+"        it is used for pattern matching - only messages containing the given text will be deleted.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup self 6`\n"
+"            - `[p]cleanup self 10 Pong`\n"
+"            - `[p]cleanup self 7 \"\" True`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<match_pattern>` The text that messages must contain to be deleted. Use \"\" to skip this.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:650
+#, docstring
+msgid "Deletes duplicate messages in the channel from the last X messages and keeps only one copy.\n\n"
+"        Defaults to 50.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The number of messages to check for duplicates. Must be a positive integer.\n"
+"        "
+msgstr "Sletter dupliserte meldinger i kanalen fra de siste X meldingene og beholder bare en kopi.\n\n"
+"        Standard til 50.\n\n"
+"        **Argumenter:**\n\n"
+"        - `<number>` Antall meldinger for å sjekke etter duplikater. Må være et positivt heltall.\n"
+"        "
+
+#: redbot/cogs/cleanup/converters.py:17
+msgid "{} doesn't look like a valid message ID."
+msgstr "{} ser ikke ut som en gyldig meldings ID."
+
+#: redbot/cogs/cleanup/converters.py:29
+msgid "{arg} is not an integer."
+msgstr "{arg} er ikke et heltall."
+
+#: redbot/cogs/cleanup/converters.py:31
+msgid "{arg} is not a positive integer."
+msgstr "{arg} er ikke et positivt heltall."
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/cleanup/locales/nl-NL.po

@@ -0,0 +1,167 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-05-23 14:25+0000\n"
+"Last-Translator: \n"
+"Language-Team: Dutch\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: nl\n"
+"X-Crowdin-File-ID: 31\n"
+"Language: nl_NL\n"
+
+#: redbot/cogs/cleanup/cleanup.py:23
+#, docstring
+msgid "This cog contains commands used for \"cleaning up\" (deleting) messages.\n\n"
+"    This is designed as a moderator tool and offers many convenient use cases.\n"
+"    All cleanup commands only apply to the channel the command is executed in.\n\n"
+"    Messages older than two weeks cannot be mass deleted.\n"
+"    This is a limitation of the API.\n"
+"    "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:54
+msgid "Are you sure you want to delete {number} messages? (y/n)"
+msgstr "Weet je zeker dat je {number} berichten wilt verwijderen? (y/n)"
+
+#: redbot/cogs/cleanup/cleanup.py:68
+msgid "Cancelled."
+msgstr "Geannuleerd."
+
+#: redbot/cogs/cleanup/cleanup.py:144
+#, docstring
+msgid "Base command for deleting messages."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:154
+#, docstring
+msgid "Delete the last X messages matching the specified text in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup text \"test\" 5`\n\n"
+"        Remember to use double quotes.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:209
+#, docstring
+msgid "Delete the last X messages from a specified user in the current channel.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup user @Twentysix 2`\n"
+"            - `[p]cleanup user Red 6`\n\n"
+"        **Arguments:**\n\n"
+"        - `<user>` The user whose messages are to be cleaned up.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:282
+#, docstring
+msgid "Delete all messages after a specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages after it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:303 redbot/cogs/cleanup/cleanup.py:357
+msgid "Message not found."
+msgstr "Bericht niet gevonden."
+
+#: redbot/cogs/cleanup/cleanup.py:335
+#, docstring
+msgid "Deletes X messages before the specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages before it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:390
+#, docstring
+msgid "Delete the messages between Message One and Message Two, providing the messages IDs.\n\n"
+"        The first message ID should be the older message and the second one the newer.\n\n"
+"        Example:\n"
+"            - `[p]cleanup between 123456789123456789 987654321987654321`\n\n"
+"        **Arguments:**\n\n"
+"        - `<one>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<two>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:438
+#, docstring
+msgid "Delete the last X messages in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup messages 26`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:476
+#, docstring
+msgid "Clean up command messages and messages from the bot in the current channel.\n\n"
+"        Can only cleanup custom commands and alias commands if those cogs are loaded.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:564
+#, docstring
+msgid "Clean up messages owned by the bot in the current channel.\n\n"
+"        By default, all messages are cleaned. If a second argument is specified,\n"
+"        it is used for pattern matching - only messages containing the given text will be deleted.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup self 6`\n"
+"            - `[p]cleanup self 10 Pong`\n"
+"            - `[p]cleanup self 7 \"\" True`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<match_pattern>` The text that messages must contain to be deleted. Use \"\" to skip this.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:650
+#, docstring
+msgid "Deletes duplicate messages in the channel from the last X messages and keeps only one copy.\n\n"
+"        Defaults to 50.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The number of messages to check for duplicates. Must be a positive integer.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:17
+msgid "{} doesn't look like a valid message ID."
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:29
+msgid "{arg} is not an integer."
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:31
+msgid "{arg} is not a positive integer."
+msgstr ""
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/cleanup/locales/pl-PL.po

@@ -0,0 +1,167 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-05-23 14:25+0000\n"
+"Last-Translator: \n"
+"Language-Team: Polish\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=4; plural=(n==1 ? 0 : (n%10>=2 && n%10<=4) && (n%100<12 || n%100>14) ? 1 : n!=1 && (n%10>=0 && n%10<=1) || (n%10>=5 && n%10<=9) || (n%100>=12 && n%100<=14) ? 2 : 3);\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: pl\n"
+"X-Crowdin-File-ID: 31\n"
+"Language: pl_PL\n"
+
+#: redbot/cogs/cleanup/cleanup.py:23
+#, docstring
+msgid "This cog contains commands used for \"cleaning up\" (deleting) messages.\n\n"
+"    This is designed as a moderator tool and offers many convenient use cases.\n"
+"    All cleanup commands only apply to the channel the command is executed in.\n\n"
+"    Messages older than two weeks cannot be mass deleted.\n"
+"    This is a limitation of the API.\n"
+"    "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:54
+msgid "Are you sure you want to delete {number} messages? (y/n)"
+msgstr "Czy na pewno chcesz usunąć {number} wiadomości? (y/n)"
+
+#: redbot/cogs/cleanup/cleanup.py:68
+msgid "Cancelled."
+msgstr "Anulowano."
+
+#: redbot/cogs/cleanup/cleanup.py:144
+#, docstring
+msgid "Base command for deleting messages."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:154
+#, docstring
+msgid "Delete the last X messages matching the specified text in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup text \"test\" 5`\n\n"
+"        Remember to use double quotes.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:209
+#, docstring
+msgid "Delete the last X messages from a specified user in the current channel.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup user @Twentysix 2`\n"
+"            - `[p]cleanup user Red 6`\n\n"
+"        **Arguments:**\n\n"
+"        - `<user>` The user whose messages are to be cleaned up.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:282
+#, docstring
+msgid "Delete all messages after a specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages after it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:303 redbot/cogs/cleanup/cleanup.py:357
+msgid "Message not found."
+msgstr "Nie znaleziono wiadomości."
+
+#: redbot/cogs/cleanup/cleanup.py:335
+#, docstring
+msgid "Deletes X messages before the specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages before it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:390
+#, docstring
+msgid "Delete the messages between Message One and Message Two, providing the messages IDs.\n\n"
+"        The first message ID should be the older message and the second one the newer.\n\n"
+"        Example:\n"
+"            - `[p]cleanup between 123456789123456789 987654321987654321`\n\n"
+"        **Arguments:**\n\n"
+"        - `<one>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<two>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:438
+#, docstring
+msgid "Delete the last X messages in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup messages 26`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:476
+#, docstring
+msgid "Clean up command messages and messages from the bot in the current channel.\n\n"
+"        Can only cleanup custom commands and alias commands if those cogs are loaded.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:564
+#, docstring
+msgid "Clean up messages owned by the bot in the current channel.\n\n"
+"        By default, all messages are cleaned. If a second argument is specified,\n"
+"        it is used for pattern matching - only messages containing the given text will be deleted.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup self 6`\n"
+"            - `[p]cleanup self 10 Pong`\n"
+"            - `[p]cleanup self 7 \"\" True`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<match_pattern>` The text that messages must contain to be deleted. Use \"\" to skip this.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:650
+#, docstring
+msgid "Deletes duplicate messages in the channel from the last X messages and keeps only one copy.\n\n"
+"        Defaults to 50.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The number of messages to check for duplicates. Must be a positive integer.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:17
+msgid "{} doesn't look like a valid message ID."
+msgstr "{} nie wygląda na prawidłowe ID wiadomości."
+
+#: redbot/cogs/cleanup/converters.py:29
+msgid "{arg} is not an integer."
+msgstr "{arg} nie jest liczbą całkowitą."
+
+#: redbot/cogs/cleanup/converters.py:31
+msgid "{arg} is not a positive integer."
+msgstr "{arg} nie jest dodatnią liczbą całkowitą."
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/cleanup/locales/pt-BR.po

@@ -0,0 +1,167 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-05-23 14:25+0000\n"
+"Last-Translator: \n"
+"Language-Team: Portuguese, Brazilian\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: pt-BR\n"
+"X-Crowdin-File-ID: 31\n"
+"Language: pt_BR\n"
+
+#: redbot/cogs/cleanup/cleanup.py:23
+#, docstring
+msgid "This cog contains commands used for \"cleaning up\" (deleting) messages.\n\n"
+"    This is designed as a moderator tool and offers many convenient use cases.\n"
+"    All cleanup commands only apply to the channel the command is executed in.\n\n"
+"    Messages older than two weeks cannot be mass deleted.\n"
+"    This is a limitation of the API.\n"
+"    "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:54
+msgid "Are you sure you want to delete {number} messages? (y/n)"
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:68
+msgid "Cancelled."
+msgstr "Cancelado."
+
+#: redbot/cogs/cleanup/cleanup.py:144
+#, docstring
+msgid "Base command for deleting messages."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:154
+#, docstring
+msgid "Delete the last X messages matching the specified text in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup text \"test\" 5`\n\n"
+"        Remember to use double quotes.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:209
+#, docstring
+msgid "Delete the last X messages from a specified user in the current channel.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup user @Twentysix 2`\n"
+"            - `[p]cleanup user Red 6`\n\n"
+"        **Arguments:**\n\n"
+"        - `<user>` The user whose messages are to be cleaned up.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:282
+#, docstring
+msgid "Delete all messages after a specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages after it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:303 redbot/cogs/cleanup/cleanup.py:357
+msgid "Message not found."
+msgstr "Mensagem não encontrada."
+
+#: redbot/cogs/cleanup/cleanup.py:335
+#, docstring
+msgid "Deletes X messages before the specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages before it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:390
+#, docstring
+msgid "Delete the messages between Message One and Message Two, providing the messages IDs.\n\n"
+"        The first message ID should be the older message and the second one the newer.\n\n"
+"        Example:\n"
+"            - `[p]cleanup between 123456789123456789 987654321987654321`\n\n"
+"        **Arguments:**\n\n"
+"        - `<one>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<two>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:438
+#, docstring
+msgid "Delete the last X messages in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup messages 26`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:476
+#, docstring
+msgid "Clean up command messages and messages from the bot in the current channel.\n\n"
+"        Can only cleanup custom commands and alias commands if those cogs are loaded.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:564
+#, docstring
+msgid "Clean up messages owned by the bot in the current channel.\n\n"
+"        By default, all messages are cleaned. If a second argument is specified,\n"
+"        it is used for pattern matching - only messages containing the given text will be deleted.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup self 6`\n"
+"            - `[p]cleanup self 10 Pong`\n"
+"            - `[p]cleanup self 7 \"\" True`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<match_pattern>` The text that messages must contain to be deleted. Use \"\" to skip this.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:650
+#, docstring
+msgid "Deletes duplicate messages in the channel from the last X messages and keeps only one copy.\n\n"
+"        Defaults to 50.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The number of messages to check for duplicates. Must be a positive integer.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:17
+msgid "{} doesn't look like a valid message ID."
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:29
+msgid "{arg} is not an integer."
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:31
+msgid "{arg} is not a positive integer."
+msgstr ""
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/cleanup/locales/pt-PT.po

@@ -0,0 +1,167 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-05-23 14:25+0000\n"
+"Last-Translator: \n"
+"Language-Team: Portuguese\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: pt-PT\n"
+"X-Crowdin-File-ID: 31\n"
+"Language: pt_PT\n"
+
+#: redbot/cogs/cleanup/cleanup.py:23
+#, docstring
+msgid "This cog contains commands used for \"cleaning up\" (deleting) messages.\n\n"
+"    This is designed as a moderator tool and offers many convenient use cases.\n"
+"    All cleanup commands only apply to the channel the command is executed in.\n\n"
+"    Messages older than two weeks cannot be mass deleted.\n"
+"    This is a limitation of the API.\n"
+"    "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:54
+msgid "Are you sure you want to delete {number} messages? (y/n)"
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:68
+msgid "Cancelled."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:144
+#, docstring
+msgid "Base command for deleting messages."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:154
+#, docstring
+msgid "Delete the last X messages matching the specified text in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup text \"test\" 5`\n\n"
+"        Remember to use double quotes.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:209
+#, docstring
+msgid "Delete the last X messages from a specified user in the current channel.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup user @Twentysix 2`\n"
+"            - `[p]cleanup user Red 6`\n\n"
+"        **Arguments:**\n\n"
+"        - `<user>` The user whose messages are to be cleaned up.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:282
+#, docstring
+msgid "Delete all messages after a specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages after it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:303 redbot/cogs/cleanup/cleanup.py:357
+msgid "Message not found."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:335
+#, docstring
+msgid "Deletes X messages before the specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages before it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:390
+#, docstring
+msgid "Delete the messages between Message One and Message Two, providing the messages IDs.\n\n"
+"        The first message ID should be the older message and the second one the newer.\n\n"
+"        Example:\n"
+"            - `[p]cleanup between 123456789123456789 987654321987654321`\n\n"
+"        **Arguments:**\n\n"
+"        - `<one>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<two>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:438
+#, docstring
+msgid "Delete the last X messages in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup messages 26`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:476
+#, docstring
+msgid "Clean up command messages and messages from the bot in the current channel.\n\n"
+"        Can only cleanup custom commands and alias commands if those cogs are loaded.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:564
+#, docstring
+msgid "Clean up messages owned by the bot in the current channel.\n\n"
+"        By default, all messages are cleaned. If a second argument is specified,\n"
+"        it is used for pattern matching - only messages containing the given text will be deleted.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup self 6`\n"
+"            - `[p]cleanup self 10 Pong`\n"
+"            - `[p]cleanup self 7 \"\" True`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<match_pattern>` The text that messages must contain to be deleted. Use \"\" to skip this.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:650
+#, docstring
+msgid "Deletes duplicate messages in the channel from the last X messages and keeps only one copy.\n\n"
+"        Defaults to 50.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The number of messages to check for duplicates. Must be a positive integer.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:17
+msgid "{} doesn't look like a valid message ID."
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:29
+msgid "{arg} is not an integer."
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:31
+msgid "{arg} is not a positive integer."
+msgstr ""
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/cleanup/locales/ru-RU.po

@@ -0,0 +1,175 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-05-23 14:25+0000\n"
+"Last-Translator: \n"
+"Language-Team: Russian\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=4; plural=((n%10==1 && n%100!=11) ? 0 : ((n%10 >= 2 && n%10 <=4 && (n%100 < 12 || n%100 > 14)) ? 1 : ((n%10 == 0 || (n%10 >= 5 && n%10 <=9)) || (n%100 >= 11 && n%100 <= 14)) ? 2 : 3));\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: ru\n"
+"X-Crowdin-File-ID: 31\n"
+"Language: ru_RU\n"
+
+#: redbot/cogs/cleanup/cleanup.py:23
+#, docstring
+msgid "This cog contains commands used for \"cleaning up\" (deleting) messages.\n\n"
+"    This is designed as a moderator tool and offers many convenient use cases.\n"
+"    All cleanup commands only apply to the channel the command is executed in.\n\n"
+"    Messages older than two weeks cannot be mass deleted.\n"
+"    This is a limitation of the API.\n"
+"    "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:54
+msgid "Are you sure you want to delete {number} messages? (y/n)"
+msgstr "Вы уверены, что хотите удалить {number} сообщений? (y/n)"
+
+#: redbot/cogs/cleanup/cleanup.py:68
+msgid "Cancelled."
+msgstr "Отменено."
+
+#: redbot/cogs/cleanup/cleanup.py:144
+#, docstring
+msgid "Base command for deleting messages."
+msgstr "Базовая команда для удаления сообщений."
+
+#: redbot/cogs/cleanup/cleanup.py:154
+#, docstring
+msgid "Delete the last X messages matching the specified text in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup text \"test\" 5`\n\n"
+"        Remember to use double quotes.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:209
+#, docstring
+msgid "Delete the last X messages from a specified user in the current channel.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup user @Twentysix 2`\n"
+"            - `[p]cleanup user Red 6`\n\n"
+"        **Arguments:**\n\n"
+"        - `<user>` The user whose messages are to be cleaned up.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:282
+#, docstring
+msgid "Delete all messages after a specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages after it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:303 redbot/cogs/cleanup/cleanup.py:357
+msgid "Message not found."
+msgstr "Сообщение не найдено."
+
+#: redbot/cogs/cleanup/cleanup.py:335
+#, docstring
+msgid "Deletes X messages before the specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages before it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:390
+#, docstring
+msgid "Delete the messages between Message One and Message Two, providing the messages IDs.\n\n"
+"        The first message ID should be the older message and the second one the newer.\n\n"
+"        Example:\n"
+"            - `[p]cleanup between 123456789123456789 987654321987654321`\n\n"
+"        **Arguments:**\n\n"
+"        - `<one>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<two>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr "Удалите сообщения между сообщением 1 и сообщением 2, указав идентификаторы сообщений.\n\n"
+"        Первый идентификатор сообщения должен быть старым сообщением, а второй— новым.\n\n"
+"        Пример:\n"
+"            - `[p]очистка между 123456789123456789 987654321987654321`\n\n"
+"        **Аргументы:**\n\n"
+"        - `<one>` Идентификатор сообщения для очистки. Это сообщение не будет удалено.\n"
+"        - `<two>` Идентификатор сообщения, который нужно очистить раньше. Это сообщение не будет удалено.\n"
+"        - `<delete_pinned>` Удалять или нет. По умолчанию Ложь\n"
+"        "
+
+#: redbot/cogs/cleanup/cleanup.py:438
+#, docstring
+msgid "Delete the last X messages in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup messages 26`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:476
+#, docstring
+msgid "Clean up command messages and messages from the bot in the current channel.\n\n"
+"        Can only cleanup custom commands and alias commands if those cogs are loaded.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:564
+#, docstring
+msgid "Clean up messages owned by the bot in the current channel.\n\n"
+"        By default, all messages are cleaned. If a second argument is specified,\n"
+"        it is used for pattern matching - only messages containing the given text will be deleted.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup self 6`\n"
+"            - `[p]cleanup self 10 Pong`\n"
+"            - `[p]cleanup self 7 \"\" True`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<match_pattern>` The text that messages must contain to be deleted. Use \"\" to skip this.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:650
+#, docstring
+msgid "Deletes duplicate messages in the channel from the last X messages and keeps only one copy.\n\n"
+"        Defaults to 50.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The number of messages to check for duplicates. Must be a positive integer.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:17
+msgid "{} doesn't look like a valid message ID."
+msgstr "{} не похож на действительный ID сообщения."
+
+#: redbot/cogs/cleanup/converters.py:29
+msgid "{arg} is not an integer."
+msgstr "{arg} не является целым числом."
+
+#: redbot/cogs/cleanup/converters.py:31
+msgid "{arg} is not a positive integer."
+msgstr "{arg} не является положительным целым числом."
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/cleanup/locales/sk-SK.po

@@ -0,0 +1,167 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-05-23 14:25+0000\n"
+"Last-Translator: \n"
+"Language-Team: Slovak\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=4; plural=(n==1) ? 0 : (n>=2 && n<=4) ? 1 : 3;\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: sk\n"
+"X-Crowdin-File-ID: 31\n"
+"Language: sk_SK\n"
+
+#: redbot/cogs/cleanup/cleanup.py:23
+#, docstring
+msgid "This cog contains commands used for \"cleaning up\" (deleting) messages.\n\n"
+"    This is designed as a moderator tool and offers many convenient use cases.\n"
+"    All cleanup commands only apply to the channel the command is executed in.\n\n"
+"    Messages older than two weeks cannot be mass deleted.\n"
+"    This is a limitation of the API.\n"
+"    "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:54
+msgid "Are you sure you want to delete {number} messages? (y/n)"
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:68
+msgid "Cancelled."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:144
+#, docstring
+msgid "Base command for deleting messages."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:154
+#, docstring
+msgid "Delete the last X messages matching the specified text in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup text \"test\" 5`\n\n"
+"        Remember to use double quotes.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:209
+#, docstring
+msgid "Delete the last X messages from a specified user in the current channel.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup user @Twentysix 2`\n"
+"            - `[p]cleanup user Red 6`\n\n"
+"        **Arguments:**\n\n"
+"        - `<user>` The user whose messages are to be cleaned up.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:282
+#, docstring
+msgid "Delete all messages after a specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages after it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:303 redbot/cogs/cleanup/cleanup.py:357
+msgid "Message not found."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:335
+#, docstring
+msgid "Deletes X messages before the specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages before it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:390
+#, docstring
+msgid "Delete the messages between Message One and Message Two, providing the messages IDs.\n\n"
+"        The first message ID should be the older message and the second one the newer.\n\n"
+"        Example:\n"
+"            - `[p]cleanup between 123456789123456789 987654321987654321`\n\n"
+"        **Arguments:**\n\n"
+"        - `<one>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<two>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:438
+#, docstring
+msgid "Delete the last X messages in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup messages 26`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:476
+#, docstring
+msgid "Clean up command messages and messages from the bot in the current channel.\n\n"
+"        Can only cleanup custom commands and alias commands if those cogs are loaded.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:564
+#, docstring
+msgid "Clean up messages owned by the bot in the current channel.\n\n"
+"        By default, all messages are cleaned. If a second argument is specified,\n"
+"        it is used for pattern matching - only messages containing the given text will be deleted.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup self 6`\n"
+"            - `[p]cleanup self 10 Pong`\n"
+"            - `[p]cleanup self 7 \"\" True`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<match_pattern>` The text that messages must contain to be deleted. Use \"\" to skip this.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:650
+#, docstring
+msgid "Deletes duplicate messages in the channel from the last X messages and keeps only one copy.\n\n"
+"        Defaults to 50.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The number of messages to check for duplicates. Must be a positive integer.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:17
+msgid "{} doesn't look like a valid message ID."
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:29
+msgid "{arg} is not an integer."
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:31
+msgid "{arg} is not a positive integer."
+msgstr ""
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/cleanup/locales/sl-SI.po

@@ -0,0 +1,167 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-05-23 14:25+0000\n"
+"Last-Translator: \n"
+"Language-Team: Slovenian\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=4; plural=(n%100==1 ? 1 : n%100==2 ? 2 : n%100==3 || n%100==4 ? 3 : 0);\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: sl\n"
+"X-Crowdin-File-ID: 31\n"
+"Language: sl_SI\n"
+
+#: redbot/cogs/cleanup/cleanup.py:23
+#, docstring
+msgid "This cog contains commands used for \"cleaning up\" (deleting) messages.\n\n"
+"    This is designed as a moderator tool and offers many convenient use cases.\n"
+"    All cleanup commands only apply to the channel the command is executed in.\n\n"
+"    Messages older than two weeks cannot be mass deleted.\n"
+"    This is a limitation of the API.\n"
+"    "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:54
+msgid "Are you sure you want to delete {number} messages? (y/n)"
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:68
+msgid "Cancelled."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:144
+#, docstring
+msgid "Base command for deleting messages."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:154
+#, docstring
+msgid "Delete the last X messages matching the specified text in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup text \"test\" 5`\n\n"
+"        Remember to use double quotes.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:209
+#, docstring
+msgid "Delete the last X messages from a specified user in the current channel.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup user @Twentysix 2`\n"
+"            - `[p]cleanup user Red 6`\n\n"
+"        **Arguments:**\n\n"
+"        - `<user>` The user whose messages are to be cleaned up.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:282
+#, docstring
+msgid "Delete all messages after a specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages after it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:303 redbot/cogs/cleanup/cleanup.py:357
+msgid "Message not found."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:335
+#, docstring
+msgid "Deletes X messages before the specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages before it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:390
+#, docstring
+msgid "Delete the messages between Message One and Message Two, providing the messages IDs.\n\n"
+"        The first message ID should be the older message and the second one the newer.\n\n"
+"        Example:\n"
+"            - `[p]cleanup between 123456789123456789 987654321987654321`\n\n"
+"        **Arguments:**\n\n"
+"        - `<one>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<two>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:438
+#, docstring
+msgid "Delete the last X messages in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup messages 26`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:476
+#, docstring
+msgid "Clean up command messages and messages from the bot in the current channel.\n\n"
+"        Can only cleanup custom commands and alias commands if those cogs are loaded.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:564
+#, docstring
+msgid "Clean up messages owned by the bot in the current channel.\n\n"
+"        By default, all messages are cleaned. If a second argument is specified,\n"
+"        it is used for pattern matching - only messages containing the given text will be deleted.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup self 6`\n"
+"            - `[p]cleanup self 10 Pong`\n"
+"            - `[p]cleanup self 7 \"\" True`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<match_pattern>` The text that messages must contain to be deleted. Use \"\" to skip this.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:650
+#, docstring
+msgid "Deletes duplicate messages in the channel from the last X messages and keeps only one copy.\n\n"
+"        Defaults to 50.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The number of messages to check for duplicates. Must be a positive integer.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:17
+msgid "{} doesn't look like a valid message ID."
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:29
+msgid "{arg} is not an integer."
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:31
+msgid "{arg} is not a positive integer."
+msgstr ""
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/cleanup/locales/sv-SE.po

@@ -0,0 +1,167 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-05-23 14:25+0000\n"
+"Last-Translator: \n"
+"Language-Team: Swedish\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: sv-SE\n"
+"X-Crowdin-File-ID: 31\n"
+"Language: sv_SE\n"
+
+#: redbot/cogs/cleanup/cleanup.py:23
+#, docstring
+msgid "This cog contains commands used for \"cleaning up\" (deleting) messages.\n\n"
+"    This is designed as a moderator tool and offers many convenient use cases.\n"
+"    All cleanup commands only apply to the channel the command is executed in.\n\n"
+"    Messages older than two weeks cannot be mass deleted.\n"
+"    This is a limitation of the API.\n"
+"    "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:54
+msgid "Are you sure you want to delete {number} messages? (y/n)"
+msgstr "Är du säker på att du vill ta bort {number} meddelanden? (y/n)"
+
+#: redbot/cogs/cleanup/cleanup.py:68
+msgid "Cancelled."
+msgstr "Avbruten."
+
+#: redbot/cogs/cleanup/cleanup.py:144
+#, docstring
+msgid "Base command for deleting messages."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:154
+#, docstring
+msgid "Delete the last X messages matching the specified text in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup text \"test\" 5`\n\n"
+"        Remember to use double quotes.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:209
+#, docstring
+msgid "Delete the last X messages from a specified user in the current channel.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup user @Twentysix 2`\n"
+"            - `[p]cleanup user Red 6`\n\n"
+"        **Arguments:**\n\n"
+"        - `<user>` The user whose messages are to be cleaned up.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:282
+#, docstring
+msgid "Delete all messages after a specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages after it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:303 redbot/cogs/cleanup/cleanup.py:357
+msgid "Message not found."
+msgstr "Meddelandet kunde inte hittas."
+
+#: redbot/cogs/cleanup/cleanup.py:335
+#, docstring
+msgid "Deletes X messages before the specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages before it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:390
+#, docstring
+msgid "Delete the messages between Message One and Message Two, providing the messages IDs.\n\n"
+"        The first message ID should be the older message and the second one the newer.\n\n"
+"        Example:\n"
+"            - `[p]cleanup between 123456789123456789 987654321987654321`\n\n"
+"        **Arguments:**\n\n"
+"        - `<one>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<two>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:438
+#, docstring
+msgid "Delete the last X messages in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup messages 26`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:476
+#, docstring
+msgid "Clean up command messages and messages from the bot in the current channel.\n\n"
+"        Can only cleanup custom commands and alias commands if those cogs are loaded.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:564
+#, docstring
+msgid "Clean up messages owned by the bot in the current channel.\n\n"
+"        By default, all messages are cleaned. If a second argument is specified,\n"
+"        it is used for pattern matching - only messages containing the given text will be deleted.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup self 6`\n"
+"            - `[p]cleanup self 10 Pong`\n"
+"            - `[p]cleanup self 7 \"\" True`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<match_pattern>` The text that messages must contain to be deleted. Use \"\" to skip this.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:650
+#, docstring
+msgid "Deletes duplicate messages in the channel from the last X messages and keeps only one copy.\n\n"
+"        Defaults to 50.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The number of messages to check for duplicates. Must be a positive integer.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:17
+msgid "{} doesn't look like a valid message ID."
+msgstr "{} ser inte ut som ett giltigt meddelande-ID."
+
+#: redbot/cogs/cleanup/converters.py:29
+msgid "{arg} is not an integer."
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:31
+msgid "{arg} is not a positive integer."
+msgstr ""
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/cleanup/locales/tr-TR.po

@@ -0,0 +1,235 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-05-23 14:25+0000\n"
+"Last-Translator: \n"
+"Language-Team: Turkish\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: tr\n"
+"X-Crowdin-File-ID: 31\n"
+"Language: tr_TR\n"
+
+#: redbot/cogs/cleanup/cleanup.py:23
+#, docstring
+msgid "This cog contains commands used for \"cleaning up\" (deleting) messages.\n\n"
+"    This is designed as a moderator tool and offers many convenient use cases.\n"
+"    All cleanup commands only apply to the channel the command is executed in.\n\n"
+"    Messages older than two weeks cannot be mass deleted.\n"
+"    This is a limitation of the API.\n"
+"    "
+msgstr "Bu cog mesajları \"temizlemek\" (silmek) için kullanılan komutlar içerir.\n\n"
+"    Bu sunucu yöneticileri için bir araç olarak tasarlanmıştır ve çok sayıda rahatlık sağlar.\n"
+"    Temizlik komutlarının tamamı sadece komutun içinde çalıştırıldığı kanala etki eder.\n\n"
+"    İki haftadan eski mesajlar topluca silinemez.\n"
+"    Bu Discord tarafından getirilmiş bir kısıtlamadır.\n"
+"    "
+
+#: redbot/cogs/cleanup/cleanup.py:54
+msgid "Are you sure you want to delete {number} messages? (y/n)"
+msgstr "{number} iletileri silmek istediğinizden emin misiniz? (e/h)"
+
+#: redbot/cogs/cleanup/cleanup.py:68
+msgid "Cancelled."
+msgstr "İptal."
+
+#: redbot/cogs/cleanup/cleanup.py:144
+#, docstring
+msgid "Base command for deleting messages."
+msgstr "Mesajları silmek için kullanılan temel komut."
+
+#: redbot/cogs/cleanup/cleanup.py:154
+#, docstring
+msgid "Delete the last X messages matching the specified text in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup text \"test\" 5`\n\n"
+"        Remember to use double quotes.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr "Belirtilen yazıyla uyuşan, şu anki kanalda bulunan son X adet mesajı siler.\n\n"
+"        Örnek:\n"
+"            - `[p]cleanup text \"test\" 5`\n\n"
+"        Çift tırnak kullanmayı unutmayın.\n\n"
+"        **Seçenekler:**\n\n"
+"        - `<numara>` Maksimum kaç mesaj silineceği, pozitif tam sayı olmak zorundadır.\n"
+"        - `<sabit_silme>` Sabitlenmiş mesajların silinip silinmeyeceği, varsayılan olarak silinmezler (False)\n"
+"        "
+
+#: redbot/cogs/cleanup/cleanup.py:209
+#, docstring
+msgid "Delete the last X messages from a specified user in the current channel.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup user @Twentysix 2`\n"
+"            - `[p]cleanup user Red 6`\n\n"
+"        **Arguments:**\n\n"
+"        - `<user>` The user whose messages are to be cleaned up.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr "Belirtilen kullanıcının göndermiş olduğu şu anki kanalda bulunan son X adet mesajı siler.\n\n"
+"        Örnek:\n"
+"            - `[p]cleanup user @Twentysix 2`\n"
+"            - `[p]cleanup user Red 6`\n\n"
+"        **Seçenekler:**\n\n"
+"        - `<kullanıcı>` Mesajları silinecek olan kullanıcı\n"
+"        - `<rakam>` Maksimum kaç mesaj silineceği, pozitif tam sayı olmak zorundadır.\n"
+"        - `<sabit silme>` Sabitlenmiş mesajların silinip silinmeyeceği, varsayılan olarak silinmezler (False)\n"
+"        "
+
+#: redbot/cogs/cleanup/cleanup.py:282
+#, docstring
+msgid "Delete all messages after a specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages after it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr "Belirtilen bir mesajdan sonraki tüm mesajları sil.\n\n"
+"        Bir mesaj idsi edinmek için Discord ayarlarına girip\n"
+"        \"görünüm\" sekmesinden geliştirici modunu açın.\n"
+"        Sonra bir mesaja sağ tıklayıp idsini kopyalayın.\n\n"
+"        **Seçenekler:**\n\n"
+"        - `<mesaj_idsi>` Sonrasındaki mesajlar silinecek olan mesajın Idsi. Bu mesajın kendisi silinmez.\n"
+"        -`<sabit_silme>` Sabit mesajların silinip silinmeyeceği. Varsayılan olarak kapalıdır. (False)\n"
+"        "
+
+#: redbot/cogs/cleanup/cleanup.py:303 redbot/cogs/cleanup/cleanup.py:357
+msgid "Message not found."
+msgstr "Mesaj bulunamadı."
+
+#: redbot/cogs/cleanup/cleanup.py:335
+#, docstring
+msgid "Deletes X messages before the specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages before it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr "Belirtilen mesajdan önceki X adet mesajı siler.\n\n"
+"        Bir mesaj idsi edinmek için Discord ayarlarına girip\n"
+"        \"görünüm\" sekmesinden geliştirici modunu açın.\n"
+"        Sonra bir mesaja sağ tıklayıp idsini kopyalayın.\n\n"
+"        **Seçenekler:**\n\n"
+"        - `<mesaj_idsi>` Öncesindeki mesajlar silinecek olan mesajın Idsi. Bu mesajın kendisi silinmez.\n"
+"        - `<sayı>` Silinecek mesaj sayısı, pozitif bir tam sayı olmak zorundadır.\n"
+"        - `<sabit_silme>` Sabit mesajların silinip silinmeyeceği. Varsayılan olarak kapalıdır. (False)\n"
+"        "
+
+#: redbot/cogs/cleanup/cleanup.py:390
+#, docstring
+msgid "Delete the messages between Message One and Message Two, providing the messages IDs.\n\n"
+"        The first message ID should be the older message and the second one the newer.\n\n"
+"        Example:\n"
+"            - `[p]cleanup between 123456789123456789 987654321987654321`\n\n"
+"        **Arguments:**\n\n"
+"        - `<one>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<two>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr "IDleri verilen iki mesaj arasındaki mesajları siler.\n\n"
+"        İlk mesaj IDsi temizliğin başlangıç noktasını, ikinci mesaj IDsi ise bitiş noktasını belirtmelidir.\n\n"
+"        Örnek:\n"
+"            - `[p]cleanup between 123456789123456789 987654321987654321`\n\n"
+"        **Seçenekler:**\n\n"
+"        - `<bir>` Sonrasındaki mesajlar silinecek olan mesajın IDsi. Bu mesajın kendisi silinmez.\n"
+"        - `<iki>` Öncesindeki mesajlar silinecek olan mesajın IDsi. Bu mesajın kendisi silinmez.\n"
+"        - `<sabit_silme>` Sabit mesajların silinip silinmeyeceği. Varsayılan olarak kapalıdır. (False)\n"
+"        "
+
+#: redbot/cogs/cleanup/cleanup.py:438
+#, docstring
+msgid "Delete the last X messages in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup messages 26`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr "Şu anki kanalda bulunan son X mesajı siler.\n\n"
+"        Örnek:\n"
+"            - `[p]cleanup messages 26`\n\n"
+"        **Seçenekler:**\n\n"
+"        - `<rakam>` Maksimum kaç mesaj silineceği, pozitif tam sayı olmak zorundadır.\n"
+"        - `<sabit_silme>` Sabitlenmiş mesajların silinip silinmeyeceği, varsayılan olarak silinmezler (False)\n"
+"        "
+
+#: redbot/cogs/cleanup/cleanup.py:476
+#, docstring
+msgid "Clean up command messages and messages from the bot in the current channel.\n\n"
+"        Can only cleanup custom commands and alias commands if those cogs are loaded.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr "Botun şu anki kanala göndermiş olduğu mesajları ve komut yanıtlarını siler.\n\n"
+"        Customcom veya alias ile oluşturulmuş komutların yanıtları, sadece cog yüklüyse silinir.\n\n"
+"        **Seçenekler:**\n\n"
+"        - `<rakam>` Maksimum kaç mesaj silineceği, pozitif tam sayı olmak zorundadır.\n"
+"        - `<sabit_silme>` Sabitlenmiş mesajların silinip silinmeyeceği, varsayılan olarak silinmezler (False)\n"
+"        "
+
+#: redbot/cogs/cleanup/cleanup.py:564
+#, docstring
+msgid "Clean up messages owned by the bot in the current channel.\n\n"
+"        By default, all messages are cleaned. If a second argument is specified,\n"
+"        it is used for pattern matching - only messages containing the given text will be deleted.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup self 6`\n"
+"            - `[p]cleanup self 10 Pong`\n"
+"            - `[p]cleanup self 7 \"\" True`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<match_pattern>` The text that messages must contain to be deleted. Use \"\" to skip this.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr "Şu anki kanalda bota ait olan mesajları siler.\n\n"
+"        Varsayılan olarak bütün mesajlar silinir. Eğer ikinci seçenek olarak komuta herhangi bir şey verilirse, eşleştirme yapılır ve sadece  verilen yazıyı içeren mesajlar silinir.\n\n"
+"        Örnekler:\n"
+"            - `[p]cleanup self 6`\n"
+"            - `[p]cleanup self 10 Pong`\n"
+"            - `[p]cleanup self 7 \"\" True`\n\n"
+"        **Seçenekler:**\n\n\n"
+"        - `<rakam>` Maksimum kaç mesaj silineceği, pozitif tam sayı olmak zorundadır.\n"
+"        - `<eşleştirme>` Bir mesajın silinmesi için bulundurması gereken yazı, eğer bunu atlamak isterseniz \"\" (iki tane çift tırnak) kullanın.\n"
+"        - `<sabit_silme>` Sabitlenmiş mesajların silinip silinmeyeceği, varsayılan olarak silinmezler (False)\n"
+"        "
+
+#: redbot/cogs/cleanup/cleanup.py:650
+#, docstring
+msgid "Deletes duplicate messages in the channel from the last X messages and keeps only one copy.\n\n"
+"        Defaults to 50.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The number of messages to check for duplicates. Must be a positive integer.\n"
+"        "
+msgstr "Son X mesajdan aynı olanları siler ve sadece bir tanesini bırakır.\n\n"
+"        Varsayılan olarak 50.\n\n"
+"        **Seçenekler:**\n\n"
+"        - `<number>` Aynıları için denetlenecek mesaj sayısı, pozitif tam sayı olmak zorundadır.\n"
+"        "
+
+#: redbot/cogs/cleanup/converters.py:17
+msgid "{} doesn't look like a valid message ID."
+msgstr "{} geçersiz mesaj ID'si."
+
+#: redbot/cogs/cleanup/converters.py:29
+msgid "{arg} is not an integer."
+msgstr "{arg} tamsayı değil."
+
+#: redbot/cogs/cleanup/converters.py:31
+msgid "{arg} is not a positive integer."
+msgstr "{arg} pozitif bir tamsayı değil."
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/cleanup/locales/uk-UA.po

@@ -0,0 +1,167 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-05-23 14:25+0000\n"
+"Last-Translator: \n"
+"Language-Team: Ukrainian\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=4; plural=((n%10==1 && n%100!=11) ? 0 : ((n%10 >= 2 && n%10 <=4 && (n%100 < 12 || n%100 > 14)) ? 1 : ((n%10 == 0 || (n%10 >= 5 && n%10 <=9)) || (n%100 >= 11 && n%100 <= 14)) ? 2 : 3));\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: uk\n"
+"X-Crowdin-File-ID: 31\n"
+"Language: uk_UA\n"
+
+#: redbot/cogs/cleanup/cleanup.py:23
+#, docstring
+msgid "This cog contains commands used for \"cleaning up\" (deleting) messages.\n\n"
+"    This is designed as a moderator tool and offers many convenient use cases.\n"
+"    All cleanup commands only apply to the channel the command is executed in.\n\n"
+"    Messages older than two weeks cannot be mass deleted.\n"
+"    This is a limitation of the API.\n"
+"    "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:54
+msgid "Are you sure you want to delete {number} messages? (y/n)"
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:68
+msgid "Cancelled."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:144
+#, docstring
+msgid "Base command for deleting messages."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:154
+#, docstring
+msgid "Delete the last X messages matching the specified text in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup text \"test\" 5`\n\n"
+"        Remember to use double quotes.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:209
+#, docstring
+msgid "Delete the last X messages from a specified user in the current channel.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup user @Twentysix 2`\n"
+"            - `[p]cleanup user Red 6`\n\n"
+"        **Arguments:**\n\n"
+"        - `<user>` The user whose messages are to be cleaned up.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:282
+#, docstring
+msgid "Delete all messages after a specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages after it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:303 redbot/cogs/cleanup/cleanup.py:357
+msgid "Message not found."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:335
+#, docstring
+msgid "Deletes X messages before the specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages before it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:390
+#, docstring
+msgid "Delete the messages between Message One and Message Two, providing the messages IDs.\n\n"
+"        The first message ID should be the older message and the second one the newer.\n\n"
+"        Example:\n"
+"            - `[p]cleanup between 123456789123456789 987654321987654321`\n\n"
+"        **Arguments:**\n\n"
+"        - `<one>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<two>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:438
+#, docstring
+msgid "Delete the last X messages in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup messages 26`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:476
+#, docstring
+msgid "Clean up command messages and messages from the bot in the current channel.\n\n"
+"        Can only cleanup custom commands and alias commands if those cogs are loaded.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:564
+#, docstring
+msgid "Clean up messages owned by the bot in the current channel.\n\n"
+"        By default, all messages are cleaned. If a second argument is specified,\n"
+"        it is used for pattern matching - only messages containing the given text will be deleted.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup self 6`\n"
+"            - `[p]cleanup self 10 Pong`\n"
+"            - `[p]cleanup self 7 \"\" True`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<match_pattern>` The text that messages must contain to be deleted. Use \"\" to skip this.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:650
+#, docstring
+msgid "Deletes duplicate messages in the channel from the last X messages and keeps only one copy.\n\n"
+"        Defaults to 50.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The number of messages to check for duplicates. Must be a positive integer.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:17
+msgid "{} doesn't look like a valid message ID."
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:29
+msgid "{arg} is not an integer."
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:31
+msgid "{arg} is not a positive integer."
+msgstr ""
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/cleanup/locales/vi-VN.po

@@ -0,0 +1,167 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-05-23 14:25+0000\n"
+"Last-Translator: \n"
+"Language-Team: Vietnamese\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: vi\n"
+"X-Crowdin-File-ID: 31\n"
+"Language: vi_VN\n"
+
+#: redbot/cogs/cleanup/cleanup.py:23
+#, docstring
+msgid "This cog contains commands used for \"cleaning up\" (deleting) messages.\n\n"
+"    This is designed as a moderator tool and offers many convenient use cases.\n"
+"    All cleanup commands only apply to the channel the command is executed in.\n\n"
+"    Messages older than two weeks cannot be mass deleted.\n"
+"    This is a limitation of the API.\n"
+"    "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:54
+msgid "Are you sure you want to delete {number} messages? (y/n)"
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:68
+msgid "Cancelled."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:144
+#, docstring
+msgid "Base command for deleting messages."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:154
+#, docstring
+msgid "Delete the last X messages matching the specified text in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup text \"test\" 5`\n\n"
+"        Remember to use double quotes.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:209
+#, docstring
+msgid "Delete the last X messages from a specified user in the current channel.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup user @Twentysix 2`\n"
+"            - `[p]cleanup user Red 6`\n\n"
+"        **Arguments:**\n\n"
+"        - `<user>` The user whose messages are to be cleaned up.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:282
+#, docstring
+msgid "Delete all messages after a specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages after it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:303 redbot/cogs/cleanup/cleanup.py:357
+msgid "Message not found."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:335
+#, docstring
+msgid "Deletes X messages before the specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages before it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:390
+#, docstring
+msgid "Delete the messages between Message One and Message Two, providing the messages IDs.\n\n"
+"        The first message ID should be the older message and the second one the newer.\n\n"
+"        Example:\n"
+"            - `[p]cleanup between 123456789123456789 987654321987654321`\n\n"
+"        **Arguments:**\n\n"
+"        - `<one>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<two>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:438
+#, docstring
+msgid "Delete the last X messages in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup messages 26`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:476
+#, docstring
+msgid "Clean up command messages and messages from the bot in the current channel.\n\n"
+"        Can only cleanup custom commands and alias commands if those cogs are loaded.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:564
+#, docstring
+msgid "Clean up messages owned by the bot in the current channel.\n\n"
+"        By default, all messages are cleaned. If a second argument is specified,\n"
+"        it is used for pattern matching - only messages containing the given text will be deleted.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup self 6`\n"
+"            - `[p]cleanup self 10 Pong`\n"
+"            - `[p]cleanup self 7 \"\" True`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<match_pattern>` The text that messages must contain to be deleted. Use \"\" to skip this.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:650
+#, docstring
+msgid "Deletes duplicate messages in the channel from the last X messages and keeps only one copy.\n\n"
+"        Defaults to 50.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The number of messages to check for duplicates. Must be a positive integer.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:17
+msgid "{} doesn't look like a valid message ID."
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:29
+msgid "{arg} is not an integer."
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:31
+msgid "{arg} is not a positive integer."
+msgstr ""
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/cleanup/locales/zh-CN.po

@@ -0,0 +1,167 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-05-23 14:25+0000\n"
+"Last-Translator: \n"
+"Language-Team: Chinese Simplified\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: zh-CN\n"
+"X-Crowdin-File-ID: 31\n"
+"Language: zh_CN\n"
+
+#: redbot/cogs/cleanup/cleanup.py:23
+#, docstring
+msgid "This cog contains commands used for \"cleaning up\" (deleting) messages.\n\n"
+"    This is designed as a moderator tool and offers many convenient use cases.\n"
+"    All cleanup commands only apply to the channel the command is executed in.\n\n"
+"    Messages older than two weeks cannot be mass deleted.\n"
+"    This is a limitation of the API.\n"
+"    "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:54
+msgid "Are you sure you want to delete {number} messages? (y/n)"
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:68
+msgid "Cancelled."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:144
+#, docstring
+msgid "Base command for deleting messages."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:154
+#, docstring
+msgid "Delete the last X messages matching the specified text in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup text \"test\" 5`\n\n"
+"        Remember to use double quotes.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:209
+#, docstring
+msgid "Delete the last X messages from a specified user in the current channel.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup user @Twentysix 2`\n"
+"            - `[p]cleanup user Red 6`\n\n"
+"        **Arguments:**\n\n"
+"        - `<user>` The user whose messages are to be cleaned up.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:282
+#, docstring
+msgid "Delete all messages after a specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages after it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:303 redbot/cogs/cleanup/cleanup.py:357
+msgid "Message not found."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:335
+#, docstring
+msgid "Deletes X messages before the specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages before it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:390
+#, docstring
+msgid "Delete the messages between Message One and Message Two, providing the messages IDs.\n\n"
+"        The first message ID should be the older message and the second one the newer.\n\n"
+"        Example:\n"
+"            - `[p]cleanup between 123456789123456789 987654321987654321`\n\n"
+"        **Arguments:**\n\n"
+"        - `<one>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<two>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:438
+#, docstring
+msgid "Delete the last X messages in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup messages 26`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:476
+#, docstring
+msgid "Clean up command messages and messages from the bot in the current channel.\n\n"
+"        Can only cleanup custom commands and alias commands if those cogs are loaded.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:564
+#, docstring
+msgid "Clean up messages owned by the bot in the current channel.\n\n"
+"        By default, all messages are cleaned. If a second argument is specified,\n"
+"        it is used for pattern matching - only messages containing the given text will be deleted.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup self 6`\n"
+"            - `[p]cleanup self 10 Pong`\n"
+"            - `[p]cleanup self 7 \"\" True`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<match_pattern>` The text that messages must contain to be deleted. Use \"\" to skip this.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:650
+#, docstring
+msgid "Deletes duplicate messages in the channel from the last X messages and keeps only one copy.\n\n"
+"        Defaults to 50.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The number of messages to check for duplicates. Must be a positive integer.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:17
+msgid "{} doesn't look like a valid message ID."
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:29
+msgid "{arg} is not an integer."
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:31
+msgid "{arg} is not a positive integer."
+msgstr ""
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/cleanup/locales/zh-HK.po

@@ -0,0 +1,167 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-05-23 14:25+0000\n"
+"Last-Translator: \n"
+"Language-Team: Chinese Traditional, Hong Kong\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: zh-HK\n"
+"X-Crowdin-File-ID: 31\n"
+"Language: zh_HK\n"
+
+#: redbot/cogs/cleanup/cleanup.py:23
+#, docstring
+msgid "This cog contains commands used for \"cleaning up\" (deleting) messages.\n\n"
+"    This is designed as a moderator tool and offers many convenient use cases.\n"
+"    All cleanup commands only apply to the channel the command is executed in.\n\n"
+"    Messages older than two weeks cannot be mass deleted.\n"
+"    This is a limitation of the API.\n"
+"    "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:54
+msgid "Are you sure you want to delete {number} messages? (y/n)"
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:68
+msgid "Cancelled."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:144
+#, docstring
+msgid "Base command for deleting messages."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:154
+#, docstring
+msgid "Delete the last X messages matching the specified text in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup text \"test\" 5`\n\n"
+"        Remember to use double quotes.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:209
+#, docstring
+msgid "Delete the last X messages from a specified user in the current channel.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup user @Twentysix 2`\n"
+"            - `[p]cleanup user Red 6`\n\n"
+"        **Arguments:**\n\n"
+"        - `<user>` The user whose messages are to be cleaned up.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:282
+#, docstring
+msgid "Delete all messages after a specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages after it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:303 redbot/cogs/cleanup/cleanup.py:357
+msgid "Message not found."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:335
+#, docstring
+msgid "Deletes X messages before the specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages before it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:390
+#, docstring
+msgid "Delete the messages between Message One and Message Two, providing the messages IDs.\n\n"
+"        The first message ID should be the older message and the second one the newer.\n\n"
+"        Example:\n"
+"            - `[p]cleanup between 123456789123456789 987654321987654321`\n\n"
+"        **Arguments:**\n\n"
+"        - `<one>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<two>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:438
+#, docstring
+msgid "Delete the last X messages in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup messages 26`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:476
+#, docstring
+msgid "Clean up command messages and messages from the bot in the current channel.\n\n"
+"        Can only cleanup custom commands and alias commands if those cogs are loaded.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:564
+#, docstring
+msgid "Clean up messages owned by the bot in the current channel.\n\n"
+"        By default, all messages are cleaned. If a second argument is specified,\n"
+"        it is used for pattern matching - only messages containing the given text will be deleted.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup self 6`\n"
+"            - `[p]cleanup self 10 Pong`\n"
+"            - `[p]cleanup self 7 \"\" True`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<match_pattern>` The text that messages must contain to be deleted. Use \"\" to skip this.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:650
+#, docstring
+msgid "Deletes duplicate messages in the channel from the last X messages and keeps only one copy.\n\n"
+"        Defaults to 50.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The number of messages to check for duplicates. Must be a positive integer.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:17
+msgid "{} doesn't look like a valid message ID."
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:29
+msgid "{arg} is not an integer."
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:31
+msgid "{arg} is not a positive integer."
+msgstr ""
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/cleanup/locales/zh-TW.po

@@ -0,0 +1,167 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-05-23 14:25+0000\n"
+"Last-Translator: \n"
+"Language-Team: Chinese Traditional\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=1; plural=0;\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: zh-TW\n"
+"X-Crowdin-File-ID: 31\n"
+"Language: zh_TW\n"
+
+#: redbot/cogs/cleanup/cleanup.py:23
+#, docstring
+msgid "This cog contains commands used for \"cleaning up\" (deleting) messages.\n\n"
+"    This is designed as a moderator tool and offers many convenient use cases.\n"
+"    All cleanup commands only apply to the channel the command is executed in.\n\n"
+"    Messages older than two weeks cannot be mass deleted.\n"
+"    This is a limitation of the API.\n"
+"    "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:54
+msgid "Are you sure you want to delete {number} messages? (y/n)"
+msgstr "您確定要刪除{number}則訊息嗎? (y/n)"
+
+#: redbot/cogs/cleanup/cleanup.py:68
+msgid "Cancelled."
+msgstr "已取消。"
+
+#: redbot/cogs/cleanup/cleanup.py:144
+#, docstring
+msgid "Base command for deleting messages."
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:154
+#, docstring
+msgid "Delete the last X messages matching the specified text in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup text \"test\" 5`\n\n"
+"        Remember to use double quotes.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:209
+#, docstring
+msgid "Delete the last X messages from a specified user in the current channel.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup user @Twentysix 2`\n"
+"            - `[p]cleanup user Red 6`\n\n"
+"        **Arguments:**\n\n"
+"        - `<user>` The user whose messages are to be cleaned up.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:282
+#, docstring
+msgid "Delete all messages after a specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages after it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:303 redbot/cogs/cleanup/cleanup.py:357
+msgid "Message not found."
+msgstr "未找到訊息。"
+
+#: redbot/cogs/cleanup/cleanup.py:335
+#, docstring
+msgid "Deletes X messages before the specified message.\n\n"
+"        To get a message id, enable developer mode in Discord's\n"
+"        settings, 'appearance' tab. Then right click a message\n"
+"        and copy its id.\n"
+"        Replying to a message will cleanup all messages before it.\n\n"
+"        **Arguments:**\n\n"
+"        - `<message_id>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:390
+#, docstring
+msgid "Delete the messages between Message One and Message Two, providing the messages IDs.\n\n"
+"        The first message ID should be the older message and the second one the newer.\n\n"
+"        Example:\n"
+"            - `[p]cleanup between 123456789123456789 987654321987654321`\n\n"
+"        **Arguments:**\n\n"
+"        - `<one>` The id of the message to cleanup after. This message won't be deleted.\n"
+"        - `<two>` The id of the message to cleanup before. This message won't be deleted.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:438
+#, docstring
+msgid "Delete the last X messages in the current channel.\n\n"
+"        Example:\n"
+"            - `[p]cleanup messages 26`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:476
+#, docstring
+msgid "Clean up command messages and messages from the bot in the current channel.\n\n"
+"        Can only cleanup custom commands and alias commands if those cogs are loaded.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:564
+#, docstring
+msgid "Clean up messages owned by the bot in the current channel.\n\n"
+"        By default, all messages are cleaned. If a second argument is specified,\n"
+"        it is used for pattern matching - only messages containing the given text will be deleted.\n\n"
+"        Examples:\n"
+"            - `[p]cleanup self 6`\n"
+"            - `[p]cleanup self 10 Pong`\n"
+"            - `[p]cleanup self 7 \"\" True`\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The max number of messages to cleanup. Must be a positive integer.\n"
+"        - `<match_pattern>` The text that messages must contain to be deleted. Use \"\" to skip this.\n"
+"        - `<delete_pinned>` Whether to delete pinned messages or not. Defaults to False\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/cleanup.py:650
+#, docstring
+msgid "Deletes duplicate messages in the channel from the last X messages and keeps only one copy.\n\n"
+"        Defaults to 50.\n\n"
+"        **Arguments:**\n\n"
+"        - `<number>` The number of messages to check for duplicates. Must be a positive integer.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:17
+msgid "{} doesn't look like a valid message ID."
+msgstr "{}看起來不是有效的訊息ID。"
+
+#: redbot/cogs/cleanup/converters.py:29
+msgid "{arg} is not an integer."
+msgstr ""
+
+#: redbot/cogs/cleanup/converters.py:31
+msgid "{arg} is not a positive integer."
+msgstr ""
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/customcom/__init__.py

@@ -0,0 +1,7 @@
+from redbot.core.bot import Red
+
+from .customcom import CustomCommands
+
+
+async def setup(bot: Red) -> None:
+    await bot.add_cog(CustomCommands(bot))

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/customcom/customcom.py

@@ -0,0 +1,880 @@
+import asyncio
+import re
+import random
+from datetime import datetime, timedelta
+from inspect import Parameter
+from typing import Iterable, List, Mapping, Tuple, Dict, Set, Literal, Union
+from urllib.parse import quote_plus
+
+import discord
+from rapidfuzz import process
+
+from redbot.core import Config, commands
+from redbot.core.i18n import Translator, cog_i18n
+from redbot.core.utils import menus, AsyncIter
+from redbot.core.utils.chat_formatting import box, pagify, escape, humanize_list
+from redbot.core.utils.predicates import MessagePredicate
+
+_ = Translator("CustomCommands", __file__)
+
+
+class CCError(Exception):
+    pass
+
+
+class AlreadyExists(CCError):
+    pass
+
+
+class ArgParseError(CCError):
+    pass
+
+
+class NotFound(CCError):
+    pass
+
+
+class OnCooldown(CCError):
+    pass
+
+
+class CommandNotEdited(CCError):
+    pass
+
+
+class ResponseTooLong(CCError):
+    pass
+
+
+class CommandObj:
+    def __init__(self, **kwargs):
+        self.config = kwargs.get("config")
+        self.bot = kwargs.get("bot")
+        self.db = self.config.guild
+
+    @staticmethod
+    async def get_commands(config) -> dict:
+        _commands = await config.commands()
+        return {k: v for k, v in _commands.items() if _commands[k]}
+
+    async def redact_author_ids(self, user_id: int):
+        all_guilds = await self.config.all_guilds()
+
+        for guild_id in all_guilds.keys():
+            await asyncio.sleep(0)
+            async with self.config.guild_from_id(guild_id).commands() as all_commands:
+                async for com_name, com_info in AsyncIter(all_commands.items(), steps=100):
+                    if not com_info:
+                        continue
+
+                    if com_info.get("author", {}).get("id", 0) == user_id:
+                        com_info["author"]["id"] = 0xDE1
+                        com_info["author"]["name"] = "Deleted User"
+
+                    if editors := com_info.get("editors", None):
+                        for index, editor_id in enumerate(editors):
+                            if editor_id == user_id:
+                                editors[index] = 0xDE1
+
+    async def get_responses(self, ctx):
+        intro = _(
+            "Welcome to the interactive random {cc} maker!\n"
+            "Every message you send will be added as one of the random "
+            "responses to choose from once this {cc} is "
+            "triggered. To exit this interactive menu, type `{quit}`"
+        ).format(cc="customcommand", quit="exit()")
+        await ctx.send(intro)
+
+        responses = []
+        args = None
+        while True:
+            await ctx.send(_("Add a random response:"))
+            msg = await self.bot.wait_for("message", check=MessagePredicate.same_context(ctx))
+
+            if msg.content.lower() == "exit()":
+                break
+            elif len(msg.content) > 2000:
+                await ctx.send(
+                    _(
+                        "The text response you're trying to create has more than 2000 characters.\n"
+                        "I cannot send messages that are longer than 2000 characters, please try again."
+                    )
+                )
+                continue
+            else:
+                try:
+                    this_args = ctx.cog.prepare_args(msg.content)
+                except ArgParseError as e:
+                    await ctx.send(e.args[0])
+                    continue
+                if args and args != this_args:
+                    await ctx.send(_("Random responses must take the same arguments!"))
+                    continue
+                args = args or this_args
+                responses.append(msg.content)
+        return responses
+
+    @staticmethod
+    def get_now() -> str:
+        # Get current time as a string, for 'created_at' and 'edited_at' fields
+        # in the ccinfo dict
+        return "{:%d/%m/%Y %H:%M:%S}".format(datetime.utcnow())
+
+    async def get(self, message: discord.Message, command: str) -> Tuple[str, Dict]:
+        if not command:
+            raise NotFound()
+        ccinfo = await self.db(message.guild).commands.get_raw(command, default=None)
+        if not ccinfo:
+            raise NotFound()
+        else:
+            return ccinfo["response"], ccinfo.get("cooldowns", {})
+
+    async def get_full(self, message: discord.Message, command: str) -> Dict:
+        ccinfo = await self.db(message.guild).commands.get_raw(command, default=None)
+        if ccinfo:
+            return ccinfo
+        else:
+            raise NotFound()
+
+    async def create(
+        self, ctx: commands.Context, command: str, *, response: Union[str, List[str]]
+    ):
+        """Create a custom command"""
+        # Check if this command is already registered as a customcommand
+        if await self.db(ctx.guild).commands.get_raw(command, default=None):
+            raise AlreadyExists()
+        # Check against those pesky nitro users!
+        if isinstance(response, str) and len(response) > 2000:
+            raise ResponseTooLong()
+        elif isinstance(response, list) and any([len(i) > 2000 for i in response]):
+            raise ResponseTooLong()
+        # test to raise
+        ctx.cog.prepare_args(response if isinstance(response, str) else response[0])
+        author = ctx.message.author
+        ccinfo = {
+            "author": {"id": author.id, "name": str(author)},
+            "command": command,
+            "cooldowns": {},
+            "created_at": self.get_now(),
+            "editors": [],
+            "response": response,
+        }
+        await self.db(ctx.guild).commands.set_raw(command, value=ccinfo)
+
+    async def edit(
+        self,
+        ctx: commands.Context,
+        command: str,
+        *,
+        response=None,
+        cooldowns: Mapping[str, int] = None,
+        ask_for: bool = True,
+    ):
+        """Edit an already existing custom command"""
+        ccinfo = await self.db(ctx.guild).commands.get_raw(command, default=None)
+
+        # Check if this command is registered
+        if not ccinfo:
+            raise NotFound()
+
+        author = ctx.message.author
+
+        if ask_for and not response:
+            await ctx.send(_("Do you want to create a 'randomized' custom command?") + " (yes/no)")
+
+            pred = MessagePredicate.yes_or_no(ctx)
+            try:
+                await self.bot.wait_for("message", check=pred, timeout=30)
+            except asyncio.TimeoutError:
+                await ctx.send(_("Response timed out, please try again later."))
+                raise CommandNotEdited()
+            if pred.result is True:
+                response = await self.get_responses(ctx=ctx)
+            else:
+                await ctx.send(_("What response do you want?"))
+                try:
+                    resp = await self.bot.wait_for(
+                        "message", check=MessagePredicate.same_context(ctx), timeout=180
+                    )
+                except asyncio.TimeoutError:
+                    await ctx.send(_("Response timed out, please try again later."))
+                    raise CommandNotEdited()
+                response = resp.content
+
+        if response:
+            # test to raise
+            if len(response) > 2000:
+                raise ResponseTooLong()
+            ctx.cog.prepare_args(response if isinstance(response, str) else response[0])
+            ccinfo["response"] = response
+
+        if cooldowns:
+            ccinfo.setdefault("cooldowns", {}).update(cooldowns)
+            for key, value in ccinfo["cooldowns"].copy().items():
+                if value <= 0:
+                    del ccinfo["cooldowns"][key]
+
+        if author.id not in ccinfo["editors"]:
+            # Add the person who invoked the `edit` coroutine to the list of
+            # editors, if the person is not yet in there
+            ccinfo["editors"].append(author.id)
+
+        ccinfo["edited_at"] = self.get_now()
+
+        await self.db(ctx.guild).commands.set_raw(command, value=ccinfo)
+
+    async def delete(self, ctx: commands.Context, command: str):
+        """Delete an already existing custom command"""
+        # Check if this command is registered
+        if not await self.db(ctx.guild).commands.get_raw(command, default=None):
+            raise NotFound()
+        await self.db(ctx.guild).commands.set_raw(command, value=None)
+
+
+@cog_i18n(_)
+class CustomCommands(commands.Cog):
+    """This cog contains commands for creating and managing custom commands that display text.
+
+    These are useful for storing information members might need, like FAQ answers or invite links.
+    Custom commands can be used by anyone by default, so be careful with pings.
+    Commands can only be lowercase, and will not respond to any uppercase letters.
+    """
+
+    def __init__(self, bot):
+        super().__init__()
+        self.bot = bot
+        self.key = 414589031223512
+        self.config = Config.get_conf(self, self.key)
+        self.config.register_guild(commands={})
+        self.commandobj = CommandObj(config=self.config, bot=self.bot)
+        self.cooldowns = {}
+
+    async def red_delete_data_for_user(
+        self,
+        *,
+        requester: Literal["discord_deleted_user", "owner", "user", "user_strict"],
+        user_id: int,
+    ):
+        if requester != "discord_deleted_user":
+            return
+
+        await self.commandobj.redact_author_ids(user_id)
+
+    @commands.group(aliases=["cc"])
+    @commands.guild_only()
+    async def customcom(self, ctx: commands.Context):
+        """Base command for Custom Commands management."""
+        pass
+
+    @customcom.command(name="raw")
+    async def cc_raw(self, ctx: commands.Context, command: str.lower):
+        """Get the raw response of a custom command, to get the proper markdown.
+
+        This is helpful for copy and pasting.
+
+        **Arguments:**
+
+        - `<command>` The custom command to get the raw response of."""
+        commands = await self.config.guild(ctx.guild).commands()
+        if command not in commands:
+            return await ctx.send("That command doesn't exist.")
+        command = commands[command]
+        if isinstance(command["response"], str):
+            raw = discord.utils.escape_markdown(command["response"])
+            if len(raw) > 2000:
+                raw = f"{raw[:1997]}..."
+            await ctx.send(raw)
+        else:
+            msglist = []
+            if await ctx.embed_requested():
+                colour = await ctx.embed_colour()
+                for number, response in enumerate(command["response"], start=1):
+                    raw = discord.utils.escape_markdown(response)
+                    if len(raw) > 2048:
+                        raw = f"{raw[:2045]}..."
+                    embed = discord.Embed(
+                        title=_("Response #{num}/{total}").format(
+                            num=number, total=len(command["response"])
+                        ),
+                        description=raw,
+                        colour=colour,
+                    )
+                    msglist.append(embed)
+            else:
+                for number, response in enumerate(command["response"], start=1):
+                    raw = discord.utils.escape_markdown(response)
+                    msg = _("Response #{num}/{total}:\n{raw}").format(
+                        num=number, total=len(command["response"]), raw=raw
+                    )
+                    if len(msg) > 2000:
+                        msg = f"{msg[:1997]}..."
+                    msglist.append(msg)
+            await menus.menu(ctx, msglist)
+
+    @customcom.command(name="search")
+    @commands.guild_only()
+    async def cc_search(self, ctx: commands.Context, *, query):
+        """
+        Searches through custom commands, according to the query.
+
+        Uses fuzzy searching to find close matches.
+
+        **Arguments:**
+
+        - `<query>` The query to search for. Can be multiple words.
+        """
+        cc_commands = await CommandObj.get_commands(self.config.guild(ctx.guild))
+        extracted = process.extract(query, list(cc_commands.keys()))
+        accepted = []
+        for key, score, __ in extracted:
+            if score > 60:
+                # Match was decently strong
+                accepted.append((key, cc_commands[key]))
+            else:
+                # Match wasn't strong enough
+                pass
+        if len(accepted) == 0:
+            return await ctx.send(_("No close matches were found."))
+        results = self.prepare_command_list(ctx, accepted)
+        if await ctx.embed_requested():
+            content = " \n".join(map("**{0[0]}** {0[1]}".format, results))
+            embed = discord.Embed(
+                title=_("Search results"), description=content, colour=await ctx.embed_colour()
+            )
+            await ctx.send(embed=embed)
+        else:
+            content = "\n".join(map("{0[0]:<12} : {0[1]}".format, results))
+            await ctx.send(_("The following matches have been found:") + box(content))
+
+    @customcom.group(name="create", aliases=["add"], invoke_without_command=True)
+    @commands.mod_or_permissions(administrator=True)
+    async def cc_create(self, ctx: commands.Context, command: str.lower, *, text: str):
+        """Create custom commands.
+
+        If a type is not specified, a simple CC will be created.
+        CCs can be enhanced with arguments, see the guide
+        [here](https://docs.discord.red/en/stable/cog_customcom.html).
+        """
+        await ctx.invoke(self.cc_create_simple, command=command, text=text)
+
+    @cc_create.command(name="random")
+    @commands.mod_or_permissions(administrator=True)
+    async def cc_create_random(self, ctx: commands.Context, command: str.lower):
+        """Create a CC where it will randomly choose a response!
+
+        Note: This command is interactive.
+
+        **Arguments:**
+
+        - `<command>` The command executed to return the text. Cast to lowercase.
+        """
+        if any(char.isspace() for char in command):
+            # Haha, nice try
+            await ctx.send(_("Custom command names cannot have spaces in them."))
+            return
+        if command in (*self.bot.all_commands, *commands.RESERVED_COMMAND_NAMES):
+            await ctx.send(_("There already exists a bot command with the same name."))
+            return
+        responses = await self.commandobj.get_responses(ctx=ctx)
+        if not responses:
+            await ctx.send(_("Custom command process cancelled."))
+            return
+        try:
+            await self.commandobj.create(ctx=ctx, command=command, response=responses)
+            await ctx.send(_("Custom command successfully added."))
+        except AlreadyExists:
+            await ctx.send(
+                _("This command already exists. Use `{command}` to edit it.").format(
+                    command=f"{ctx.clean_prefix}customcom edit"
+                )
+            )
+        except ResponseTooLong:  # This isn't needed, however may be a good idea to keep this.
+            await ctx.send(
+                _(
+                    "The text response you're trying to create has more than 2000 characters.\n"
+                    "I cannot send messages that are longer than 2000 characters."
+                )
+            )
+
+    @cc_create.command(name="simple")
+    @commands.mod_or_permissions(administrator=True)
+    async def cc_create_simple(self, ctx, command: str.lower, *, text: str):
+        """Add a simple custom command.
+
+        Example:
+            - `[p]customcom create simple yourcommand Text you want`
+
+        **Arguments:**
+
+        - `<command>` The command executed to return the text. Cast to lowercase.
+        - `<text>` The text to return when executing the command. See guide for enhanced usage.
+        """
+        if any(char.isspace() for char in command):
+            # Haha, nice try
+            await ctx.send(_("Custom command names cannot have spaces in them."))
+            return
+        if command in (*self.bot.all_commands, *commands.RESERVED_COMMAND_NAMES):
+            await ctx.send(_("There already exists a bot command with the same name."))
+            return
+        try:
+            await self.commandobj.create(ctx=ctx, command=command, response=text)
+            await ctx.send(_("Custom command successfully added."))
+        except AlreadyExists:
+            await ctx.send(
+                _("This command already exists. Use `{command}` to edit it.").format(
+                    command=f"{ctx.clean_prefix}customcom edit"
+                )
+            )
+        except ArgParseError as e:
+            await ctx.send(e.args[0])
+        except ResponseTooLong:
+            await ctx.send(
+                _(
+                    "The text response you're trying to create has more than 2000 characters.\n"
+                    "I cannot send messages that are longer than 2000 characters."
+                )
+            )
+
+    @customcom.command(name="cooldown")
+    @commands.mod_or_permissions(administrator=True)
+    async def cc_cooldown(
+        self, ctx, command: str.lower, cooldown: int = None, *, per: str.lower = "member"
+    ):
+        """Set, edit, or view the cooldown for a custom command.
+
+        You may set cooldowns per member, channel, or guild. Multiple
+        cooldowns may be set. All cooldowns must be cooled to call the
+        custom command.
+
+        Examples:
+            - `[p]customcom cooldown pingrole`
+            - `[p]customcom cooldown yourcommand 30`
+            - `[p]cc cooldown mycommand 30 guild`
+
+        **Arguments:**
+
+        - `<command>` The custom command to check or set the cooldown.
+        - `[cooldown]` The number of seconds to wait before allowing the command to be invoked again. If omitted, will instead return the current cooldown settings.
+        - `[per]` The group to apply the cooldown on. Defaults to per member. Valid choices are server / guild, user / member, and channel.
+        """
+        if cooldown is None:
+            try:
+                cooldowns = (await self.commandobj.get(ctx.message, command))[1]
+            except NotFound:
+                return await ctx.send(_("That command doesn't exist."))
+            if cooldowns:
+                cooldown = []
+                for per, rate in cooldowns.items():
+                    cooldown.append(
+                        _("A {} may call this command every {} seconds").format(per, rate)
+                    )
+                return await ctx.send("\n".join(cooldown))
+            else:
+                return await ctx.send(_("This command has no cooldown."))
+        per = {"server": "guild", "user": "member"}.get(per, per)
+        allowed = ("guild", "member", "channel")
+        if per not in allowed:
+            return await ctx.send(_("{} must be one of {}").format("per", ", ".join(allowed)))
+        cooldown = {per: cooldown}
+        try:
+            await self.commandobj.edit(ctx=ctx, command=command, cooldowns=cooldown, ask_for=False)
+            await ctx.send(_("Custom command cooldown successfully edited."))
+        except NotFound:
+            await ctx.send(
+                _("That command doesn't exist. Use `{command}` to add it.").format(
+                    command=f"{ctx.clean_prefix}customcom create"
+                )
+            )
+
+    @customcom.command(name="delete", aliases=["del", "remove"])
+    @commands.mod_or_permissions(administrator=True)
+    async def cc_delete(self, ctx, command: str.lower):
+        """Delete a custom command.
+
+        Example:
+            - `[p]customcom delete yourcommand`
+
+        **Arguments:**
+
+        - `<command>` The custom command to delete.
+        """
+        try:
+            await self.commandobj.delete(ctx=ctx, command=command)
+            await ctx.send(_("Custom command successfully deleted."))
+        except NotFound:
+            await ctx.send(_("That command doesn't exist."))
+
+    @customcom.command(name="edit")
+    @commands.mod_or_permissions(administrator=True)
+    async def cc_edit(self, ctx, command: str.lower, *, text: str = None):
+        """Edit a custom command.
+
+        Example:
+            - `[p]customcom edit yourcommand Text you want`
+
+        **Arguments:**
+
+        - `<command>` The custom command to edit.
+        - `<text>` The new text to return when executing the command.
+        """
+        try:
+            await self.commandobj.edit(ctx=ctx, command=command, response=text)
+            await ctx.send(_("Custom command successfully edited."))
+        except NotFound:
+            await ctx.send(
+                _("That command doesn't exist. Use `{command}` to add it.").format(
+                    command=f"{ctx.clean_prefix}customcom create"
+                )
+            )
+        except ArgParseError as e:
+            await ctx.send(e.args[0])
+        except CommandNotEdited:
+            pass
+        except ResponseTooLong:
+            await ctx.send(
+                _(
+                    "The text response you're trying to create has more than 2000 characters.\n"
+                    "I cannot send messages that are longer than 2000 characters."
+                )
+            )
+
+    @customcom.command(name="list")
+    @commands.bot_can_react()
+    async def cc_list(self, ctx: commands.Context):
+        """List all available custom commands.
+
+        The list displays a preview of each command's response, with
+        markdown escaped and newlines replaced with spaces.
+        """
+        cc_dict = await CommandObj.get_commands(self.config.guild(ctx.guild))
+
+        if not cc_dict:
+            await ctx.send(
+                _(
+                    "There are no custom commands in this server."
+                    " Use `{command}` to start adding some."
+                ).format(command=f"{ctx.clean_prefix}customcom create")
+            )
+            return
+
+        results = self.prepare_command_list(ctx, sorted(cc_dict.items(), key=lambda t: t[0]))
+
+        if await ctx.embed_requested():
+            # We need a space before the newline incase the CC preview ends in link (GH-2295)
+            content = " \n".join(map("**{0[0]}** {0[1]}".format, results))
+            pages = list(pagify(content, page_length=1024))
+            embed_pages = []
+            for idx, page in enumerate(pages, start=1):
+                embed = discord.Embed(
+                    title=_("Custom Command List"),
+                    description=page,
+                    colour=await ctx.embed_colour(),
+                )
+                embed.set_footer(text=_("Page {num}/{total}").format(num=idx, total=len(pages)))
+                embed_pages.append(embed)
+            await menus.menu(ctx, embed_pages)
+        else:
+            content = "\n".join(map("{0[0]:<12} : {0[1]}".format, results))
+            pages = list(map(box, pagify(content, page_length=2000, shorten_by=10)))
+            await menus.menu(ctx, pages)
+
+    @customcom.command(name="show")
+    async def cc_show(self, ctx, command_name: str):
+        """Shows a custom command's responses and its settings.
+
+        **Arguments:**
+
+        - `<command_name>` The custom command to show.
+        """
+
+        try:
+            cmd = await self.commandobj.get_full(ctx.message, command_name)
+        except NotFound:
+            await ctx.send(_("I could not not find that custom command."))
+            return
+
+        responses = cmd["response"]
+
+        if isinstance(responses, str):
+            responses = [responses]
+
+        _aid = cmd["author"]["id"]
+
+        if _aid == 0xDE1:
+            author = _("Deleted User")
+        elif member := ctx.guild.get_member(_aid):
+            author = f"{member} ({_aid})"
+        else:
+            author = f"{cmd['author']['name']} ({_aid})"
+
+        _type = _("Random") if len(responses) > 1 else _("Normal")
+
+        text = _(
+            "Command: {command_name}\n"
+            "Author: {author}\n"
+            "Created: {created_at}\n"
+            "Type: {type}\n"
+        ).format(
+            command_name=command_name, author=author, created_at=cmd["created_at"], type=_type
+        )
+
+        cooldowns = cmd.get("cooldowns", {})
+
+        if cooldowns:
+            cooldown_text = _("Cooldowns:\n")
+            for rate, per in cooldowns.items():
+                cooldown_text += _("{num} seconds per {period}\n").format(num=per, period=rate)
+            text += cooldown_text
+
+        text += _("Responses:\n")
+        responses = ["- " + r for r in responses]
+        text += "\n".join(responses)
+
+        for p in pagify(text):
+            await ctx.send(box(p, lang="yaml"))
+
+    @commands.Cog.listener()
+    async def on_message_without_command(self, message):
+        is_private = message.guild is None
+
+        # user_allowed check, will be replaced with self.bot.user_allowed or
+        # something similar once it's added
+        user_allowed = True
+
+        if isinstance(message.channel, discord.PartialMessageable):
+            return
+
+        if len(message.content) < 2 or is_private or not user_allowed or message.author.bot:
+            return
+
+        if await self.bot.cog_disabled_in_guild(self, message.guild):
+            return
+
+        ctx = await self.bot.get_context(message)
+
+        if ctx.prefix is None:
+            return
+
+        try:
+            raw_response, cooldowns = await self.commandobj.get(
+                message=message, command=ctx.invoked_with
+            )
+            if isinstance(raw_response, list):
+                raw_response = random.choice(raw_response)
+            elif isinstance(raw_response, str):
+                pass
+            else:
+                raise NotFound()
+            if cooldowns:
+                self.test_cooldowns(ctx, ctx.invoked_with, cooldowns)
+        except CCError:
+            return
+
+        # wrap the command here so it won't register with the bot
+        fake_cc = commands.command(name=ctx.invoked_with)(self.cc_callback)
+        fake_cc.params = self.prepare_args(raw_response)
+        fake_cc.requires.ready_event.set()
+        ctx.command = fake_cc
+
+        await self.bot.invoke(ctx)
+        if not ctx.command_failed:
+            await self.cc_command(*ctx.args, **ctx.kwargs, raw_response=raw_response)
+
+    async def cc_callback(self, *args, **kwargs) -> None:
+        """
+        Custom command.
+
+        Created via the CustomCom cog. See `[p]customcom` for more details.
+        """
+        # fake command to take advantage of discord.py's parsing and events
+        pass
+
+    async def cc_command(self, ctx, *cc_args, raw_response, **cc_kwargs) -> None:
+        cc_args = (*cc_args, *cc_kwargs.values())
+        results = re.findall(r"{([^}]+)\}", raw_response)
+        for result in results:
+            param = self.transform_parameter(result, ctx.message)
+            raw_response = raw_response.replace("{" + result + "}", param)
+        results = re.findall(r"{((\d+)[^.}]*(\.[^:}]+)?[^}]*)\}", raw_response)
+        if results:
+            low = min(int(result[1]) for result in results)
+            for result in results:
+                index = int(result[1]) - low
+                arg = self.transform_arg(result[0], result[2], cc_args[index])
+                raw_response = raw_response.replace("{" + result[0] + "}", arg)
+        await ctx.send(raw_response)
+
+    @staticmethod
+    def prepare_args(raw_response) -> Mapping[str, Parameter]:
+        args = re.findall(r"{(\d+)[^:}]*(:[^.}]*)?[^}]*\}", raw_response)
+        if not args:
+            return {}
+        allowed_builtins = {
+            "bool": bool,
+            "complex": complex,
+            "float": float,
+            "frozenset": frozenset,
+            "int": int,
+            "list": list,
+            "set": set,
+            "str": str,
+            "tuple": tuple,
+            "query": quote_plus,
+        }
+        indices = [int(a[0]) for a in args]
+        low = min(indices)
+        indices = [a - low for a in indices]
+        high = max(indices)
+        if high > 9:
+            raise ArgParseError(_("Too many arguments!"))
+        gaps = set(indices).symmetric_difference(range(high + 1))
+        if gaps:
+            raise ArgParseError(
+                _("Arguments must be sequential. Missing arguments: ")
+                + ", ".join(str(i + low) for i in gaps)
+            )
+        fin = [Parameter("_" + str(i), Parameter.POSITIONAL_OR_KEYWORD) for i in range(high + 1)]
+        for arg in args:
+            index = int(arg[0]) - low
+            anno_raw = arg[1][1:]  # strip initial colon
+            if anno_raw.lower().endswith("converter"):
+                anno_raw = anno_raw[:-9]
+            if not anno_raw or anno_raw.startswith("_"):  # public types only
+                name = "{}_{}".format("text", index if index < high else "final")
+                fin[index] = fin[index].replace(name=name)
+                continue
+            # allow type hinting only for discord.py and builtin types
+            try:
+                anno = getattr(discord, anno_raw)
+                # force an AttributeError if there's no discord.py converter
+                getattr(commands, anno.__name__ + "Converter")
+            except AttributeError:
+                anno = allowed_builtins.get(anno_raw.lower(), Parameter.empty)
+            if (
+                anno is not Parameter.empty
+                and fin[index].annotation is not Parameter.empty
+                and anno != fin[index].annotation
+            ):
+                raise ArgParseError(
+                    _(
+                        'Conflicting colon notation for argument {index}: "{name1}" and "{name2}".'
+                    ).format(
+                        index=index + low,
+                        name1=fin[index].annotation.__name__,
+                        name2=anno.__name__,
+                    )
+                )
+            if anno is not Parameter.empty:
+                fin[index] = fin[index].replace(annotation=anno)
+        # consume rest
+        fin[-1] = fin[-1].replace(kind=Parameter.KEYWORD_ONLY)
+        # name the parameters for the help text
+        for i, param in enumerate(fin):
+            anno = param.annotation
+            name = "{}_{}".format(
+                "text" if anno is Parameter.empty else anno.__name__.lower(),
+                i if i < high else "final",
+            )
+            fin[i] = fin[i].replace(name=name)
+        return dict((p.name, p) for p in fin)
+
+    def test_cooldowns(self, ctx, command, cooldowns):
+        now = datetime.utcnow()
+        new_cooldowns = {}
+        for per, rate in cooldowns.items():
+            if per == "guild":
+                key = (command, ctx.guild)
+            elif per == "channel":
+                key = (command, ctx.guild, ctx.channel)
+            elif per == "member":
+                key = (command, ctx.guild, ctx.author)
+            else:
+                raise ValueError(per)
+            cooldown = self.cooldowns.get(key)
+            if cooldown:
+                cooldown += timedelta(seconds=rate)
+                if cooldown > now:
+                    raise OnCooldown()
+            new_cooldowns[key] = now
+        # only update cooldowns if the command isn't on cooldown
+        self.cooldowns.update(new_cooldowns)
+
+    @classmethod
+    def transform_arg(cls, result, attr, obj) -> str:
+        attr = attr[1:]  # strip initial dot
+        if not attr:
+            return cls.maybe_humanize_list(obj)
+        raw_result = "{" + result + "}"
+        # forbid private members and nested attr lookups
+        if attr.startswith("_") or "." in attr:
+            return raw_result
+        return cls.maybe_humanize_list(getattr(obj, attr, raw_result))
+
+    @staticmethod
+    def maybe_humanize_list(thing) -> str:
+        if isinstance(thing, str):
+            return thing
+        try:
+            return humanize_list(list(map(str, thing)))
+        except TypeError:
+            return str(thing)
+
+    @staticmethod
+    def transform_parameter(result, message) -> str:
+        """
+        For security reasons only specific objects are allowed
+        Internals are ignored
+        """
+        raw_result = "{" + result + "}"
+        objects = {
+            "message": message,
+            "author": message.author,
+            "channel": message.channel,
+            "guild": message.guild,
+            "server": message.guild,
+        }
+        if result in objects:
+            return str(objects[result])
+        try:
+            first, second = result.split(".")
+        except ValueError:
+            return raw_result
+        if first in objects and not second.startswith("_"):
+            first = objects[first]
+        else:
+            return raw_result
+        return str(getattr(first, second, raw_result))
+
+    async def get_command_names(self, guild: discord.Guild) -> Set[str]:
+        """Get all custom command names in a guild.
+
+        Returns
+        --------
+        Set[str]
+            A set of all custom command names.
+
+        """
+        return set(await CommandObj.get_commands(self.config.guild(guild)))
+
+    @staticmethod
+    def prepare_command_list(
+        ctx: commands.Context, command_list: Iterable[Tuple[str, dict]]
+    ) -> List[Tuple[str, str]]:
+        results = []
+        for command, body in command_list:
+            responses = body["response"]
+            if isinstance(responses, list):
+                result = ", ".join(responses)
+            elif isinstance(responses, str):
+                result = responses
+            else:
+                continue
+            # Cut preview to 52 characters max
+            if len(result) > 52:
+                result = result[:49] + "..."
+            # Replace newlines with spaces
+            result = result.replace("\n", " ")
+            # Escape markdown and mass mentions
+            result = escape(result, formatting=True, mass_mentions=True)
+            results.append((f"{ctx.clean_prefix}{command}", result))
+        return results

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/customcom/locales/af-ZA.po

@@ -0,0 +1,296 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-02-11 12:29+0000\n"
+"Last-Translator: \n"
+"Language-Team: Afrikaans\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: af\n"
+"X-Crowdin-File-ID: 41\n"
+"Language: af_ZA\n"
+
+#: redbot/cogs/customcom/customcom.py:78
+msgid "Welcome to the interactive random {cc} maker!\n"
+"Every message you send will be added as one of the random responses to choose from once this {cc} is triggered. To exit this interactive menu, type `{quit}`"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:89
+msgid "Add a random response:"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:101
+msgid "Random responses must take the same arguments!"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:166
+msgid "Do you want to create a 'randomized' custom command? (y/n)"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:172
+#: redbot/cogs/customcom/customcom.py:183
+msgid "Response timed out, please try again later."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:177
+msgid "What response do you want?"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:217
+#, docstring
+msgid "This cog contains commands for creating and managing custom commands that display text.\n\n"
+"    These are useful for storing information members might need, like FAQ answers or invite links.\n"
+"    Custom commands can be used by anyone by default, so be careful with pings.\n"
+"    Commands can only be lowercase, and will not respond to any uppercase letters.\n"
+"    "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:247
+#, docstring
+msgid "Base command for Custom Commands management."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:252
+#, docstring
+msgid "Get the raw response of a custom command, to get the proper markdown.\n\n"
+"        This is helpful for copy and pasting.\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to get the raw response of."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:277
+msgid "Response #{num}/{total}"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:287
+msgid "Response #{num}/{total}:\n"
+"{raw}"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:298
+#, docstring
+msgid "\n"
+"        Searches through custom commands, according to the query.\n\n"
+"        Uses fuzzywuzzy searching to find close matches.\n\n"
+"        **Arguments:**\n\n"
+"        - `<query>` The query to search for. Can be multiple words.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:318
+msgid "No close matches were found."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:323
+msgid "Search results"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:328
+msgid "The following matches have been found:"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:333
+#, docstring
+msgid "Create custom commands.\n\n"
+"        If a type is not specified, a simple CC will be created.\n"
+"        CCs can be enhanced with arguments, see the guide\n"
+"        [here](https://docs.discord.red/en/stable/cog_customcom.html).\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:344
+#, docstring
+msgid "Create a CC where it will randomly choose a response!\n\n"
+"        Note: This command is interactive.\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The command executed to return the text. Cast to lowercase.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:354
+#: redbot/cogs/customcom/customcom.py:388
+msgid "Custom command names cannot have spaces in them."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:357
+#: redbot/cogs/customcom/customcom.py:391
+msgid "There already exists a bot command with the same name."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:361
+msgid "Custom command process cancelled."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:365
+#: redbot/cogs/customcom/customcom.py:395
+msgid "Custom command successfully added."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:368
+#: redbot/cogs/customcom/customcom.py:398
+msgid "This command already exists. Use `{command}` to edit it."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:376
+#, docstring
+msgid "Add a simple custom command.\n\n"
+"        Example:\n"
+"            - `[p]customcom create simple yourcommand Text you want`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The command executed to return the text. Cast to lowercase.\n"
+"        - `<text>` The text to return when executing the command. See guide for enhanced usage.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:410
+#, docstring
+msgid "Set, edit, or view the cooldown for a custom command.\n\n"
+"        You may set cooldowns per member, channel, or guild. Multiple\n"
+"        cooldowns may be set. All cooldowns must be cooled to call the\n"
+"        custom command.\n\n"
+"        Examples:\n"
+"            - `[p]customcom cooldown pingrole`\n"
+"            - `[p]customcom cooldown yourcommand 30`\n"
+"            - `[p]cc cooldown mycommand 30 guild`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to check or set the cooldown.\n"
+"        - `<cooldown>` The number of seconds to wait before allowing the command to be invoked again. If omitted, will instead return the current cooldown settings.\n"
+"        - `<per>` The group to apply the cooldown on. Defaults to per member. Valid choices are server, guild, user, and member.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:431
+#: redbot/cogs/customcom/customcom.py:472
+msgid "That command doesn't exist."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:436
+msgid "A {} may call this command every {} seconds"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:440
+msgid "This command has no cooldown."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:444
+msgid "{} must be one of {}"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:448
+msgid "Custom command cooldown successfully edited."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:451
+#: redbot/cogs/customcom/customcom.py:492
+msgid "That command doesn't exist. Use `{command}` to add it."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:459
+#, docstring
+msgid "Delete a custom command.\n\n"
+"        Example:\n"
+"            - `[p]customcom delete yourcommand`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to delete.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:470
+msgid "Custom command successfully deleted."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:477
+#, docstring
+msgid "Edit a custom command.\n\n"
+"        Example:\n"
+"            - `[p]customcom edit yourcommand Text you want`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to edit.\n"
+"        - `<text>` The new text to return when executing the command.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:489
+msgid "Custom command successfully edited."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:504
+#, docstring
+msgid "List all available custom commands.\n\n"
+"        The list displays a preview of each command's response, with\n"
+"        markdown escaped and newlines replaced with spaces.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:513
+msgid "There are no custom commands in this server. Use `{command}` to start adding some."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:529
+msgid "Custom Command List"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:533
+msgid "Page {num}/{total}"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:543
+#, docstring
+msgid "Shows a custom command's responses and its settings.\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to show.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:553
+msgid "I could not not find that custom command."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:564
+msgid "Deleted User"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:570
+msgid "Random"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:570
+msgid "Normal"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:572
+msgid "Command: {command_name}\n"
+"Author: {author}\n"
+"Created: {created_at}\n"
+"Type: {type}\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:584
+msgid "Cooldowns:\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:586
+msgid "{num} seconds per {period}\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:589
+msgid "Responses:\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:687
+msgid "Too many arguments!"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:691
+msgid "Arguments must be sequential. Missing arguments: "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:717
+msgid "Conflicting colon notation for argument {index}: \"{name1}\" and \"{name2}\"."
+msgstr ""
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/customcom/locales/ar-SA.po

@@ -0,0 +1,304 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-02-11 12:29+0000\n"
+"Last-Translator: \n"
+"Language-Team: Arabic\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=6; plural=(n==0 ? 0 : n==1 ? 1 : n==2 ? 2 : n%100>=3 && n%100<=10 ? 3 : n%100>=11 && n%100<=99 ? 4 : 5);\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: ar\n"
+"X-Crowdin-File-ID: 41\n"
+"Language: ar_SA\n"
+
+#: redbot/cogs/customcom/customcom.py:78
+msgid "Welcome to the interactive random {cc} maker!\n"
+"Every message you send will be added as one of the random responses to choose from once this {cc} is triggered. To exit this interactive menu, type `{quit}`"
+msgstr "مرحبا بكم في صانع {cc} العشوائي التفاعلي!\n"
+"سيتم إضافة كل رسالة ترسلها كأحد الاستجابات العشوائية للاختيار منها بمجرد تشغيل هذا {cc}. للخروج من هذه القائمة التفاعلية، اكتب `{quit}`"
+
+#: redbot/cogs/customcom/customcom.py:89
+msgid "Add a random response:"
+msgstr "إضافة رد عشوائي:"
+
+#: redbot/cogs/customcom/customcom.py:101
+msgid "Random responses must take the same arguments!"
+msgstr "يجب أن تأخذ الردود العشوائية نفس الحجج!"
+
+#: redbot/cogs/customcom/customcom.py:166
+msgid "Do you want to create a 'randomized' custom command? (y/n)"
+msgstr "هل تريد إنشاء أمر مخصص 'عشوائي'؟ (y/n)"
+
+#: redbot/cogs/customcom/customcom.py:172
+#: redbot/cogs/customcom/customcom.py:183
+msgid "Response timed out, please try again later."
+msgstr "انتهت مهلة الرد، يرجى المحاولة مرة أخرى لاحقاً."
+
+#: redbot/cogs/customcom/customcom.py:177
+msgid "What response do you want?"
+msgstr "ما هي الاستجابة التي تريدها؟"
+
+#: redbot/cogs/customcom/customcom.py:217
+#, docstring
+msgid "This cog contains commands for creating and managing custom commands that display text.\n\n"
+"    These are useful for storing information members might need, like FAQ answers or invite links.\n"
+"    Custom commands can be used by anyone by default, so be careful with pings.\n"
+"    Commands can only be lowercase, and will not respond to any uppercase letters.\n"
+"    "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:247
+#, docstring
+msgid "Base command for Custom Commands management."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:252
+#, docstring
+msgid "Get the raw response of a custom command, to get the proper markdown.\n\n"
+"        This is helpful for copy and pasting.\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to get the raw response of."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:277
+msgid "Response #{num}/{total}"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:287
+msgid "Response #{num}/{total}:\n"
+"{raw}"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:298
+#, docstring
+msgid "\n"
+"        Searches through custom commands, according to the query.\n\n"
+"        Uses fuzzywuzzy searching to find close matches.\n\n"
+"        **Arguments:**\n\n"
+"        - `<query>` The query to search for. Can be multiple words.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:318
+msgid "No close matches were found."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:323
+msgid "Search results"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:328
+msgid "The following matches have been found:"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:333
+#, docstring
+msgid "Create custom commands.\n\n"
+"        If a type is not specified, a simple CC will be created.\n"
+"        CCs can be enhanced with arguments, see the guide\n"
+"        [here](https://docs.discord.red/en/stable/cog_customcom.html).\n"
+"        "
+msgstr "إنشاء أوامر مخصصة.\n\n"
+"        إذا لم يتم تحديد نوع ما، سيتم إنشاء نسخة تطبيقية بسيطة.\n"
+"        يمكن تعزيز CCCCs بالحجج، راجع الدليل\n"
+"        [here]()\n"
+"        "
+
+#: redbot/cogs/customcom/customcom.py:344
+#, docstring
+msgid "Create a CC where it will randomly choose a response!\n\n"
+"        Note: This command is interactive.\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The command executed to return the text. Cast to lowercase.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:354
+#: redbot/cogs/customcom/customcom.py:388
+msgid "Custom command names cannot have spaces in them."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:357
+#: redbot/cogs/customcom/customcom.py:391
+msgid "There already exists a bot command with the same name."
+msgstr "يوجد بالفعل أمر بوت بنفس الاسم."
+
+#: redbot/cogs/customcom/customcom.py:361
+msgid "Custom command process cancelled."
+msgstr "ت�� إلغاء عملية الأوامر المخصصة."
+
+#: redbot/cogs/customcom/customcom.py:365
+#: redbot/cogs/customcom/customcom.py:395
+msgid "Custom command successfully added."
+msgstr "تم إضافة الأمر المخصص بنجاح."
+
+#: redbot/cogs/customcom/customcom.py:368
+#: redbot/cogs/customcom/customcom.py:398
+msgid "This command already exists. Use `{command}` to edit it."
+msgstr "هذا الأمر موجود بالفعل. استخدم `{command}` لتعديله."
+
+#: redbot/cogs/customcom/customcom.py:376
+#, docstring
+msgid "Add a simple custom command.\n\n"
+"        Example:\n"
+"            - `[p]customcom create simple yourcommand Text you want`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The command executed to return the text. Cast to lowercase.\n"
+"        - `<text>` The text to return when executing the command. See guide for enhanced usage.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:410
+#, docstring
+msgid "Set, edit, or view the cooldown for a custom command.\n\n"
+"        You may set cooldowns per member, channel, or guild. Multiple\n"
+"        cooldowns may be set. All cooldowns must be cooled to call the\n"
+"        custom command.\n\n"
+"        Examples:\n"
+"            - `[p]customcom cooldown pingrole`\n"
+"            - `[p]customcom cooldown yourcommand 30`\n"
+"            - `[p]cc cooldown mycommand 30 guild`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to check or set the cooldown.\n"
+"        - `<cooldown>` The number of seconds to wait before allowing the command to be invoked again. If omitted, will instead return the current cooldown settings.\n"
+"        - `<per>` The group to apply the cooldown on. Defaults to per member. Valid choices are server, guild, user, and member.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:431
+#: redbot/cogs/customcom/customcom.py:472
+msgid "That command doesn't exist."
+msgstr "هذا الأمر غير موجود."
+
+#: redbot/cogs/customcom/customcom.py:436
+msgid "A {} may call this command every {} seconds"
+msgstr "يجوز {} استخدام هذا الأمر كل {} ثانية"
+
+#: redbot/cogs/customcom/customcom.py:440
+msgid "This command has no cooldown."
+msgstr "هذا الأمر ليس له تبريد."
+
+#: redbot/cogs/customcom/customcom.py:444
+msgid "{} must be one of {}"
+msgstr "{} يجب أن تكون واحدة من {}"
+
+#: redbot/cogs/customcom/customcom.py:448
+msgid "Custom command cooldown successfully edited."
+msgstr "تم تعديل أمر تبريد مخصص بنجاح."
+
+#: redbot/cogs/customcom/customcom.py:451
+#: redbot/cogs/customcom/customcom.py:492
+msgid "That command doesn't exist. Use `{command}` to add it."
+msgstr "هذا الأمر غير موجود. استخدم `{command}` لإضافته."
+
+#: redbot/cogs/customcom/customcom.py:459
+#, docstring
+msgid "Delete a custom command.\n\n"
+"        Example:\n"
+"            - `[p]customcom delete yourcommand`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to delete.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:470
+msgid "Custom command successfully deleted."
+msgstr "تم حذف الأمر المخصص بنجاح."
+
+#: redbot/cogs/customcom/customcom.py:477
+#, docstring
+msgid "Edit a custom command.\n\n"
+"        Example:\n"
+"            - `[p]customcom edit yourcommand Text you want`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to edit.\n"
+"        - `<text>` The new text to return when executing the command.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:489
+msgid "Custom command successfully edited."
+msgstr "تم تعديل الأمر المخصص بنجاح."
+
+#: redbot/cogs/customcom/customcom.py:504
+#, docstring
+msgid "List all available custom commands.\n\n"
+"        The list displays a preview of each command's response, with\n"
+"        markdown escaped and newlines replaced with spaces.\n"
+"        "
+msgstr "قائمة جميع الأوامر المخصصة المتاحة.\n\n"
+"        القائمة تعرض معاينة لرد كل أمر، مع\n"
+"        حررت من الدرك واستعيض عن الخطوط الجديدة بمسافات.\n"
+"        "
+
+#: redbot/cogs/customcom/customcom.py:513
+msgid "There are no custom commands in this server. Use `{command}` to start adding some."
+msgstr "لا توجد أوامر مخصصة في هذا الخادم. استخدم `{command}` لبدء إضافة البعض."
+
+#: redbot/cogs/customcom/customcom.py:529
+msgid "Custom Command List"
+msgstr "قائمة الأوامر المخصصة"
+
+#: redbot/cogs/customcom/customcom.py:533
+msgid "Page {num}/{total}"
+msgstr "الصفحة {num}/{total}"
+
+#: redbot/cogs/customcom/customcom.py:543
+#, docstring
+msgid "Shows a custom command's responses and its settings.\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to show.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:553
+msgid "I could not not find that custom command."
+msgstr "لم أتمكن من العثور على هذا الأمر المخصص."
+
+#: redbot/cogs/customcom/customcom.py:564
+msgid "Deleted User"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:570
+msgid "Random"
+msgstr "عشوائي"
+
+#: redbot/cogs/customcom/customcom.py:570
+msgid "Normal"
+msgstr "عادي"
+
+#: redbot/cogs/customcom/customcom.py:572
+msgid "Command: {command_name}\n"
+"Author: {author}\n"
+"Created: {created_at}\n"
+"Type: {type}\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:584
+msgid "Cooldowns:\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:586
+msgid "{num} seconds per {period}\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:589
+msgid "Responses:\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:687
+msgid "Too many arguments!"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:691
+msgid "Arguments must be sequential. Missing arguments: "
+msgstr "يجب أن تكون الحجج متتابعة. الحجج المفقودة: "
+
+#: redbot/cogs/customcom/customcom.py:717
+msgid "Conflicting colon notation for argument {index}: \"{name1}\" and \"{name2}\"."
+msgstr ""
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/customcom/locales/bg-BG.po

@@ -0,0 +1,296 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-02-11 12:29+0000\n"
+"Last-Translator: \n"
+"Language-Team: Bulgarian\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: bg\n"
+"X-Crowdin-File-ID: 41\n"
+"Language: bg_BG\n"
+
+#: redbot/cogs/customcom/customcom.py:78
+msgid "Welcome to the interactive random {cc} maker!\n"
+"Every message you send will be added as one of the random responses to choose from once this {cc} is triggered. To exit this interactive menu, type `{quit}`"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:89
+msgid "Add a random response:"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:101
+msgid "Random responses must take the same arguments!"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:166
+msgid "Do you want to create a 'randomized' custom command? (y/n)"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:172
+#: redbot/cogs/customcom/customcom.py:183
+msgid "Response timed out, please try again later."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:177
+msgid "What response do you want?"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:217
+#, docstring
+msgid "This cog contains commands for creating and managing custom commands that display text.\n\n"
+"    These are useful for storing information members might need, like FAQ answers or invite links.\n"
+"    Custom commands can be used by anyone by default, so be careful with pings.\n"
+"    Commands can only be lowercase, and will not respond to any uppercase letters.\n"
+"    "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:247
+#, docstring
+msgid "Base command for Custom Commands management."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:252
+#, docstring
+msgid "Get the raw response of a custom command, to get the proper markdown.\n\n"
+"        This is helpful for copy and pasting.\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to get the raw response of."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:277
+msgid "Response #{num}/{total}"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:287
+msgid "Response #{num}/{total}:\n"
+"{raw}"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:298
+#, docstring
+msgid "\n"
+"        Searches through custom commands, according to the query.\n\n"
+"        Uses fuzzywuzzy searching to find close matches.\n\n"
+"        **Arguments:**\n\n"
+"        - `<query>` The query to search for. Can be multiple words.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:318
+msgid "No close matches were found."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:323
+msgid "Search results"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:328
+msgid "The following matches have been found:"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:333
+#, docstring
+msgid "Create custom commands.\n\n"
+"        If a type is not specified, a simple CC will be created.\n"
+"        CCs can be enhanced with arguments, see the guide\n"
+"        [here](https://docs.discord.red/en/stable/cog_customcom.html).\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:344
+#, docstring
+msgid "Create a CC where it will randomly choose a response!\n\n"
+"        Note: This command is interactive.\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The command executed to return the text. Cast to lowercase.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:354
+#: redbot/cogs/customcom/customcom.py:388
+msgid "Custom command names cannot have spaces in them."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:357
+#: redbot/cogs/customcom/customcom.py:391
+msgid "There already exists a bot command with the same name."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:361
+msgid "Custom command process cancelled."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:365
+#: redbot/cogs/customcom/customcom.py:395
+msgid "Custom command successfully added."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:368
+#: redbot/cogs/customcom/customcom.py:398
+msgid "This command already exists. Use `{command}` to edit it."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:376
+#, docstring
+msgid "Add a simple custom command.\n\n"
+"        Example:\n"
+"            - `[p]customcom create simple yourcommand Text you want`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The command executed to return the text. Cast to lowercase.\n"
+"        - `<text>` The text to return when executing the command. See guide for enhanced usage.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:410
+#, docstring
+msgid "Set, edit, or view the cooldown for a custom command.\n\n"
+"        You may set cooldowns per member, channel, or guild. Multiple\n"
+"        cooldowns may be set. All cooldowns must be cooled to call the\n"
+"        custom command.\n\n"
+"        Examples:\n"
+"            - `[p]customcom cooldown pingrole`\n"
+"            - `[p]customcom cooldown yourcommand 30`\n"
+"            - `[p]cc cooldown mycommand 30 guild`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to check or set the cooldown.\n"
+"        - `<cooldown>` The number of seconds to wait before allowing the command to be invoked again. If omitted, will instead return the current cooldown settings.\n"
+"        - `<per>` The group to apply the cooldown on. Defaults to per member. Valid choices are server, guild, user, and member.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:431
+#: redbot/cogs/customcom/customcom.py:472
+msgid "That command doesn't exist."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:436
+msgid "A {} may call this command every {} seconds"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:440
+msgid "This command has no cooldown."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:444
+msgid "{} must be one of {}"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:448
+msgid "Custom command cooldown successfully edited."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:451
+#: redbot/cogs/customcom/customcom.py:492
+msgid "That command doesn't exist. Use `{command}` to add it."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:459
+#, docstring
+msgid "Delete a custom command.\n\n"
+"        Example:\n"
+"            - `[p]customcom delete yourcommand`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to delete.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:470
+msgid "Custom command successfully deleted."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:477
+#, docstring
+msgid "Edit a custom command.\n\n"
+"        Example:\n"
+"            - `[p]customcom edit yourcommand Text you want`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to edit.\n"
+"        - `<text>` The new text to return when executing the command.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:489
+msgid "Custom command successfully edited."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:504
+#, docstring
+msgid "List all available custom commands.\n\n"
+"        The list displays a preview of each command's response, with\n"
+"        markdown escaped and newlines replaced with spaces.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:513
+msgid "There are no custom commands in this server. Use `{command}` to start adding some."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:529
+msgid "Custom Command List"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:533
+msgid "Page {num}/{total}"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:543
+#, docstring
+msgid "Shows a custom command's responses and its settings.\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to show.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:553
+msgid "I could not not find that custom command."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:564
+msgid "Deleted User"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:570
+msgid "Random"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:570
+msgid "Normal"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:572
+msgid "Command: {command_name}\n"
+"Author: {author}\n"
+"Created: {created_at}\n"
+"Type: {type}\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:584
+msgid "Cooldowns:\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:586
+msgid "{num} seconds per {period}\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:589
+msgid "Responses:\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:687
+msgid "Too many arguments!"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:691
+msgid "Arguments must be sequential. Missing arguments: "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:717
+msgid "Conflicting colon notation for argument {index}: \"{name1}\" and \"{name2}\"."
+msgstr ""
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/customcom/locales/bs-BA.po

@@ -0,0 +1,296 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-02-11 12:29+0000\n"
+"Last-Translator: \n"
+"Language-Team: Bosnian\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: bs\n"
+"X-Crowdin-File-ID: 41\n"
+"Language: bs_BA\n"
+
+#: redbot/cogs/customcom/customcom.py:78
+msgid "Welcome to the interactive random {cc} maker!\n"
+"Every message you send will be added as one of the random responses to choose from once this {cc} is triggered. To exit this interactive menu, type `{quit}`"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:89
+msgid "Add a random response:"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:101
+msgid "Random responses must take the same arguments!"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:166
+msgid "Do you want to create a 'randomized' custom command? (y/n)"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:172
+#: redbot/cogs/customcom/customcom.py:183
+msgid "Response timed out, please try again later."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:177
+msgid "What response do you want?"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:217
+#, docstring
+msgid "This cog contains commands for creating and managing custom commands that display text.\n\n"
+"    These are useful for storing information members might need, like FAQ answers or invite links.\n"
+"    Custom commands can be used by anyone by default, so be careful with pings.\n"
+"    Commands can only be lowercase, and will not respond to any uppercase letters.\n"
+"    "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:247
+#, docstring
+msgid "Base command for Custom Commands management."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:252
+#, docstring
+msgid "Get the raw response of a custom command, to get the proper markdown.\n\n"
+"        This is helpful for copy and pasting.\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to get the raw response of."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:277
+msgid "Response #{num}/{total}"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:287
+msgid "Response #{num}/{total}:\n"
+"{raw}"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:298
+#, docstring
+msgid "\n"
+"        Searches through custom commands, according to the query.\n\n"
+"        Uses fuzzywuzzy searching to find close matches.\n\n"
+"        **Arguments:**\n\n"
+"        - `<query>` The query to search for. Can be multiple words.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:318
+msgid "No close matches were found."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:323
+msgid "Search results"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:328
+msgid "The following matches have been found:"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:333
+#, docstring
+msgid "Create custom commands.\n\n"
+"        If a type is not specified, a simple CC will be created.\n"
+"        CCs can be enhanced with arguments, see the guide\n"
+"        [here](https://docs.discord.red/en/stable/cog_customcom.html).\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:344
+#, docstring
+msgid "Create a CC where it will randomly choose a response!\n\n"
+"        Note: This command is interactive.\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The command executed to return the text. Cast to lowercase.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:354
+#: redbot/cogs/customcom/customcom.py:388
+msgid "Custom command names cannot have spaces in them."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:357
+#: redbot/cogs/customcom/customcom.py:391
+msgid "There already exists a bot command with the same name."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:361
+msgid "Custom command process cancelled."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:365
+#: redbot/cogs/customcom/customcom.py:395
+msgid "Custom command successfully added."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:368
+#: redbot/cogs/customcom/customcom.py:398
+msgid "This command already exists. Use `{command}` to edit it."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:376
+#, docstring
+msgid "Add a simple custom command.\n\n"
+"        Example:\n"
+"            - `[p]customcom create simple yourcommand Text you want`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The command executed to return the text. Cast to lowercase.\n"
+"        - `<text>` The text to return when executing the command. See guide for enhanced usage.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:410
+#, docstring
+msgid "Set, edit, or view the cooldown for a custom command.\n\n"
+"        You may set cooldowns per member, channel, or guild. Multiple\n"
+"        cooldowns may be set. All cooldowns must be cooled to call the\n"
+"        custom command.\n\n"
+"        Examples:\n"
+"            - `[p]customcom cooldown pingrole`\n"
+"            - `[p]customcom cooldown yourcommand 30`\n"
+"            - `[p]cc cooldown mycommand 30 guild`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to check or set the cooldown.\n"
+"        - `<cooldown>` The number of seconds to wait before allowing the command to be invoked again. If omitted, will instead return the current cooldown settings.\n"
+"        - `<per>` The group to apply the cooldown on. Defaults to per member. Valid choices are server, guild, user, and member.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:431
+#: redbot/cogs/customcom/customcom.py:472
+msgid "That command doesn't exist."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:436
+msgid "A {} may call this command every {} seconds"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:440
+msgid "This command has no cooldown."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:444
+msgid "{} must be one of {}"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:448
+msgid "Custom command cooldown successfully edited."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:451
+#: redbot/cogs/customcom/customcom.py:492
+msgid "That command doesn't exist. Use `{command}` to add it."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:459
+#, docstring
+msgid "Delete a custom command.\n\n"
+"        Example:\n"
+"            - `[p]customcom delete yourcommand`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to delete.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:470
+msgid "Custom command successfully deleted."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:477
+#, docstring
+msgid "Edit a custom command.\n\n"
+"        Example:\n"
+"            - `[p]customcom edit yourcommand Text you want`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to edit.\n"
+"        - `<text>` The new text to return when executing the command.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:489
+msgid "Custom command successfully edited."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:504
+#, docstring
+msgid "List all available custom commands.\n\n"
+"        The list displays a preview of each command's response, with\n"
+"        markdown escaped and newlines replaced with spaces.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:513
+msgid "There are no custom commands in this server. Use `{command}` to start adding some."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:529
+msgid "Custom Command List"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:533
+msgid "Page {num}/{total}"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:543
+#, docstring
+msgid "Shows a custom command's responses and its settings.\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to show.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:553
+msgid "I could not not find that custom command."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:564
+msgid "Deleted User"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:570
+msgid "Random"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:570
+msgid "Normal"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:572
+msgid "Command: {command_name}\n"
+"Author: {author}\n"
+"Created: {created_at}\n"
+"Type: {type}\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:584
+msgid "Cooldowns:\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:586
+msgid "{num} seconds per {period}\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:589
+msgid "Responses:\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:687
+msgid "Too many arguments!"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:691
+msgid "Arguments must be sequential. Missing arguments: "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:717
+msgid "Conflicting colon notation for argument {index}: \"{name1}\" and \"{name2}\"."
+msgstr ""
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/customcom/locales/ca-ES.po

@@ -0,0 +1,296 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-02-11 12:29+0000\n"
+"Last-Translator: \n"
+"Language-Team: Catalan\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: ca\n"
+"X-Crowdin-File-ID: 41\n"
+"Language: ca_ES\n"
+
+#: redbot/cogs/customcom/customcom.py:78
+msgid "Welcome to the interactive random {cc} maker!\n"
+"Every message you send will be added as one of the random responses to choose from once this {cc} is triggered. To exit this interactive menu, type `{quit}`"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:89
+msgid "Add a random response:"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:101
+msgid "Random responses must take the same arguments!"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:166
+msgid "Do you want to create a 'randomized' custom command? (y/n)"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:172
+#: redbot/cogs/customcom/customcom.py:183
+msgid "Response timed out, please try again later."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:177
+msgid "What response do you want?"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:217
+#, docstring
+msgid "This cog contains commands for creating and managing custom commands that display text.\n\n"
+"    These are useful for storing information members might need, like FAQ answers or invite links.\n"
+"    Custom commands can be used by anyone by default, so be careful with pings.\n"
+"    Commands can only be lowercase, and will not respond to any uppercase letters.\n"
+"    "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:247
+#, docstring
+msgid "Base command for Custom Commands management."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:252
+#, docstring
+msgid "Get the raw response of a custom command, to get the proper markdown.\n\n"
+"        This is helpful for copy and pasting.\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to get the raw response of."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:277
+msgid "Response #{num}/{total}"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:287
+msgid "Response #{num}/{total}:\n"
+"{raw}"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:298
+#, docstring
+msgid "\n"
+"        Searches through custom commands, according to the query.\n\n"
+"        Uses fuzzywuzzy searching to find close matches.\n\n"
+"        **Arguments:**\n\n"
+"        - `<query>` The query to search for. Can be multiple words.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:318
+msgid "No close matches were found."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:323
+msgid "Search results"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:328
+msgid "The following matches have been found:"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:333
+#, docstring
+msgid "Create custom commands.\n\n"
+"        If a type is not specified, a simple CC will be created.\n"
+"        CCs can be enhanced with arguments, see the guide\n"
+"        [here](https://docs.discord.red/en/stable/cog_customcom.html).\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:344
+#, docstring
+msgid "Create a CC where it will randomly choose a response!\n\n"
+"        Note: This command is interactive.\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The command executed to return the text. Cast to lowercase.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:354
+#: redbot/cogs/customcom/customcom.py:388
+msgid "Custom command names cannot have spaces in them."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:357
+#: redbot/cogs/customcom/customcom.py:391
+msgid "There already exists a bot command with the same name."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:361
+msgid "Custom command process cancelled."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:365
+#: redbot/cogs/customcom/customcom.py:395
+msgid "Custom command successfully added."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:368
+#: redbot/cogs/customcom/customcom.py:398
+msgid "This command already exists. Use `{command}` to edit it."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:376
+#, docstring
+msgid "Add a simple custom command.\n\n"
+"        Example:\n"
+"            - `[p]customcom create simple yourcommand Text you want`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The command executed to return the text. Cast to lowercase.\n"
+"        - `<text>` The text to return when executing the command. See guide for enhanced usage.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:410
+#, docstring
+msgid "Set, edit, or view the cooldown for a custom command.\n\n"
+"        You may set cooldowns per member, channel, or guild. Multiple\n"
+"        cooldowns may be set. All cooldowns must be cooled to call the\n"
+"        custom command.\n\n"
+"        Examples:\n"
+"            - `[p]customcom cooldown pingrole`\n"
+"            - `[p]customcom cooldown yourcommand 30`\n"
+"            - `[p]cc cooldown mycommand 30 guild`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to check or set the cooldown.\n"
+"        - `<cooldown>` The number of seconds to wait before allowing the command to be invoked again. If omitted, will instead return the current cooldown settings.\n"
+"        - `<per>` The group to apply the cooldown on. Defaults to per member. Valid choices are server, guild, user, and member.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:431
+#: redbot/cogs/customcom/customcom.py:472
+msgid "That command doesn't exist."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:436
+msgid "A {} may call this command every {} seconds"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:440
+msgid "This command has no cooldown."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:444
+msgid "{} must be one of {}"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:448
+msgid "Custom command cooldown successfully edited."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:451
+#: redbot/cogs/customcom/customcom.py:492
+msgid "That command doesn't exist. Use `{command}` to add it."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:459
+#, docstring
+msgid "Delete a custom command.\n\n"
+"        Example:\n"
+"            - `[p]customcom delete yourcommand`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to delete.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:470
+msgid "Custom command successfully deleted."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:477
+#, docstring
+msgid "Edit a custom command.\n\n"
+"        Example:\n"
+"            - `[p]customcom edit yourcommand Text you want`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to edit.\n"
+"        - `<text>` The new text to return when executing the command.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:489
+msgid "Custom command successfully edited."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:504
+#, docstring
+msgid "List all available custom commands.\n\n"
+"        The list displays a preview of each command's response, with\n"
+"        markdown escaped and newlines replaced with spaces.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:513
+msgid "There are no custom commands in this server. Use `{command}` to start adding some."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:529
+msgid "Custom Command List"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:533
+msgid "Page {num}/{total}"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:543
+#, docstring
+msgid "Shows a custom command's responses and its settings.\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to show.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:553
+msgid "I could not not find that custom command."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:564
+msgid "Deleted User"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:570
+msgid "Random"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:570
+msgid "Normal"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:572
+msgid "Command: {command_name}\n"
+"Author: {author}\n"
+"Created: {created_at}\n"
+"Type: {type}\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:584
+msgid "Cooldowns:\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:586
+msgid "{num} seconds per {period}\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:589
+msgid "Responses:\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:687
+msgid "Too many arguments!"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:691
+msgid "Arguments must be sequential. Missing arguments: "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:717
+msgid "Conflicting colon notation for argument {index}: \"{name1}\" and \"{name2}\"."
+msgstr ""
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/customcom/locales/cs-CZ.po

@@ -0,0 +1,297 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-02-11 12:29+0000\n"
+"Last-Translator: \n"
+"Language-Team: Czech\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=4; plural=(n==1) ? 0 : (n>=2 && n<=4) ? 1 : 3;\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: cs\n"
+"X-Crowdin-File-ID: 41\n"
+"Language: cs_CZ\n"
+
+#: redbot/cogs/customcom/customcom.py:78
+msgid "Welcome to the interactive random {cc} maker!\n"
+"Every message you send will be added as one of the random responses to choose from once this {cc} is triggered. To exit this interactive menu, type `{quit}`"
+msgstr "Vítejte v interaktivním náhodném {cc} tvůrci!\n"
+"Každá zpráva, kterou odešlete, bude přidána jako jedna z náhodných odpovědí pro výběr od okamžiku, kdy bude tato {cc} spuštěna. Chcete-li ukončit toto interaktivní menu, zadejte `{quit}`"
+
+#: redbot/cogs/customcom/customcom.py:89
+msgid "Add a random response:"
+msgstr "Přidat náhodnou odpověď:"
+
+#: redbot/cogs/customcom/customcom.py:101
+msgid "Random responses must take the same arguments!"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:166
+msgid "Do you want to create a 'randomized' custom command? (y/n)"
+msgstr "Chcete vytvořit 'náhodný' vlastní příkaz? (y/n)"
+
+#: redbot/cogs/customcom/customcom.py:172
+#: redbot/cogs/customcom/customcom.py:183
+msgid "Response timed out, please try again later."
+msgstr "Vypršel časový limit odpovědi, opakujte akci později."
+
+#: redbot/cogs/customcom/customcom.py:177
+msgid "What response do you want?"
+msgstr "Jakou odpověď chcete?"
+
+#: redbot/cogs/customcom/customcom.py:217
+#, docstring
+msgid "This cog contains commands for creating and managing custom commands that display text.\n\n"
+"    These are useful for storing information members might need, like FAQ answers or invite links.\n"
+"    Custom commands can be used by anyone by default, so be careful with pings.\n"
+"    Commands can only be lowercase, and will not respond to any uppercase letters.\n"
+"    "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:247
+#, docstring
+msgid "Base command for Custom Commands management."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:252
+#, docstring
+msgid "Get the raw response of a custom command, to get the proper markdown.\n\n"
+"        This is helpful for copy and pasting.\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to get the raw response of."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:277
+msgid "Response #{num}/{total}"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:287
+msgid "Response #{num}/{total}:\n"
+"{raw}"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:298
+#, docstring
+msgid "\n"
+"        Searches through custom commands, according to the query.\n\n"
+"        Uses fuzzywuzzy searching to find close matches.\n\n"
+"        **Arguments:**\n\n"
+"        - `<query>` The query to search for. Can be multiple words.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:318
+msgid "No close matches were found."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:323
+msgid "Search results"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:328
+msgid "The following matches have been found:"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:333
+#, docstring
+msgid "Create custom commands.\n\n"
+"        If a type is not specified, a simple CC will be created.\n"
+"        CCs can be enhanced with arguments, see the guide\n"
+"        [here](https://docs.discord.red/en/stable/cog_customcom.html).\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:344
+#, docstring
+msgid "Create a CC where it will randomly choose a response!\n\n"
+"        Note: This command is interactive.\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The command executed to return the text. Cast to lowercase.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:354
+#: redbot/cogs/customcom/customcom.py:388
+msgid "Custom command names cannot have spaces in them."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:357
+#: redbot/cogs/customcom/customcom.py:391
+msgid "There already exists a bot command with the same name."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:361
+msgid "Custom command process cancelled."
+msgstr "Vlastní příkaz byl zrušen."
+
+#: redbot/cogs/customcom/customcom.py:365
+#: redbot/cogs/customcom/customcom.py:395
+msgid "Custom command successfully added."
+msgstr "Vlastní příkaz byl úspěšně přidán."
+
+#: redbot/cogs/customcom/customcom.py:368
+#: redbot/cogs/customcom/customcom.py:398
+msgid "This command already exists. Use `{command}` to edit it."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:376
+#, docstring
+msgid "Add a simple custom command.\n\n"
+"        Example:\n"
+"            - `[p]customcom create simple yourcommand Text you want`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The command executed to return the text. Cast to lowercase.\n"
+"        - `<text>` The text to return when executing the command. See guide for enhanced usage.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:410
+#, docstring
+msgid "Set, edit, or view the cooldown for a custom command.\n\n"
+"        You may set cooldowns per member, channel, or guild. Multiple\n"
+"        cooldowns may be set. All cooldowns must be cooled to call the\n"
+"        custom command.\n\n"
+"        Examples:\n"
+"            - `[p]customcom cooldown pingrole`\n"
+"            - `[p]customcom cooldown yourcommand 30`\n"
+"            - `[p]cc cooldown mycommand 30 guild`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to check or set the cooldown.\n"
+"        - `<cooldown>` The number of seconds to wait before allowing the command to be invoked again. If omitted, will instead return the current cooldown settings.\n"
+"        - `<per>` The group to apply the cooldown on. Defaults to per member. Valid choices are server, guild, user, and member.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:431
+#: redbot/cogs/customcom/customcom.py:472
+msgid "That command doesn't exist."
+msgstr "Tento příkaz neexistuje."
+
+#: redbot/cogs/customcom/customcom.py:436
+msgid "A {} may call this command every {} seconds"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:440
+msgid "This command has no cooldown."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:444
+msgid "{} must be one of {}"
+msgstr "{} musí být jeden z {}"
+
+#: redbot/cogs/customcom/customcom.py:448
+msgid "Custom command cooldown successfully edited."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:451
+#: redbot/cogs/customcom/customcom.py:492
+msgid "That command doesn't exist. Use `{command}` to add it."
+msgstr "Tento příkaz neexistuje. Použijte `{command}` pro jeho přidání."
+
+#: redbot/cogs/customcom/customcom.py:459
+#, docstring
+msgid "Delete a custom command.\n\n"
+"        Example:\n"
+"            - `[p]customcom delete yourcommand`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to delete.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:470
+msgid "Custom command successfully deleted."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:477
+#, docstring
+msgid "Edit a custom command.\n\n"
+"        Example:\n"
+"            - `[p]customcom edit yourcommand Text you want`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to edit.\n"
+"        - `<text>` The new text to return when executing the command.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:489
+msgid "Custom command successfully edited."
+msgstr "Vlastní příkaz byl úspěšně upraven."
+
+#: redbot/cogs/customcom/customcom.py:504
+#, docstring
+msgid "List all available custom commands.\n\n"
+"        The list displays a preview of each command's response, with\n"
+"        markdown escaped and newlines replaced with spaces.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:513
+msgid "There are no custom commands in this server. Use `{command}` to start adding some."
+msgstr "Na tomto serveru nejsou žádné vlastní příkazy. Použij `{command}` pro začátek přidávání."
+
+#: redbot/cogs/customcom/customcom.py:529
+msgid "Custom Command List"
+msgstr "Seznam vlastních příkazů"
+
+#: redbot/cogs/customcom/customcom.py:533
+msgid "Page {num}/{total}"
+msgstr "Strana {num}/{total}"
+
+#: redbot/cogs/customcom/customcom.py:543
+#, docstring
+msgid "Shows a custom command's responses and its settings.\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to show.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:553
+msgid "I could not not find that custom command."
+msgstr "Nemohu najít tento vlastní příkaz."
+
+#: redbot/cogs/customcom/customcom.py:564
+msgid "Deleted User"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:570
+msgid "Random"
+msgstr "Náhodně"
+
+#: redbot/cogs/customcom/customcom.py:570
+msgid "Normal"
+msgstr "Normální"
+
+#: redbot/cogs/customcom/customcom.py:572
+msgid "Command: {command_name}\n"
+"Author: {author}\n"
+"Created: {created_at}\n"
+"Type: {type}\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:584
+msgid "Cooldowns:\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:586
+msgid "{num} seconds per {period}\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:589
+msgid "Responses:\n"
+msgstr "Odpovědi:\n"
+
+#: redbot/cogs/customcom/customcom.py:687
+msgid "Too many arguments!"
+msgstr "Příliš mnoho argumentů!"
+
+#: redbot/cogs/customcom/customcom.py:691
+msgid "Arguments must be sequential. Missing arguments: "
+msgstr "Argumenty musí být sekvenční. Chybějící argumenty: "
+
+#: redbot/cogs/customcom/customcom.py:717
+msgid "Conflicting colon notation for argument {index}: \"{name1}\" and \"{name2}\"."
+msgstr ""
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/customcom/locales/da-DK.po

@@ -0,0 +1,297 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-02-11 12:29+0000\n"
+"Last-Translator: \n"
+"Language-Team: Danish\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: da\n"
+"X-Crowdin-File-ID: 41\n"
+"Language: da_DK\n"
+
+#: redbot/cogs/customcom/customcom.py:78
+msgid "Welcome to the interactive random {cc} maker!\n"
+"Every message you send will be added as one of the random responses to choose from once this {cc} is triggered. To exit this interactive menu, type `{quit}`"
+msgstr "Velkommen til den interaktive tilfældigheds {cc} skaber!\n"
+"Hver besked som du sender vil blive tilføjet som et af de tilfældige svar at vælge imellem så snart {cc} er aktiveret. For at afslutte denne interaktive menu, skriv `{quit}`"
+
+#: redbot/cogs/customcom/customcom.py:89
+msgid "Add a random response:"
+msgstr "Tilføj et tilfældig svar:"
+
+#: redbot/cogs/customcom/customcom.py:101
+msgid "Random responses must take the same arguments!"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:166
+msgid "Do you want to create a 'randomized' custom command? (y/n)"
+msgstr "Vil du skabe en \"tilfældigt\" brugerdefineret kommando? (y/n)"
+
+#: redbot/cogs/customcom/customcom.py:172
+#: redbot/cogs/customcom/customcom.py:183
+msgid "Response timed out, please try again later."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:177
+msgid "What response do you want?"
+msgstr "Hvilket svar vil du have?"
+
+#: redbot/cogs/customcom/customcom.py:217
+#, docstring
+msgid "This cog contains commands for creating and managing custom commands that display text.\n\n"
+"    These are useful for storing information members might need, like FAQ answers or invite links.\n"
+"    Custom commands can be used by anyone by default, so be careful with pings.\n"
+"    Commands can only be lowercase, and will not respond to any uppercase letters.\n"
+"    "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:247
+#, docstring
+msgid "Base command for Custom Commands management."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:252
+#, docstring
+msgid "Get the raw response of a custom command, to get the proper markdown.\n\n"
+"        This is helpful for copy and pasting.\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to get the raw response of."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:277
+msgid "Response #{num}/{total}"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:287
+msgid "Response #{num}/{total}:\n"
+"{raw}"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:298
+#, docstring
+msgid "\n"
+"        Searches through custom commands, according to the query.\n\n"
+"        Uses fuzzywuzzy searching to find close matches.\n\n"
+"        **Arguments:**\n\n"
+"        - `<query>` The query to search for. Can be multiple words.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:318
+msgid "No close matches were found."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:323
+msgid "Search results"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:328
+msgid "The following matches have been found:"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:333
+#, docstring
+msgid "Create custom commands.\n\n"
+"        If a type is not specified, a simple CC will be created.\n"
+"        CCs can be enhanced with arguments, see the guide\n"
+"        [here](https://docs.discord.red/en/stable/cog_customcom.html).\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:344
+#, docstring
+msgid "Create a CC where it will randomly choose a response!\n\n"
+"        Note: This command is interactive.\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The command executed to return the text. Cast to lowercase.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:354
+#: redbot/cogs/customcom/customcom.py:388
+msgid "Custom command names cannot have spaces in them."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:357
+#: redbot/cogs/customcom/customcom.py:391
+msgid "There already exists a bot command with the same name."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:361
+msgid "Custom command process cancelled."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:365
+#: redbot/cogs/customcom/customcom.py:395
+msgid "Custom command successfully added."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:368
+#: redbot/cogs/customcom/customcom.py:398
+msgid "This command already exists. Use `{command}` to edit it."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:376
+#, docstring
+msgid "Add a simple custom command.\n\n"
+"        Example:\n"
+"            - `[p]customcom create simple yourcommand Text you want`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The command executed to return the text. Cast to lowercase.\n"
+"        - `<text>` The text to return when executing the command. See guide for enhanced usage.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:410
+#, docstring
+msgid "Set, edit, or view the cooldown for a custom command.\n\n"
+"        You may set cooldowns per member, channel, or guild. Multiple\n"
+"        cooldowns may be set. All cooldowns must be cooled to call the\n"
+"        custom command.\n\n"
+"        Examples:\n"
+"            - `[p]customcom cooldown pingrole`\n"
+"            - `[p]customcom cooldown yourcommand 30`\n"
+"            - `[p]cc cooldown mycommand 30 guild`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to check or set the cooldown.\n"
+"        - `<cooldown>` The number of seconds to wait before allowing the command to be invoked again. If omitted, will instead return the current cooldown settings.\n"
+"        - `<per>` The group to apply the cooldown on. Defaults to per member. Valid choices are server, guild, user, and member.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:431
+#: redbot/cogs/customcom/customcom.py:472
+msgid "That command doesn't exist."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:436
+msgid "A {} may call this command every {} seconds"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:440
+msgid "This command has no cooldown."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:444
+msgid "{} must be one of {}"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:448
+msgid "Custom command cooldown successfully edited."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:451
+#: redbot/cogs/customcom/customcom.py:492
+msgid "That command doesn't exist. Use `{command}` to add it."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:459
+#, docstring
+msgid "Delete a custom command.\n\n"
+"        Example:\n"
+"            - `[p]customcom delete yourcommand`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to delete.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:470
+msgid "Custom command successfully deleted."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:477
+#, docstring
+msgid "Edit a custom command.\n\n"
+"        Example:\n"
+"            - `[p]customcom edit yourcommand Text you want`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to edit.\n"
+"        - `<text>` The new text to return when executing the command.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:489
+msgid "Custom command successfully edited."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:504
+#, docstring
+msgid "List all available custom commands.\n\n"
+"        The list displays a preview of each command's response, with\n"
+"        markdown escaped and newlines replaced with spaces.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:513
+msgid "There are no custom commands in this server. Use `{command}` to start adding some."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:529
+msgid "Custom Command List"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:533
+msgid "Page {num}/{total}"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:543
+#, docstring
+msgid "Shows a custom command's responses and its settings.\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to show.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:553
+msgid "I could not not find that custom command."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:564
+msgid "Deleted User"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:570
+msgid "Random"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:570
+msgid "Normal"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:572
+msgid "Command: {command_name}\n"
+"Author: {author}\n"
+"Created: {created_at}\n"
+"Type: {type}\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:584
+msgid "Cooldowns:\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:586
+msgid "{num} seconds per {period}\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:589
+msgid "Responses:\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:687
+msgid "Too many arguments!"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:691
+msgid "Arguments must be sequential. Missing arguments: "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:717
+msgid "Conflicting colon notation for argument {index}: \"{name1}\" and \"{name2}\"."
+msgstr ""
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/customcom/locales/de-DE.po

@@ -0,0 +1,308 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-02-11 12:29+0000\n"
+"Last-Translator: \n"
+"Language-Team: German\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: de\n"
+"X-Crowdin-File-ID: 41\n"
+"Language: de_DE\n"
+
+#: redbot/cogs/customcom/customcom.py:78
+msgid "Welcome to the interactive random {cc} maker!\n"
+"Every message you send will be added as one of the random responses to choose from once this {cc} is triggered. To exit this interactive menu, type `{quit}`"
+msgstr "**Hier kannst du einen zufälligen „{cc}“ Befehl erstellen.**\n"
+"Jede von dir gesendete Nachricht wird als eine der zufälligen Antworten hinzugefügt, aus denen dann zufällig gewählt wird, sobald dieser „{cc}“ ausgeführt wird. Um dieses interaktive Menü zu beenden, schreibe: `{quit}`."
+
+#: redbot/cogs/customcom/customcom.py:89
+msgid "Add a random response:"
+msgstr "Füge eine zufällige Antwort hinzu:"
+
+#: redbot/cogs/customcom/customcom.py:101
+msgid "Random responses must take the same arguments!"
+msgstr "Zufällige Antworten müssen die gleichen Argumente aufweisen!"
+
+#: redbot/cogs/customcom/customcom.py:166
+msgid "Do you want to create a 'randomized' custom command? (y/n)"
+msgstr "Möchtest du einen 'zufälligen' benutzerdefinierten Befehl erstellen? (y/n)"
+
+#: redbot/cogs/customcom/customcom.py:172
+#: redbot/cogs/customcom/customcom.py:183
+msgid "Response timed out, please try again later."
+msgstr "Zeitüberschreitung bei der Antwort, versuche es später erneut."
+
+#: redbot/cogs/customcom/customcom.py:177
+msgid "What response do you want?"
+msgstr "Welche Reaktion willst du?"
+
+#: redbot/cogs/customcom/customcom.py:217
+#, docstring
+msgid "This cog contains commands for creating and managing custom commands that display text.\n\n"
+"    These are useful for storing information members might need, like FAQ answers or invite links.\n"
+"    Custom commands can be used by anyone by default, so be careful with pings.\n"
+"    Commands can only be lowercase, and will not respond to any uppercase letters.\n"
+"    "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:247
+#, docstring
+msgid "Base command for Custom Commands management."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:252
+#, docstring
+msgid "Get the raw response of a custom command, to get the proper markdown.\n\n"
+"        This is helpful for copy and pasting.\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to get the raw response of."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:277
+msgid "Response #{num}/{total}"
+msgstr "Antwort #{num}/{total}"
+
+#: redbot/cogs/customcom/customcom.py:287
+msgid "Response #{num}/{total}:\n"
+"{raw}"
+msgstr "Antwort #{num}/{total}:\n"
+"{raw}"
+
+#: redbot/cogs/customcom/customcom.py:298
+#, docstring
+msgid "\n"
+"        Searches through custom commands, according to the query.\n\n"
+"        Uses fuzzywuzzy searching to find close matches.\n\n"
+"        **Arguments:**\n\n"
+"        - `<query>` The query to search for. Can be multiple words.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:318
+msgid "No close matches were found."
+msgstr "Keine Ergebnisse gefunden."
+
+#: redbot/cogs/customcom/customcom.py:323
+msgid "Search results"
+msgstr "Suchergebnisse"
+
+#: redbot/cogs/customcom/customcom.py:328
+msgid "The following matches have been found:"
+msgstr "Folgendes wurde gefunden:"
+
+#: redbot/cogs/customcom/customcom.py:333
+#, docstring
+msgid "Create custom commands.\n\n"
+"        If a type is not specified, a simple CC will be created.\n"
+"        CCs can be enhanced with arguments, see the guide\n"
+"        [here](https://docs.discord.red/en/stable/cog_customcom.html).\n"
+"        "
+msgstr "Erstelle einen benutzerdefinierten Befehl.\n\n"
+"       Wenn keine Art für den benutzerdefinierten Befehl spezifiziert wurde, wird ein einfacher benutzerdefinierter Befehl erstellt.\n"
+"        Benutzerdefinierte Befehle können auch mit Argumenten erweitert werden. Siehe diese Anleitung:\n"
+"        [Dokumentation](https://docs.discord.red/en/stable/cog_customcom.html).\n"
+"        "
+
+#: redbot/cogs/customcom/customcom.py:344
+#, docstring
+msgid "Create a CC where it will randomly choose a response!\n\n"
+"        Note: This command is interactive.\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The command executed to return the text. Cast to lowercase.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:354
+#: redbot/cogs/customcom/customcom.py:388
+msgid "Custom command names cannot have spaces in them."
+msgstr "Benutzerdefinierte Befehle dürfen keine Leerzeichen enthalten."
+
+#: redbot/cogs/customcom/customcom.py:357
+#: redbot/cogs/customcom/customcom.py:391
+msgid "There already exists a bot command with the same name."
+msgstr "Es existiert bereits ein Befehl des Bots mit diesem Namen."
+
+#: redbot/cogs/customcom/customcom.py:361
+msgid "Custom command process cancelled."
+msgstr "Der Vorgang, zum Erstellen eines benutzedefinierten Befehls, wurde abgebrochen."
+
+#: redbot/cogs/customcom/customcom.py:365
+#: redbot/cogs/customcom/customcom.py:395
+msgid "Custom command successfully added."
+msgstr "Benutzerdefinierter Befehl erfolgreich hinzugefügt."
+
+#: redbot/cogs/customcom/customcom.py:368
+#: redbot/cogs/customcom/customcom.py:398
+msgid "This command already exists. Use `{command}` to edit it."
+msgstr "Dieser Befehl ist bereits vorhanden. Verwende `{command}` um ihn zu editieren."
+
+#: redbot/cogs/customcom/customcom.py:376
+#, docstring
+msgid "Add a simple custom command.\n\n"
+"        Example:\n"
+"            - `[p]customcom create simple yourcommand Text you want`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The command executed to return the text. Cast to lowercase.\n"
+"        - `<text>` The text to return when executing the command. See guide for enhanced usage.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:410
+#, docstring
+msgid "Set, edit, or view the cooldown for a custom command.\n\n"
+"        You may set cooldowns per member, channel, or guild. Multiple\n"
+"        cooldowns may be set. All cooldowns must be cooled to call the\n"
+"        custom command.\n\n"
+"        Examples:\n"
+"            - `[p]customcom cooldown pingrole`\n"
+"            - `[p]customcom cooldown yourcommand 30`\n"
+"            - `[p]cc cooldown mycommand 30 guild`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to check or set the cooldown.\n"
+"        - `<cooldown>` The number of seconds to wait before allowing the command to be invoked again. If omitted, will instead return the current cooldown settings.\n"
+"        - `<per>` The group to apply the cooldown on. Defaults to per member. Valid choices are server, guild, user, and member.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:431
+#: redbot/cogs/customcom/customcom.py:472
+msgid "That command doesn't exist."
+msgstr "Dieser Befehl existiert nicht."
+
+#: redbot/cogs/customcom/customcom.py:436
+msgid "A {} may call this command every {} seconds"
+msgstr "Ein {} darf diesen Befehl alle {} Sekunden aufrufen"
+
+#: redbot/cogs/customcom/customcom.py:440
+msgid "This command has no cooldown."
+msgstr "Dieser Befehl hat keine Abklingzeit."
+
+#: redbot/cogs/customcom/customcom.py:444
+msgid "{} must be one of {}"
+msgstr "{} muss einer von {} sein"
+
+#: redbot/cogs/customcom/customcom.py:448
+msgid "Custom command cooldown successfully edited."
+msgstr "Abklingzeit des benutzerdefinierten Befehls erfolgreich bearbeitet."
+
+#: redbot/cogs/customcom/customcom.py:451
+#: redbot/cogs/customcom/customcom.py:492
+msgid "That command doesn't exist. Use `{command}` to add it."
+msgstr "Dieser Befehl existiert nicht. Verwende `{command}`, um ihn hinzuzufügen."
+
+#: redbot/cogs/customcom/customcom.py:459
+#, docstring
+msgid "Delete a custom command.\n\n"
+"        Example:\n"
+"            - `[p]customcom delete yourcommand`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to delete.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:470
+msgid "Custom command successfully deleted."
+msgstr "Benutzerdefinierter Befehl erfolgreich gelöscht."
+
+#: redbot/cogs/customcom/customcom.py:477
+#, docstring
+msgid "Edit a custom command.\n\n"
+"        Example:\n"
+"            - `[p]customcom edit yourcommand Text you want`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to edit.\n"
+"        - `<text>` The new text to return when executing the command.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:489
+msgid "Custom command successfully edited."
+msgstr "Benutzerdefinierter Befehl erfolgreich bearbeitet."
+
+#: redbot/cogs/customcom/customcom.py:504
+#, docstring
+msgid "List all available custom commands.\n\n"
+"        The list displays a preview of each command's response, with\n"
+"        markdown escaped and newlines replaced with spaces.\n"
+"        "
+msgstr "Listet alle verfügbaren benutzerdefinierten Befehle auf.\n\n"
+"        Die Liste zeigt eine Vorschau der einzelnen Befehlsantworten,\n"
+"        mit escaped Markdown und Zeilenumbrüche durch Leerzeichen ersetzt.\n"
+"        "
+
+#: redbot/cogs/customcom/customcom.py:513
+msgid "There are no custom commands in this server. Use `{command}` to start adding some."
+msgstr "Es existieren keine benutzerdefinierten Befehle auf diesem Server. Verwende `{command}`, um welche hinzuzufügen."
+
+#: redbot/cogs/customcom/customcom.py:529
+msgid "Custom Command List"
+msgstr "Liste der benutzerdefinierten Befehle"
+
+#: redbot/cogs/customcom/customcom.py:533
+msgid "Page {num}/{total}"
+msgstr "Seite {num}/{total}"
+
+#: redbot/cogs/customcom/customcom.py:543
+#, docstring
+msgid "Shows a custom command's responses and its settings.\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to show.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:553
+msgid "I could not not find that custom command."
+msgstr "Ich konnte diesen benutzerdefinierten Befehl nicht finden."
+
+#: redbot/cogs/customcom/customcom.py:564
+msgid "Deleted User"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:570
+msgid "Random"
+msgstr "Zufall"
+
+#: redbot/cogs/customcom/customcom.py:570
+msgid "Normal"
+msgstr "Normal"
+
+#: redbot/cogs/customcom/customcom.py:572
+msgid "Command: {command_name}\n"
+"Author: {author}\n"
+"Created: {created_at}\n"
+"Type: {type}\n"
+msgstr "Befehl: {command_name}\n"
+"Autor: {author}\n"
+"Erstellt: {created_at}\n"
+"Typ: {type}\n"
+
+#: redbot/cogs/customcom/customcom.py:584
+msgid "Cooldowns:\n"
+msgstr "Cooldown:\n"
+
+#: redbot/cogs/customcom/customcom.py:586
+msgid "{num} seconds per {period}\n"
+msgstr "{num} Sekunden pro {period}\n"
+
+#: redbot/cogs/customcom/customcom.py:589
+msgid "Responses:\n"
+msgstr "Antworten:\n"
+
+#: redbot/cogs/customcom/customcom.py:687
+msgid "Too many arguments!"
+msgstr "Zu viele Argumente!"
+
+#: redbot/cogs/customcom/customcom.py:691
+msgid "Arguments must be sequential. Missing arguments: "
+msgstr "Argumente müssen sequentiell sein. Fehlende Argumente: "
+
+#: redbot/cogs/customcom/customcom.py:717
+msgid "Conflicting colon notation for argument {index}: \"{name1}\" and \"{name2}\"."
+msgstr "Widersprüchliche Doppelpunkt Schreibweise für Argument {index}: \"{name1}\" und \"{name2}\"."
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/customcom/locales/el-GR.po

@@ -0,0 +1,296 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2021-02-11 12:29+0000\n"
+"Last-Translator: \n"
+"Language-Team: Greek\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.3\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Project-ID: 289505\n"
+"X-Crowdin-Language: el\n"
+"X-Crowdin-File-ID: 41\n"
+"Language: el_GR\n"
+
+#: redbot/cogs/customcom/customcom.py:78
+msgid "Welcome to the interactive random {cc} maker!\n"
+"Every message you send will be added as one of the random responses to choose from once this {cc} is triggered. To exit this interactive menu, type `{quit}`"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:89
+msgid "Add a random response:"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:101
+msgid "Random responses must take the same arguments!"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:166
+msgid "Do you want to create a 'randomized' custom command? (y/n)"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:172
+#: redbot/cogs/customcom/customcom.py:183
+msgid "Response timed out, please try again later."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:177
+msgid "What response do you want?"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:217
+#, docstring
+msgid "This cog contains commands for creating and managing custom commands that display text.\n\n"
+"    These are useful for storing information members might need, like FAQ answers or invite links.\n"
+"    Custom commands can be used by anyone by default, so be careful with pings.\n"
+"    Commands can only be lowercase, and will not respond to any uppercase letters.\n"
+"    "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:247
+#, docstring
+msgid "Base command for Custom Commands management."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:252
+#, docstring
+msgid "Get the raw response of a custom command, to get the proper markdown.\n\n"
+"        This is helpful for copy and pasting.\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to get the raw response of."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:277
+msgid "Response #{num}/{total}"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:287
+msgid "Response #{num}/{total}:\n"
+"{raw}"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:298
+#, docstring
+msgid "\n"
+"        Searches through custom commands, according to the query.\n\n"
+"        Uses fuzzywuzzy searching to find close matches.\n\n"
+"        **Arguments:**\n\n"
+"        - `<query>` The query to search for. Can be multiple words.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:318
+msgid "No close matches were found."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:323
+msgid "Search results"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:328
+msgid "The following matches have been found:"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:333
+#, docstring
+msgid "Create custom commands.\n\n"
+"        If a type is not specified, a simple CC will be created.\n"
+"        CCs can be enhanced with arguments, see the guide\n"
+"        [here](https://docs.discord.red/en/stable/cog_customcom.html).\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:344
+#, docstring
+msgid "Create a CC where it will randomly choose a response!\n\n"
+"        Note: This command is interactive.\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The command executed to return the text. Cast to lowercase.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:354
+#: redbot/cogs/customcom/customcom.py:388
+msgid "Custom command names cannot have spaces in them."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:357
+#: redbot/cogs/customcom/customcom.py:391
+msgid "There already exists a bot command with the same name."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:361
+msgid "Custom command process cancelled."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:365
+#: redbot/cogs/customcom/customcom.py:395
+msgid "Custom command successfully added."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:368
+#: redbot/cogs/customcom/customcom.py:398
+msgid "This command already exists. Use `{command}` to edit it."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:376
+#, docstring
+msgid "Add a simple custom command.\n\n"
+"        Example:\n"
+"            - `[p]customcom create simple yourcommand Text you want`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The command executed to return the text. Cast to lowercase.\n"
+"        - `<text>` The text to return when executing the command. See guide for enhanced usage.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:410
+#, docstring
+msgid "Set, edit, or view the cooldown for a custom command.\n\n"
+"        You may set cooldowns per member, channel, or guild. Multiple\n"
+"        cooldowns may be set. All cooldowns must be cooled to call the\n"
+"        custom command.\n\n"
+"        Examples:\n"
+"            - `[p]customcom cooldown pingrole`\n"
+"            - `[p]customcom cooldown yourcommand 30`\n"
+"            - `[p]cc cooldown mycommand 30 guild`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to check or set the cooldown.\n"
+"        - `<cooldown>` The number of seconds to wait before allowing the command to be invoked again. If omitted, will instead return the current cooldown settings.\n"
+"        - `<per>` The group to apply the cooldown on. Defaults to per member. Valid choices are server, guild, user, and member.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:431
+#: redbot/cogs/customcom/customcom.py:472
+msgid "That command doesn't exist."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:436
+msgid "A {} may call this command every {} seconds"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:440
+msgid "This command has no cooldown."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:444
+msgid "{} must be one of {}"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:448
+msgid "Custom command cooldown successfully edited."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:451
+#: redbot/cogs/customcom/customcom.py:492
+msgid "That command doesn't exist. Use `{command}` to add it."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:459
+#, docstring
+msgid "Delete a custom command.\n\n"
+"        Example:\n"
+"            - `[p]customcom delete yourcommand`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to delete.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:470
+msgid "Custom command successfully deleted."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:477
+#, docstring
+msgid "Edit a custom command.\n\n"
+"        Example:\n"
+"            - `[p]customcom edit yourcommand Text you want`\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to edit.\n"
+"        - `<text>` The new text to return when executing the command.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:489
+msgid "Custom command successfully edited."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:504
+#, docstring
+msgid "List all available custom commands.\n\n"
+"        The list displays a preview of each command's response, with\n"
+"        markdown escaped and newlines replaced with spaces.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:513
+msgid "There are no custom commands in this server. Use `{command}` to start adding some."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:529
+msgid "Custom Command List"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:533
+msgid "Page {num}/{total}"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:543
+#, docstring
+msgid "Shows a custom command's responses and its settings.\n\n"
+"        **Arguments:**\n\n"
+"        - `<command>` The custom command to show.\n"
+"        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:553
+msgid "I could not not find that custom command."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:564
+msgid "Deleted User"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:570
+msgid "Random"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:570
+msgid "Normal"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:572
+msgid "Command: {command_name}\n"
+"Author: {author}\n"
+"Created: {created_at}\n"
+"Type: {type}\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:584
+msgid "Cooldowns:\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:586
+msgid "{num} seconds per {period}\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:589
+msgid "Responses:\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:687
+msgid "Too many arguments!"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:691
+msgid "Arguments must be sequential. Missing arguments: "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:717
+msgid "Conflicting colon notation for argument {index}: \"{name1}\" and \"{name2}\"."
+msgstr ""
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/customcom/locales/en-PT.po

@@ -0,0 +1,193 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2019-07-05 22:33+0200\n"
+"PO-Revision-Date: 2019-07-14 02:15\n"
+"Last-Translator: Robert Jansen (Kowlin)\n"
+"Language-Team: Pirate English\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.0\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"X-Generator: crowdin.com\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Language: en-PT\n"
+"X-Crowdin-File: /cogs/customcom/locales/messages.pot\n"
+"Language: en_PT\n"
+
+#: redbot/cogs/customcom/customcom.py:51
+msgid "Welcome to the interactive random {cc} maker!\\nEvery message you send will be added as one of the random responses to choose from once this {cc} is triggered. To exit this interactive menu, type `{quit}`"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:62
+msgid "Add a random response:"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:74
+msgid "Random responses must take the same arguments!"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:139
+msgid "Do you want to create a 'randomized' custom command? (y/n)"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:145
+#: redbot/cogs/customcom/customcom.py:156
+msgid "Response timed out, please try again later."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:150
+msgid "What response do you want?"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:190
+#, docstring
+msgid "Creates commands used to display text."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:204
+#, docstring
+msgid "Custom commands management."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:210
+#, docstring
+msgid "Create custom commands.\\n\\n        CCs can be enhanced with arguments, see the guide\\n        [here](https://red-discordbot.readthedocs.io/en/v3-develop/cog_customcom.html).\\n        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:220
+#, docstring
+msgid "Create a CC where it will randomly choose a response!\\n\\n        Note: This command is interactive.\\n        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:227
+#: redbot/cogs/customcom/customcom.py:248
+msgid "Custom command successfully added."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:230
+#: redbot/cogs/customcom/customcom.py:251
+msgid "This command already exists. Use `{command}` to edit it."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:238
+#, docstring
+msgid "Add a simple custom command.\\n\\n        Example:\\n        - `[p]customcom create simple yourcommand Text you want`\\n        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:244
+msgid "There already exists a bot command with the same name."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:263
+#, docstring
+msgid "Set, edit, or view the cooldown for a custom command.\\n\\n        You may set cooldowns per member, channel, or guild. Multiple\\n        cooldowns may be set. All cooldowns must be cooled to call the\\n        custom command.\\n\\n        Example:\\n        - `[p]customcom cooldown yourcommand 30`\\n        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:276
+#: redbot/cogs/customcom/customcom.py:313
+msgid "That command doesn't exist."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:281
+msgid "A {} may call this command every {} seconds"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:285
+msgid "This command has no cooldown."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:289
+msgid "{} must be one of {}"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:293
+msgid "Custom command cooldown successfully edited."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:296
+#: redbot/cogs/customcom/customcom.py:328
+msgid "That command doesn't exist. Use `{command}` to add it."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:304
+#, docstring
+msgid "Delete a custom command.\\n\\n        Example:\\n        - `[p]customcom delete yourcommand`\\n        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:311
+msgid "Custom command successfully deleted."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:318
+#, docstring
+msgid "Edit a custom command.\\n\\n        Example:\\n        - `[p]customcom edit yourcommand Text you want`\\n        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:325
+msgid "Custom command successfully edited."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:338
+#, docstring
+msgid "List all available custom commands.\\n\\n        The list displays a preview of each command's response, with\\n        markdown escaped and newlines replaced with spaces.\\n        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:347
+msgid "There are no custom commands in this server. Use `{command}` to start adding some."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:379
+msgid "Custom Command List"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:383
+msgid "Page {num}/{total}"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:393
+#, docstring
+msgid "Shows a custom command's reponses and its settings."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:398
+msgid "I could not not find that custom command."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:413
+msgid "Random"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:413
+msgid "Normal"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:415
+msgid "Command: {command_name}\\nAuthor: {author}\\nCreated: {created_at}\\nType: {type}\\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:427
+msgid "Cooldowns:\\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:429
+msgid "{num} seconds per {period}\\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:432
+msgid "Responses:\\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:525
+msgid "Too many arguments!"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:529
+msgid "Arguments must be sequential. Missing arguments: "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:555
+msgid "Conflicting colon notation for argument {index}: \\\"{name1}\\\" and \\\"{name2}\\\"."
+msgstr ""
+

testbed/Cog-Creators__Red-DiscordBot/redbot/cogs/customcom/locales/en-US.po

@@ -0,0 +1,192 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: red-discordbot\n"
+"POT-Creation-Date: 2019-07-16 01:34+0000\n"
+"PO-Revision-Date: 2020-01-07 21:49\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: English\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: redgettext 3.1\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"X-Crowdin-Project: red-discordbot\n"
+"X-Crowdin-Language: en\n"
+"X-Crowdin-File: /customcom/locales/messages.pot\n"
+"Language: en_US\n"
+
+#: redbot/cogs/customcom/customcom.py:51
+msgid "Welcome to the interactive random {cc} maker!\\nEvery message you send will be added as one of the random responses to choose from once this {cc} is triggered. To exit this interactive menu, type `{quit}`"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:62
+msgid "Add a random response:"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:74
+msgid "Random responses must take the same arguments!"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:139
+msgid "Do you want to create a 'randomized' custom command? (y/n)"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:145
+#: redbot/cogs/customcom/customcom.py:156
+msgid "Response timed out, please try again later."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:150
+msgid "What response do you want?"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:190
+#, docstring
+msgid "Creates commands used to display text."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:204
+#, docstring
+msgid "Custom commands management."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:210
+#, docstring
+msgid "Create custom commands.\\n\\n        CCs can be enhanced with arguments, see the guide\\n        [here](https://red-discordbot.readthedocs.io/en/v3-develop/cog_customcom.html).\\n        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:220
+#, docstring
+msgid "Create a CC where it will randomly choose a response!\\n\\n        Note: This command is interactive.\\n        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:227
+#: redbot/cogs/customcom/customcom.py:248
+msgid "Custom command successfully added."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:230
+#: redbot/cogs/customcom/customcom.py:251
+msgid "This command already exists. Use `{command}` to edit it."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:238
+#, docstring
+msgid "Add a simple custom command.\\n\\n        Example:\\n        - `[p]customcom create simple yourcommand Text you want`\\n        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:244
+msgid "There already exists a bot command with the same name."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:263
+#, docstring
+msgid "Set, edit, or view the cooldown for a custom command.\\n\\n        You may set cooldowns per member, channel, or guild. Multiple\\n        cooldowns may be set. All cooldowns must be cooled to call the\\n        custom command.\\n\\n        Example:\\n        - `[p]customcom cooldown yourcommand 30`\\n        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:276
+#: redbot/cogs/customcom/customcom.py:313
+msgid "That command doesn't exist."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:281
+msgid "A {} may call this command every {} seconds"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:285
+msgid "This command has no cooldown."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:289
+msgid "{} must be one of {}"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:293
+msgid "Custom command cooldown successfully edited."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:296
+#: redbot/cogs/customcom/customcom.py:328
+msgid "That command doesn't exist. Use `{command}` to add it."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:304
+#, docstring
+msgid "Delete a custom command.\\n\\n        Example:\\n        - `[p]customcom delete yourcommand`\\n        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:311
+msgid "Custom command successfully deleted."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:318
+#, docstring
+msgid "Edit a custom command.\\n\\n        Example:\\n        - `[p]customcom edit yourcommand Text you want`\\n        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:325
+msgid "Custom command successfully edited."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:338
+#, docstring
+msgid "List all available custom commands.\\n\\n        The list displays a preview of each command's response, with\\n        markdown escaped and newlines replaced with spaces.\\n        "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:347
+msgid "There are no custom commands in this server. Use `{command}` to start adding some."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:379
+msgid "Custom Command List"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:383
+msgid "Page {num}/{total}"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:393
+#, docstring
+msgid "Shows a custom command's reponses and its settings."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:398
+msgid "I could not not find that custom command."
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:413
+msgid "Random"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:413
+msgid "Normal"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:415
+msgid "Command: {command_name}\\nAuthor: {author}\\nCreated: {created_at}\\nType: {type}\\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:427
+msgid "Cooldowns:\\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:429
+msgid "{num} seconds per {period}\\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:432
+msgid "Responses:\\n"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:526
+msgid "Too many arguments!"
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:530
+msgid "Arguments must be sequential. Missing arguments: "
+msgstr ""
+
+#: redbot/cogs/customcom/customcom.py:556
+msgid "Conflicting colon notation for argument {index}: \\\"{name1}\\\" and \\\"{name2}\\\"."
+msgstr ""
+