Introduce cachetools

Bibo-Joshi · Bibo-Joshi · commit c17a8bede01a · 2021-01-23T18:03:54.000+01:00
diff --git a/requirements.txt b/requirements.txt
@@ -4,3 +4,4 @@ cryptography
 decorator>=4.4.0
 APScheduler==3.6.3
 pytz>=2018.6
+cachetools==4.2.0
diff --git a/telegram/ext/bot.py b/telegram/ext/bot.py
@@ -49,17 +49,11 @@ class Bot(telegram.bot.Bot):
     Args:
         defaults (:class:`telegram.ext.Defaults`, optional): An object containing default values to
             be used if not set explicitly in the bot methods.
-        arbitrary_callback_data (:obj:`bool` | :obj:`int` | :obj:`None`, optional): Whether to
+        arbitrary_callback_data (:obj:`bool` | :obj:`int`, optional): Whether to
             allow arbitrary objects as callback data for :class:`telegram.InlineKeyboardButton`.
-            Pass an integer to specify the maximum number objects cached in memory. Pass 0 or
-            :obj:`None` for unlimited cache size. Cache limit defaults to 1024. For more info,
+            Pass an integer to specify the maximum number objects cached in memory. For more info,
             please see our wiki. Defaults to :obj:`False`.
 
-            Warning:
-                Not limiting :attr:`maxsize` may cause memory issues for long running bots. If you
-                don't limit the size, you should be sure that every inline button is actually
-                pressed or that you manually clear the cache.
-
     """
 
     def __init__(
@@ -71,7 +65,7 @@ def __init__(
         private_key: bytes = None,
         private_key_password: bytes = None,
         defaults: Defaults = None,
-        arbitrary_callback_data: Union[bool, int, None] = False,
+        arbitrary_callback_data: Union[bool, int] = False,
     ):
         super().__init__(
             token=token,
@@ -84,8 +78,8 @@ def __init__(
         )
 
         # set up callback_data
-        if not isinstance(arbitrary_callback_data, bool) or arbitrary_callback_data is None:
-            maxsize = cast(Union[int, None], arbitrary_callback_data)
+        if not isinstance(arbitrary_callback_data, bool):
+            maxsize = cast(int, arbitrary_callback_data)
             self.arbitrary_callback_data = True
         else:
             maxsize = 1024
@@ -145,26 +139,8 @@ def get_updates(
         )
 
         for update in updates:
-            if not update.callback_query:
-                continue
-
-            callback_query = update.callback_query
-            # Get the cached callback data for the CallbackQuery
-            if callback_query.data:
-                callback_query.data = self.callback_data.get_button_data(  # type: ignore
-                    callback_query.data, update=True
-                )
-            # Get the cached callback data for the inline keyboard attached to the
-            # CallbackQuery
-            if callback_query.message and callback_query.message.reply_markup:
-                for row in callback_query.message.reply_markup.inline_keyboard:
-                    for button in row:
-                        if button.callback_data:
-                            button.callback_data = self.callback_data.get_button_data(
-                                # No need to update again, this was already done above
-                                button.callback_data,
-                                update=False,
-                            )
+            if update.callback_query:
+                self.callback_data.process_callback_query(update.callback_query)
 
         return updates
 
diff --git a/telegram/ext/callbackcontext.py b/telegram/ext/callbackcontext.py
@@ -21,9 +21,8 @@
 from queue import Queue
 from typing import TYPE_CHECKING, Any, Dict, List, Match, NoReturn, Optional, Tuple, Union
 
-from telegram import Update
+from telegram import Update, CallbackQuery
 from telegram.ext import Bot as ExtBot
-from telegram.ext.utils.callbackdatacache import CallbackDataCache
 
 if TYPE_CHECKING:
     from telegram import Bot
@@ -144,16 +143,31 @@ def user_data(self, value: Any) -> NoReturn:
             "You can not assign a new value to user_data, see " "https://git.io/fjxKe"
         )
 
-    @property
-    def callback_data_cache(self) -> Optional[CallbackDataCache]:
+    def drop_callback_data(self, callback_query: CallbackQuery) -> None:
         """
-        :class:`telegram.utils.callbackdatacache.CallbackDataCache`: Optional. Cache for the bots
-            callback data. Only present when the bot uses allows to use arbitrary callback data.
-            Useful for manually dropping unused objects from the cache.
+        Deletes the cached data for the specified callback query.
+
+        Note:
+            Will *not* raise exceptions in case the data is not found in the cache.
+            *Will* raise :class:`KeyError` in case the callback query can not be found in the
+            cache.
+
+        Args:
+            callback_query (:class:`telegram.CallbackQuery`): The callback query.
+
+        Raises:
+            KeyError | RuntimeError: :class:`KeyError`, if the callback query can not be found in
+                the cache and :class:`RuntimeError`, if the bot doesn't allow for arbitrary
+                callback data.
         """
         if isinstance(self.bot, ExtBot):
-            return self.bot.callback_data if self.bot.arbitrary_callback_data else None
-        return None
+            if not self.bot.arbitrary_callback_data:
+                RuntimeError(
+                    'This telegram.ext.Bot instance does not use arbitrary callback data.'
+                )
+            self.bot.callback_data.drop_data(callback_query)
+        else:
+            raise RuntimeError('telegram.Bot does not allow for arbitrary callback data.')
 
     @classmethod
     def from_error(
diff --git a/telegram/ext/dispatcher.py b/telegram/ext/dispatcher.py
@@ -199,13 +199,12 @@ def __init__(
                     raise ValueError("bot_data must be of type dict")
             if self.persistence.store_callback_data:
                 self.bot = cast(telegram.ext.bot.Bot, self.bot)
-                callback_data = self.persistence.get_callback_data()
-                if callback_data is not None:
-                    if not isinstance(callback_data, tuple) and len(callback_data) != 2:
+                persistent_data = self.persistence.get_callback_data()
+                if persistent_data is not None:
+                    if not isinstance(persistent_data, tuple) and len(persistent_data) != 2:
                         raise ValueError('callback_data must be a 2-tuple')
-                    button_data, lru_list = callback_data
                     self.bot.callback_data = CallbackDataCache(
-                        self.bot.callback_data.maxsize, button_data=button_data, lru_list=lru_list
+                        self.bot.callback_data.maxsize, persistent_data=persistent_data
                     )
         else:
             self.persistence = None
diff --git a/telegram/ext/updater.py b/telegram/ext/updater.py
@@ -87,14 +87,8 @@ class Updater:
             be used if not set explicitly in the bot methods.
         arbitrary_callback_data (:obj:`bool` | :obj:`int` | :obj:`None`, optional): Whether to
             allow arbitrary objects as callback data for :class:`telegram.InlineKeyboardButton`.
-            Pass an integer to specify the maximum number of cached objects. Pass 0 or :obj:`None`
-            for unlimited cache size. Cache limit defaults to 1024. For more info, please see
-            our wiki. Defaults to :obj:`False`.
-
-            Warning:
-                Not limiting :attr:`maxsize` may cause memory issues for long running bots. If you
-                don't limit the size, you should be sure that every inline button is actually
-                pressed or that you manually clear the cache using e.g. :meth:`clear`.
+            Pass an integer to specify the maximum number of cached objects. For more info, please
+            see our wiki. Defaults to :obj:`False`.
 
     Raises:
         ValueError: If both :attr:`token` and :attr:`bot` are passed or none of them.
diff --git a/telegram/ext/utils/callbackdatacache.py b/telegram/ext/utils/callbackdatacache.py
diff --git a/telegram/ext/utils/types.py b/telegram/ext/utils/types.py
