Merge pull request #391 from gobo7793/development

release

Author: Fluggs

Geckarbot.py

@@ -32,7 +32,7 @@ class Geckarbot(BaseBot):
     Basic bot info
     """
     NAME = "Geckarbot"
-    VERSION = "2.18.1"
+    VERSION = "2.19.0"
     PLUGIN_DIR = "plugins"
     CORE_PLUGIN_DIR = "coreplugins"
     CONFIG_DIR = "config"

base/data.py

@@ -335,6 +335,7 @@ class Lang(metaclass=_Singleton):
         "unmute": "🔊",
         "startup": "🔨",
         "debug": "🐞",
+        "notfound": "🙈",
         "lettermap": [
             "🇦",  # a
             "🇧",  # b

botutils/sheetsclient.py

@@ -1,6 +1,7 @@
 import logging
 import os
 import re
+import string
 import urllib.parse
 from typing import Optional, Dict, Tuple, Union, List
 
@@ -22,142 +23,199 @@ class Cell:
     """
     Representation of a sheet cell
     """
-    def __init__(self, column: int, row: int, grid=None):
+
+    MAX_COLUMNS = 18_278
+    MAX_ROWS = 200_000_000
+
+    def __init__(self, column: int, row: int, grid: 'CellRange' = None):
         """
         Representation of a single cell. Note: rows and columns in a grid begin at 1!
 
         :param column: column coordinate
         :param row: row coordinate
         :param grid: CellRange the cell coordinates are dependent on
-        :type grid: CellRange
         """
 
         self.column = column
         self.row = row
         self.grid = grid
 
     @classmethod
-    def from_a1(cls, a1_notation: str):
+    def from_a1(cls, a1_notation: str, maximize_if_undefined: bool = False) -> 'Cell':
         """
         Building the cell from the A1-notation.
 
         :param a1_notation: A1-notation of the cell e.g. "A4" or "BE34"
-        :rtype: Cell
+        :param maximize_if_undefined: if the notation does not define for row or column, the value will be set to
+            maximum row/column instead of the first.
         :return: Cell
         :raises ValueError: if invalid notation
         """
-        extract = re.search("(?P<col>[A-Z]+)(?P<row>\\d+)", a1_notation)
-        if extract:
-            groupdict = extract.groupdict()
-            # Converts the column title into the corresponding column number
-            column = sum((x*y for x, y in zip([26**i for i in range(len(groupdict['col']))][::-1],
-                                              (ord(b) - 64 for b in groupdict['col']))))
-            return cls(column, int(groupdict['row']))
-        raise ValueError
+        extract = re.search("(?P<col>[a-zA-Z]*)(?P<row>\\d*)", a1_notation)
+        if not extract:
+            raise ValueError
+        groupdict = extract.groupdict()
+        column = groupdict['col']
+        row = groupdict['row']
+        if not column:
+            column = Cell.MAX_COLUMNS if maximize_if_undefined else 1
+        if not row:
+            row = Cell.MAX_ROWS if maximize_if_undefined else 1
+        return cls(column if isinstance(column, int) else Cell.get_column_number(column), int(row))
 
     def cellname(self) -> str:
         """Returns cell in A1-notation"""
-        chars = []
-        num = self.column
-        if self.grid:
-            num += self.grid.column - 1
-        while num > 0:
-            num, d = divmod(num, 26)
-            if d == 0:
-                num, d = num - 1, 26
-            chars.append(chr(64 + d))
+        col_num = self.column
         row_num = self.row
         if self.grid:
-            row_num += self.grid.row - 1
-        return ''.join(reversed(chars)) + str(row_num)
+            col_num += self.grid.start_column - 1
+            row_num += self.grid.start_row - 1
+        return self.get_column_name(col_num) + str(row_num)
 
-    def translate(self, columns: int, rows: int):
+    def translate(self, columns: int, rows: int) -> 'Cell':
         """
         Returns cell translated by the given number of columns and rows
 
         :param columns: number of columns the cell should be moved
         :param rows: number of rows the rows the cell should be moved
-        :rtype: Cell
         :return: resulting cell
         """
         return Cell(column=self.column + columns,
                     row=self.row + rows,
                     grid=self.grid)
 
+    @staticmethod
+    def get_column_number(col: str) -> int:
+        """
+        Returns the column number
+
+        :param col: cell or column name
+        :return: column number
+        :raises ValueError: if non-ascii-letters are included
+        """
+        num = 0
+        for letter in col.upper():
+            num *= 26
+            num += string.ascii_uppercase.index(letter) + 1
+        return num
+
+    @staticmethod
+    def get_column_name(num: int) -> str:
+        """
+        Converts number n into the name of the n'th column
+
+        :param num: n'th Column
+        :return: Column name
+        """
+        name = ""
+        while num > 0:
+            num, digit = divmod(num - 1, 26)
+            name = chr(digit + 65) + name
+        return name
+
 
 class CellRange:
     """
-    Represents a range of cells
+    Representation of a range of cells. Note: rows and columns in a grid begin at 1!
+
+    :param start_cell: top-left Cell
+    :param width: number of columns
+    :param height: number of rows
     """
     def __init__(self, start_cell: Cell, width: int, height: int):
-        """
-        Representation of a range of cells. Note: rows and columns in a grid begin at 1!
-
-        :param start_cell: top-left Cell
-        :param width: number of columns
-        :param height: number of rows
-        """
-        self.column = start_cell.column
-        self.row = start_cell.row
+        self.start_column = start_cell.column
+        self.start_row = start_cell.row
         self.width = width
         self.height = height
 
+    @property
+    def end_column(self):
+        return self.start_column + self.width - 1
+
+    @property
+    def end_row(self):
+        return self.start_row + self.height - 1
+
     @classmethod
-    def from_a1(cls, a1_notation: str):
+    def from_a1(cls, a1_notation: str) -> 'CellRange':
         """
         Builds a CellRange object from "A1:B4" notation
 
         :param a1_notation: notation string
-        :rtype: CellRange
         :return: Corresponding CellRange object
         :raises ValueError: if invalid notation
         """
-        extract = re.search("(?P<cell1>[A-Z]+\\d+):(?P<cell2>[A-Z]+\\d+)", a1_notation)
+        extract = re.search("(?P<cell1>[a-zA-Z]*[a-zA-Z\\d]\\d*):(?P<cell2>[a-zA-Z]*[a-zA-Z\\d]\\d*)", a1_notation)
         if extract:
             groupdict = extract.groupdict()
-            return cls.from_cells(Cell.from_a1(groupdict['cell1']), Cell.from_a1(groupdict['cell2']))
+            return cls.from_cells(Cell.from_a1(groupdict['cell1']), Cell.from_a1(groupdict['cell2'],
+                                                                                 maximize_if_undefined=True))
         raise ValueError
 
     @classmethod
-    def from_cells(cls, start_cell: Cell, end_cell: Cell):
+    def from_cells(cls, start_cell: Cell, end_cell: Cell) -> 'CellRange':
         """
         Builds a CellRange object by passing two corners of the range rectangle.
 
         :param start_cell: top left
         :param end_cell: bottom right
-        :rtype: CellRange
         :return: Corresponding CellRange object
         """
         width = end_cell.column - start_cell.column + 1
         height = end_cell.row - start_cell.row + 1
         return cls(start_cell, width, height)
 
+    @classmethod
+    def columns(cls, start: int, end: int = None):
+        """CellRange of complete columns"""
+        return cls(Cell(start, 1), end - start + 1 if end else 1, Cell.MAX_ROWS)
+
+    @classmethod
+    def rows(cls, start: int, end: int = None):
+        """CellRange of complete rows"""
+        return cls(Cell(1, start), Cell.MAX_COLUMNS, end - start + 1 if end else 1)
+
+    def overlay_range(self, other: 'CellRange') -> Optional['CellRange']:
+        """
+        Returns the overlaying range with the other CellRange
+
+        :param other: other CellRange
+        :return: CellRange of overlay area if existing, otherwise None
+        """
+        start_column = max(self.start_column, other.start_column)
+        start_row = max(self.start_row, other.start_row)
+        end_column = min(self.end_column, other.end_column)
+        end_row = min(self.end_row, other.end_row)
+        if start_column > end_column or start_row > end_row:
+            return None
+        return CellRange.from_cells(Cell(start_column, start_row), Cell(end_column, end_row))
+
     def rangename(self) -> str:
         """Returns cell range in A1-notation"""
-        return "{}:{}".format(Cell(self.column, self.row).cellname(),
-                              Cell(self.column + self.width - 1, self.row + self.height - 1).cellname())
+        return "{}:{}".format(Cell(self.start_column, self.start_row).cellname(),
+                              Cell(self.end_column, self.end_row).cellname())
 
-    def translate(self, columns: int, rows: int):
+    def translate(self, columns: int, rows: int) -> 'CellRange':
         """
         Returns cell range translated by the given number of columns and rows
 
         :param columns: number of columns the range should be moved
         :param rows: number of rows the rows the range should be moved
-        :rtype: CellRange
         :return: resulting cell range
         """
-        return CellRange(start_cell=Cell(column=self.column + columns,
-                                         row=self.row + rows),
+        return CellRange(start_cell=Cell(column=self.start_column + columns,
+                                         row=self.start_row + rows),
                          width=self.width,
                          height=self.height)
 
     def expand(self, top: int = 0, bottom: int = 0, left: int = 0, right: int = 0):
         """
         Returns cell range expanded by the given amount in each direction
         """
-        if self.column <= left or self.row <= top or left + right <= -self.width or top + bottom <= -self.height:
+        if self.start_column <= left or self.start_row <= top or left + right <= -self.width \
+                or top + bottom <= -self.height:
             raise ValueError
-        return CellRange(start_cell=Cell(column=self.column - left, row=self.row - top),
+        return CellRange(start_cell=Cell(column=self.start_column - left, row=self.start_row - top),
                          width=self.width + left + right,
                          height=self.height + top + bottom)
 
@@ -558,10 +616,10 @@ def find_and_replace(self, find: str, replace: str, match_case: bool = True, mat
                 else:
                     request['range'] = {
                         "sheetId": sheet_id,
-                        "startRowIndex": cell_range.row,
-                        "endRowIndex": cell_range.row + cell_range.height,
-                        "startColumnIndex": cell_range.column,
-                        "endColumnIndex": cell_range.column + cell_range.width
+                        "startRowIndex": cell_range.start_row,
+                        "endRowIndex": cell_range.end_row,
+                        "startColumnIndex": cell_range.start_column,
+                        "endColumnIndex": cell_range.end_column
                     }
             else:
                 return None

botutils/uiutils.py

@@ -22,7 +22,7 @@ class CoroButton(ui.Button):
     :param data: Opaque object
     """
     def __init__(self,
-                 coro: Callable[[ui.Button, Interaction], Coroutine],
+                 coro: Callable[['CoroButton', Interaction], Coroutine],
                  *,
                  style=ButtonStyle.secondary, label=None, disabled=False, custom_id=None, emoji=None, row=None,
                  data: Any = None):
@@ -187,7 +187,7 @@ class SingleConfirmView(MultiItemView):
            then there is no timeout.
     """
     def __init__(self,
-                 confirm_coro: Optional[Callable[[ui.Button, Interaction], Coroutine]] = None,
+                 confirm_coro: Optional[Callable[[CoroButton, Interaction], Coroutine]] = None,
                  *,
                  confirm_label: str = "Confirm",
                  abort_label: str = "X",
@@ -203,7 +203,7 @@ def __init__(self,
         self.confirm_coro = confirm_coro
         self.user_id = user_id
 
-    async def confirm(self, button: ui.Button, interaction: Interaction):
+    async def confirm(self, button: CoroButton, interaction: Interaction):
         """
         Action to perform when confirm button is pressed
 

botutils/utils.py

@@ -1,4 +1,4 @@
-from typing import Union, Optional, Coroutine, Any, Callable
+from typing import Union, Optional, Coroutine, Any, Callable, List
 import datetime
 import random
 import inspect
@@ -49,8 +49,34 @@ def paginate_embed(embed: Embed):
         else:
             embed.description = f"{embed.description[0:2046]} …"
     if len(embed) > 6000:
-        raise Exception(f"Embed is still to long! Title: {embed.title}")
-
+        raise Exception(f"Embed is still too long! Title: {embed.title}")
+
+def paginate_embeds(embeds: List[Embed]) -> List[List[Embed]]:
+    """
+    Paginate a list of embeds.
+
+    :param embeds: List of embeds to paginate
+    :return: Paginated list of lists of embeds
+    :raises Exception: If a single embed is too long
+    """
+    embeds = embeds[:]
+    paginated: List[List[Embed]] = []
+    while embeds:
+        embed_page: List[Embed] = []
+        len_sum = 0
+        while embeds:
+            embed = embeds.pop(0)
+            if len(embed) > 6000:
+                raise Exception(f"Embed is too long! Title: {embed.title}")
+            len_sum += len(embed)
+            if len_sum > 6000:
+                embeds.insert(0, embed)
+                break
+            embed_page.append(embed)
+            if len(embed_page) >= 10:
+                break
+        paginated.append(embed_page)
+    return paginated
 
 async def _write_to_channel(channel_id: int = 0, message: Union[str, Embed] = None,
                             channel_type: str = ""):

lang/customcmd.json

@@ -78,6 +78,10 @@
         "help_cmd_aliasclear": "Removes all aliases from a user command",
         "usage_cmd_aliasclear": "<cmd name>",
         "desc_cmd_aliasclear": "Removes all aliases from a user command.",
+        "help_cmd_random": "Random cmd text",
+        "desc_cmd_random": "Sends a random text entry from all created text commands.",
+        "help_cmd_image": "Random cmd image",
+        "desc_cmd_image": "Sends a random link from all created text commands.",
 
         "Embed Help": "",
         "help_cmd_embed": "Creates and manages custom embed commands",
@@ -161,7 +165,7 @@
         "desc_cmd_list": "Listet alle Benutzer-Kommandos. Wenn [full] angegeben ist, werden mehr Informationen zu den Kommandos ausgegeben.",
         "help_cmd_info": "Gibt alle Infos zu einem Benutzer-Kommando aus",
         "usage_cmd_info": "<command> [# | #+ | #++]",
-        "desc_cmd_info": "Gibt alle Infos zu einem Benutzer-Kommando aus, inklusive den Ausgabetexten und ihre Ersteller.\n\nOptionen:\n  # - Gibt den Ausgabetext mit der Nummer # aus.\n  #+ - Gibt den Ausgabetext mit der Nummer # sowie alle folgenden, die in eine Nachricht passen, aus.\n  #++ - Gibt alle Ausgabetexte mit der Nummer # sowie alle folgenden aus.",
+        "desc_cmd_info": "Gibt alle Infos zu einem Benutzer-Kommando aus, inklusive den Ausgabetexten und ihre Ersteller.\n\nOptionen:\n  # - Gibt den Ausgabetext mit der Nummer # aus.\n  #+ - Gibt den Ausgabetext mit der Nummer # sowie alle folgenden, die in eine Nachricht passen, aus.\n  #++ - Gibt alle Ausgabetexte mit der Nummer # sowie alle folgenden aus.\n  last - Gibt den letzten Ausgabetext aus.\n  all - Gibt alle Ausgabetexte aus.",
         "help_cmd_search": "Sucht in den Ausgabetexten eines Benutzer-Kommandos",
         "usage_cmd_search": "<Kommandoname> <Suchbegriffe>",
         "desc_cmd_search": "Findet alle Ausgabetexte im Kommando, die jeweils alle Suchbegriffe enthalten.\nDie Suche unterscheidet nicht zwischen Groß- und Kleinschreibung.",
@@ -178,9 +182,13 @@
         "help_cmd_aliasclear": "Entfernt alle Alias von einem Benutzer-Kommando.",
         "usage_cmd_aliasclear": "<Kommando>",
         "desc_cmd_aliasclear": "Entfernt alle Alias von einem Benutzer-Komando.",
+        "help_cmd_random": "Zufälliges Kommando",
+        "desc_cmd_random": "Sendet einen zufälligen Text aus allen Text-Kommandos.",
+        "help_cmd_image": "Zufälliges Bild",
+        "desc_cmd_image": "Sendet einen zufälligen Link aus allen Text-Kommandos.",
 
         "Embed Help": "",
-        "help_cmd_embed": "Creates and manages custom embed commands",
+        "help_cmd_embed": "Verwaltet Embed-Kommandos",
         "desc_cmd_embed": "Verwaltet Embed-Kommandos.\nEmbeds bestehen aus beliebig vielen Feldern und einem optionalen Header. Felder wiederum bestehen aus einem Titel und dem Inhalt. Um ein Embed-Kommando zu erstellen:\n(1) Erstelle das initiale Embed-Kommando\n(2) Optional: Setze den Header\n(3) Setze Titel und Inhalt des ersten Felds\n(4) Füge weitere Felder hinzu und setze ihre Titel und Inhalte",
         "usage_cmd_embed": "",
         "help_cmd_embed_add": "Fügt ein neues Embed-Cmd oder Feld hinzu",