Refactor for PTB v20.0a2 (#92)

Co-authored-by: Hinrich Mahler <[email protected]>
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Author: Bibo-Joshi

.github/workflows/pre-commit_dependencies_notifier.yml

@@ -3,7 +3,6 @@ on:
   pull_request_target:
     paths:
       - requirements.txt
-      - requirements-dev.txt
       - .pre-commit-config.yaml
 permissions:
  pull-requests: write
@@ -15,5 +14,5 @@ jobs:
       - name: running the check
         uses: Poolitzer/notifier-action@master
         with:
-          notify-message: Hey! Looks like you edited the (dev) requirements or the pre-commit hooks. I'm just a friendly reminder to keep the pre-commit hook versions in sync with the dev requirements and the additional dependencies for the hooks in sync with the requirements :)
+          notify-message: Hey! Looks like you edited the requirements or the pre-commit hooks. I'm just a friendly reminder to keep the additional dependencies for the hooks in sync with the requirements :)
           repo-token: ${{ secrets.GITHUB_TOKEN }}

.pre-commit-config.yaml

@@ -8,43 +8,53 @@ ci:
 
 repos:
 -   repo: https://github.com/psf/black
-    rev: 22.3.0
+    rev: 22.6.0
     hooks:
     -   id: black
         args:
         - --diff
         - --check
--   repo: https://gitlab.com/pycqa/flake8
+-   repo: https://github.com/PyCQA/flake8
     rev: 4.0.1
     hooks:
     -   id: flake8
 -   repo: https://github.com/PyCQA/pylint
-    rev: v2.14.3
+    rev: v2.14.4
     hooks:
     -   id: pylint
         args:
           - --rcfile=setup.cfg
         additional_dependencies:
-          - beautifulsoup4
-          - thefuzz==0.19.0
-          - python-telegram-bot==13.9
-          - Sphinx
-          - requests
-          - github3.py==2.0.0
+          - beautifulsoup4~=4.11.0
+          - thefuzz~=0.19.0
+          - python-telegram-bot==20.0a2
+          - Sphinx~=5.0.2
+          - httpx~=0.23.0
+          - gql~=3.3.0
+          - async-lru~=1.0.3
 -   repo: https://github.com/pre-commit/mirrors-mypy
     rev: v0.961
     hooks:
     -   id: mypy
         additional_dependencies:
-          - beautifulsoup4
-          - thefuzz==0.19.0
-          - python-telegram-bot==13.9
-          - Sphinx
-          - requests
-          - github3.py==2.0.0
+          - beautifulsoup4~=4.11.0
+          - thefuzz~=0.19.0
+          - python-telegram-bot==20.0a2
+          - Sphinx~=5.0.2
+          - httpx~=0.23.0
+          - gql~=3.3.0
+          - async-lru~=1.0.3
 -   repo: https://github.com/asottile/pyupgrade
     rev: v2.34.0
     hooks:
     -   id: pyupgrade
         args:
           - --py36-plus
+-   repo: https://github.com/pycqa/isort
+    rev: 5.10.1
+    hooks:
+    -   id: isort
+        name: isort
+        args:
+        - --diff
+        - --check

bot.ini

@@ -1,2 +1,3 @@
 [KEYS]
 bot_api = 123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11
+github_auth = 123456

components/callbacks.py

@@ -12,21 +12,19 @@
 # Welcome new chat members at most ever X minutes
 NEW_CHAT_MEMBERS_LIMIT_SPACING = 60
 USER_AGENT = "Github: python-telegram-bot/rules-bot"
+DEFAULT_HEADERS = {"User-Agent": USER_AGENT}
 ENCLOSING_REPLACEMENT_CHARACTER = "+"
 _ERC = ENCLOSING_REPLACEMENT_CHARACTER
 ENCLOSED_REGEX = re.compile(rf"\{_ERC}([^{_ERC}]*)\{_ERC}")
 OFFTOPIC_USERNAME = "pythontelegrambottalk"
 ONTOPIC_USERNAME = "pythontelegrambotgroup"
+DEV_GROUP_USERNAME = "pythontelegrambotdev"
 OFFTOPIC_CHAT_ID = "@" + OFFTOPIC_USERNAME
 ONTOPIC_CHAT_ID = "@" + ONTOPIC_USERNAME
 ERROR_CHANNEL_CHAT_ID = -1001397960657
 TELEGRAM_SUPERSCRIPT = "ᵀᴱᴸᴱᴳᴿᴬᴹ"
 FAQ_CHANNEL_ID = "@ptbfaq"
 SELF_BOT_NAME = "roolsbot"
-ONTOPIC_RULES_MESSAGE_ID = 419903
-ONTOPIC_RULES_MESSAGE_LINK = f"https://t.me/{ONTOPIC_USERNAME}/419903"
-OFFTOPIC_RULES_MESSAGE_ID = 161133
-OFFTOPIC_RULES_MESSAGE_LINK = f"https://t.me/{OFFTOPIC_USERNAME}/161133"
 PTBCONTRIB_LINK = "https://github.com/python-telegram-bot/ptbcontrib/"
 DOCS_URL = "https://docs.python-telegram-bot.org/"
 OFFICIAL_URL = "https://core.telegram.org/bots/api"
@@ -36,8 +34,13 @@
 WIKI_FAQ_URL = urljoin(WIKI_URL, "Frequently-Asked-Questions")
 WIKI_FRDP_URL = urljoin(WIKI_URL, "Frequently-requested-design-patterns")
 EXAMPLES_URL = urljoin(PROJECT_URL, "tree/master/examples/")
-ONTOPIC_RULES = f"""
-This group is for questions, answers and discussions around the \
+ALLOWED_USERNAMES = (OFFTOPIC_USERNAME, ONTOPIC_USERNAME, DEV_GROUP_USERNAME)
+ALLOWED_CHAT_IDS = (
+    ERROR_CHANNEL_CHAT_ID,
+    -1001494805131,  # dev chat
+    -1001101839433,  # Church
+)
+ONTOPIC_RULES = f"""This group is for questions, answers and discussions around the \
 <a href="https://python-telegram-bot.org/">python-telegram-bot library</a> and, to some extent, \
 Telegram bots in general.
 
@@ -59,13 +62,13 @@
 Before asking, please take a look at our <a href="{WIKI_URL}">wiki</a> and \
 <a href="{EXAMPLES_URL}">example bots</a> or, depending on your question, the \
 <a href="{OFFICIAL_URL}">official API docs</a> and <a href="{DOCS_URL}">\
-python-telegram-bot docs</a>).
+python-telegram-bot docs</a>). Please also make sure to read the <a href="{WIKI_URL}Ask-Right">\
+wiki page on how to ask good questions</a>.
 For off-topic discussions, please use our <a href="https://t.me/{OFFTOPIC_USERNAME}">\
 off-topic group</a>.
 """
 
-OFFTOPIC_RULES = f"""
-<b>Topics:</b>
+OFFTOPIC_RULES = f"""<b>Topics:</b>
 - Discussions about Python in general
 - Meta discussions about <code>python-telegram-bot</code>
 - Friendly, respectful talking about non-tech topics

components/const.py

@@ -1,19 +1,17 @@
 import re
 from abc import ABC, abstractmethod
-from typing import List, Optional
+from dataclasses import dataclass
+from typing import ClassVar, List, Optional
 
-from github3.repos.commit import RepoCommit as GHCommit
-from github3.repos import Repository as GHRepo
-from github3.issues import Issue as GHIssue
-from thefuzz import fuzz
 from telegram import InlineKeyboardMarkup
+from thefuzz import fuzz
 
 from components.const import (
     ARROW_CHARACTER,
-    TELEGRAM_SUPERSCRIPT,
-    DEFAULT_REPO_OWNER,
     DEFAULT_REPO_NAME,
+    DEFAULT_REPO_OWNER,
     DOCS_URL,
+    TELEGRAM_SUPERSCRIPT,
 )
 
 
@@ -382,46 +380,30 @@ def compare_to_query(self, search_query: str) -> float:
         return score / 4
 
 
+@dataclass
 class Commit(BaseEntry):
     """A commit on Github
 
     Args:
-        commit: The github3 commit object
-        repository: The github3 repository object
+        owner: str
+        repo: str
+        sha: str
+        url: str
+        title: str
+        author: str
     """
 
-    def __init__(self, commit: GHCommit, repository: GHRepo) -> None:
-        self._commit = commit
-        self._repository = repository
-
-    @property
-    def owner(self) -> str:
-        return self._repository.owner.login
-
-    @property
-    def repo(self) -> str:
-        return self._repository.name
-
-    @property
-    def sha(self) -> str:
-        return self._commit.sha
+    owner: str
+    repo: str
+    sha: str
+    url: str
+    title: str
+    author: str
 
     @property
     def short_sha(self) -> str:
         return self.sha[:7]
 
-    @property
-    def url(self) -> str:
-        return self._commit.html_url
-
-    @property
-    def title(self) -> str:
-        return self._commit.commit["message"]
-
-    @property
-    def author(self) -> str:
-        return self._commit.author["login"]
-
     @property
     def short_name(self) -> str:
         return (
@@ -454,45 +436,15 @@ def compare_to_query(self, search_query: str) -> float:
         return 0
 
 
-class Issue(BaseEntry):
-    """An issue/PR on Github
-
-    Args:
-        issue: The github3 issue object
-        repository: The github3 repository object
-    """
-
-    def __init__(self, issue: GHIssue, repository: GHRepo) -> None:
-        self._issue = issue
-        self._repository = repository
-
-    @property
-    def type(self) -> str:
-        return "Issue" if not self._issue.pull_request_urls else "PR"
-
-    @property
-    def owner(self) -> str:
-        return self._repository.owner.login
-
-    @property
-    def repo(self) -> str:
-        return self._repository.name
-
-    @property
-    def number(self) -> int:
-        return self._issue.number
-
-    @property
-    def url(self) -> str:
-        return self._issue.html_url
-
-    @property
-    def title(self) -> str:
-        return self._issue.title
-
-    @property
-    def author(self) -> str:
-        return self._issue.user.login
+@dataclass
+class _IssueOrPullRequestOrDiscussion(BaseEntry):
+    _TYPE: ClassVar = ""  # pylint:disable=invalid-name
+    owner: str
+    repo: str
+    number: int
+    title: str
+    url: str
+    author: Optional[str]
 
     @property
     def short_name(self) -> str:
@@ -504,7 +456,9 @@ def short_name(self) -> str:
 
     @property
     def display_name(self) -> str:
-        return f"{self.type} {self.short_name}: {self.title} by {self.author}"
+        if self.author:
+            return f"{self._TYPE} {self.short_name}: {self.title} by {self.author}"
+        return f"{self._TYPE} {self.short_name}: {self.title}"
 
     @property
     def description(self) -> str:
@@ -515,12 +469,13 @@ def short_description(self) -> str:
         # Needs to be here because of cyclical imports
         from .util import truncate_str  # pylint:disable=import-outside-toplevel
 
-        string = f"{self.type} {self.short_name}: {self.title}"
+        string = f"{self._TYPE} {self.short_name}: {self.title}"
         return truncate_str(string, 25)
 
-    def html_markup(self, search_query: str = None) -> str:
+    def html_markup(self, search_query: str = None) -> str:  # pylint:disable=unused-argument
         return f'<a href="{self.url}">{self.display_name}</a>'
 
+    # pylint:disable=unused-argument
     def html_insertion_markup(self, search_query: str = None) -> str:
         return f'<a href="{self.url}">{self.short_name}</a>'
 
@@ -534,6 +489,51 @@ def compare_to_query(self, search_query: str) -> float:
         return fuzz.token_set_ratio(self.title, search_query)
 
 
+@dataclass
+class Issue(_IssueOrPullRequestOrDiscussion):
+    """An issue on GitHub
+
+    Args:
+        number: the number
+        repo: the repo name
+        owner: the owner name
+        url: the url of the issue
+        title: title of the issue
+    """
+
+    _TYPE: ClassVar = "Issue"
+
+
+@dataclass
+class PullRequest(_IssueOrPullRequestOrDiscussion):
+    """An pullRequest on GitHub
+
+    Args:
+        number: the number
+        repo: the repo name
+        owner: the owner name
+        url: the url of the pull request
+        title: title of the pull request
+    """
+
+    _TYPE: ClassVar = "PullRequest"
+
+
+@dataclass
+class Discussion(_IssueOrPullRequestOrDiscussion):
+    """A Discussion on GitHub
+
+    Args:
+        number: the number
+        repo: the repo name
+        owner: the owner name
+        url: the url of the pull request
+        title: title of the pull request
+    """
+
+    _TYPE: ClassVar = "Discussion"
+
+
 class PTBContrib(BaseEntry):
     """A contribution of ptbcontrib
 
@@ -577,6 +577,7 @@ class TagHint(BaseEntry):
         description: Description of the tag hint.
         default_query: Optional. Inserted into the ``message`` if no other query is provided.
         inline_keyboard: Optional. In InlineKeyboardMarkup to attach to the hint.
+        group_command: Optional. Whether this tag hint should be listed as command in the groups.
     """
 
     def __init__(
@@ -586,12 +587,14 @@ def __init__(
         description: str,
         default_query: str = None,
         inline_keyboard: InlineKeyboardMarkup = None,
+        group_command: bool = False,
     ):
         self.tag = tag
         self._message = message
         self._default_query = default_query
         self._description = description
         self._inline_keyboard = inline_keyboard
+        self.group_command = group_command
 
     @property
     def display_name(self) -> str:

components/entrytypes.py

@@ -13,7 +13,7 @@
 logger = logging.getLogger(__name__)
 
 
-def error_handler(update: object, context: CallbackContext) -> None:
+async def error_handler(update: object, context: CallbackContext) -> None:
     """Log the error and send a telegram message to notify the developer."""
     # Log the error before we do anything else, so we can see it even if something breaks.
     logger.error(msg="Exception while handling an update:", exc_info=context.error)
@@ -37,14 +37,16 @@ def error_handler(update: object, context: CallbackContext) -> None:
     # Finally, send the messages
     # We send update and traceback in two parts to reduce the chance of hitting max length
     try:
-        sent_message = context.bot.send_message(chat_id=ERROR_CHANNEL_CHAT_ID, text=message_1)
-        sent_message.reply_html(message_2)
+        sent_message = await context.bot.send_message(
+            chat_id=ERROR_CHANNEL_CHAT_ID, text=message_1
+        )
+        await sent_message.reply_html(message_2)
     except BadRequest as exc:
         if "too long" in str(exc):
             message = (
                 f"Hey.\nThe error <code>{html.escape(str(context.error))}</code> happened."
                 f" The traceback is too long to send, but it was written to the log."
             )
-            context.bot.send_message(chat_id=ERROR_CHANNEL_CHAT_ID, text=message)
+            await context.bot.send_message(chat_id=ERROR_CHANNEL_CHAT_ID, text=message)
         else:
             raise exc

components/errorhandler.py

@@ -1,233 +1,129 @@
+import asyncio
 import logging
-import re
-import threading
-import time
-from typing import (
-    Dict,
-    Union,
-    Optional,
-    no_type_check,
-    List,
-    Pattern,
-    Tuple,
-    Any,
-    cast,
-    Iterable,
-)
-
-from github3.repos.contents import Contents
-from github3 import login, GitHub
-from github3.exceptions import GitHubException
-from github3.repos import Repository as GHRepo
-from github3.structs import GitHubIterator
-from telegram.ext import JobQueue
-
-from components.const import (
-    DEFAULT_REPO_OWNER,
-    DEFAULT_REPO_NAME,
-    PTBCONTRIB_REPO_NAME,
-    EXAMPLES_URL,
-)
-from components.entrytypes import Issue, PTBContrib, Commit
-
-
-class RepoDict(Dict[str, GHRepo]):
-    def __init__(self, owner: str, session: GitHub):
-        super().__init__()
-        self._owner = owner
-        self._session = session
-
-    def __missing__(self, key: str) -> GHRepo:
-        if key not in self:
-            self[key] = self._session.repository(self._owner, key)
-        return self[key]
-
-    def update_session(self, session: GitHub) -> None:
-        self._session = session
-
-
-class GitHubIssues:
-    def __init__(
-        self, default_owner: str = DEFAULT_REPO_OWNER, default_repo: str = DEFAULT_REPO_NAME
-    ) -> None:
-        self.session = GitHub()
-        self.default_owner = default_owner
-        self.default_repo = default_repo
-
-        self.logger = logging.getLogger(self.__class__.__qualname__)
-
-        self.repos = RepoDict(self.default_owner, self.session)
+from typing import Dict, Iterable, List, Optional, Union
+
+from graphql import GraphQLError
+
+from components.const import DEFAULT_REPO_NAME, DEFAULT_REPO_OWNER, USER_AGENT
+from components.entrytypes import Commit, Discussion, Example, Issue, PTBContrib, PullRequest
+from components.graphqlclient import GraphQLClient
+
+
+class GitHub:
+    def __init__(self, auth: str, user_agent: str = USER_AGENT) -> None:
+        self._gql_client = GraphQLClient(auth=auth, user_agent=user_agent)
+
+        self._logger = logging.getLogger(self.__class__.__qualname__)
+
+        self.__lock = asyncio.Lock()
         self.issues: Dict[int, Issue] = {}
+        self.pull_requests: Dict[int, PullRequest] = {}
+        self.discussions: Dict[int, Discussion] = {}
         self.issue_iterator: Optional[Iterable[Issue]] = None
-        self.ptbcontribs: Dict[str, PTBContrib] = {}
-        self.issues_lock = threading.Lock()
-        self.ptbcontrib_lock = threading.Lock()
+        self.ptb_contribs: Dict[str, PTBContrib] = {}
+        self.examples: Dict[str, Example] = {}
 
-    def set_auth(self, client_id: str, client_secret: str) -> None:
-        self.session = login(client_id, client_secret)
-        self.repos.update_session(self.session)
+    async def initialize(self) -> None:
+        await self._gql_client.initialize()
+
+    async def shutdown(self) -> None:
+        await self._gql_client.shutdown()
 
     @property
     def all_ptbcontribs(self) -> List[PTBContrib]:
-        with self.ptbcontrib_lock:
-            return list(self.ptbcontribs.values())
+        return list(self.ptb_contribs.values())
 
     @property
     def all_issues(self) -> List[Issue]:
-        with self.issues_lock:
-            return list(self.issues.values())
-
-    def get_issue(self, number: int, owner: str = None, repo: str = None) -> Optional[Issue]:
-        if owner or repo:
-            self.logger.info(
-                "Getting issue %d for %s/%s",
-                number,
-                owner or self.default_owner,
-                repo or self.default_repo,
-            )
-        try:
-            if owner is not None:
-                repository = self.session.repository(owner, repo or self.default_repo)
-                gh_issue = repository.issue(number)
-            else:
-                repository = self.repos[repo or self.default_repo]
-                if repo is None:
-                    if issue := self.issues.get(number):
-                        return issue
-                    gh_issue = repository.issue(number)
-                else:
-                    gh_issue = repository.issue(number)
-            issue = Issue(gh_issue, repository)
-
-            if repo is None:
-                self.issues[number] = issue
-
-            return issue
-        except GitHubException:
-            return None
+        return list(self.issues.values())
 
-    @no_type_check
-    def get_commit(
-        self, sha: Union[int, str], owner: str = None, repo: str = None
-    ) -> Optional[Commit]:
-        if owner or repo:
-            self.logger.info(
-                "Getting commit %s for %s/%s",
-                sha[:7],
-                owner or self.default_owner,
-                repo or self.default_repo,
-            )
-        try:
-            if owner is not None:
-                repository = self.session.repository(owner, repo or self.default_repo)
-                gh_commit = repository.commit(sha)
-            else:
-                repository = self.repos[repo or self.default_repo]
-                if repo is None:
-                    if commit := self.issues.get(sha):
-                        return commit
-                    gh_commit = sha, repository.commit(sha)
-                else:
-                    gh_commit = repository.commit(sha)
-            return Commit(gh_commit, repository)
-        except GitHubException:
-            return None
+    @property
+    def all_pull_requests(self) -> List[PullRequest]:
+        return list(self.pull_requests.values())
 
-    def _job(self, job_queue: JobQueue) -> None:
-        self.logger.info("Getting issues for default repo.")
+    @property
+    def all_discussions(self) -> List[Discussion]:
+        return list(self.discussions.values())
 
+    @property
+    def all_examples(self) -> List[Example]:
+        return list(self.examples.values())
+
+    async def update_examples(self) -> None:
+        self._logger.info("Getting examples")
+        examples = await self._gql_client.get_examples()
+        async with self.__lock:
+            self.examples.clear()
+            for example in examples:
+                self.examples[example.short_name] = example
+
+    async def update_ptb_contribs(self) -> None:
+        self._logger.info("Getting ptbcontribs")
+        ptb_contribs = await self._gql_client.get_ptb_contribs()
+        async with self.__lock:
+            self.ptb_contribs.clear()
+            for ptb_contrib in ptb_contribs:
+                self.ptb_contribs[ptb_contrib.short_name.split("/")[1]] = ptb_contrib
+
+    async def update_issues(self, cursor: str = None) -> Optional[str]:
+        self._logger.info("Getting 100 issues before cursor %s", cursor)
+        issues, cursor = await self._gql_client.get_issues(cursor=cursor)
+        async with self.__lock:
+            for issue in issues:
+                self.issues[issue.number] = issue
+            return cursor
+
+    async def update_pull_requests(self, cursor: str = None) -> Optional[str]:
+        self._logger.info("Getting 100 pull requests before cursor %s", cursor)
+        pull_requests, cursor = await self._gql_client.get_pull_requests(cursor=cursor)
+        async with self.__lock:
+            for pull_request in pull_requests:
+                self.pull_requests[pull_request.number] = pull_request
+            return cursor
+
+    async def update_discussions(self, cursor: str = None) -> Optional[str]:
+        self._logger.info("Getting 100 discussions before cursor %s", cursor)
+        discussions, cursor = await self._gql_client.get_discussions(cursor=cursor)
+        async with self.__lock:
+            for discussion in discussions:
+                self.discussions[discussion.number] = discussion
+            return cursor
+
+    async def get_thread(
+        self, number: int, owner: str = DEFAULT_REPO_OWNER, repo: str = DEFAULT_REPO_NAME
+    ) -> Union[Issue, PullRequest, Discussion, None]:
+        if owner != DEFAULT_REPO_OWNER or repo != DEFAULT_REPO_NAME:
+            self._logger.info("Getting issue %d for %s/%s", number, owner, repo)
         try:
-            repo = self.repos[self.default_repo]
-            if self.issue_iterator is None:
-                self.issue_iterator = self.repos[self.default_repo].issues(state="all")
-            else:
-                # The GitHubIterator automatically takes care of passing the ETag
-                # which reduces the number of API requests that count towards the rate limit
-                cast(GitHubIterator, self.issue_iterator).refresh(True)
-
-            for i, gh_issue in enumerate(self.issue_iterator):
-                # Acquire lock so we don't add while a func (like self.search) is iterating over it
-                # We do this for ever single issue instead of before the for-loop, because that
-                # would block self.search during the loop which takes a while
-                with self.issues_lock:
-                    self.issues[gh_issue.number] = Issue(gh_issue, repo)
-                # Sleeping a moment after 100 issues to give the API some rest - we're not in a
-                # hurry. The 100 is the max. per page number and as of 2.0.0 what github3.py
-                # uses. sleeping doesn't block the bot, as jobs run in their own thread.
-                # This is outside the lock! (see above commit)
-                if (i + 1) % 100 == 0:
-                    self.logger.info("Done with %d issues. Sleeping a moment.", i + 1)
-                    time.sleep(10)
-
-            # Rerun in 20 minutes
-            job_queue.run_once(lambda _: self._job(job_queue), 60 * 20)
-        except GitHubException as exc:
-            if "rate limit" in str(exc):
-                self.logger.warning("GH API rate limit exceeded. Retrying in 70 minutes.")
-                job_queue.run_once(lambda _: self._job(job_queue), 60 * 70)
-            else:
-                self.logger.exception(
-                    "Something went wrong fetching issues. Retrying in 10s.", exc_info=exc
-                )
-                job_queue.run_once(lambda _: self._job(job_queue), 10)
-
-    def init_issues(self, job_queue: JobQueue) -> None:
-        job_queue.run_once(lambda _: self._job(job_queue), 10)
-
-    def _ptbcontrib_job(self, job_queue: JobQueue) -> None:
-        self.logger.info("Getting ptbcontrib data.")
+            thread = await self._gql_client.get_thread(
+                number=number, organization=owner, repository=repo
+            )
 
+            if owner == DEFAULT_REPO_OWNER and repo == DEFAULT_REPO_NAME:
+                async with self.__lock:
+                    if isinstance(thread, Issue):
+                        self.issues[thread.number] = thread
+                    if isinstance(thread, PullRequest):
+                        self.pull_requests[thread.number] = thread
+                    if isinstance(thread, Discussion):
+                        self.discussions[thread.number] = thread
+
+            return thread
+        except GraphQLError as exc:
+            self._logger.exception(
+                "Error while getting issue %d for %s/%s", number, owner, repo, exc_info=exc
+            )
+            return None
+
+    async def get_commit(
+        self, sha: str, owner: str = DEFAULT_REPO_OWNER, repo: str = DEFAULT_REPO_NAME
+    ) -> Optional[Commit]:
+        if owner != DEFAULT_REPO_OWNER or repo != DEFAULT_REPO_NAME:
+            self._logger.info("Getting commit %s for %s/%s", sha[:7], owner, repo)
         try:
-            files = cast(
-                List[Tuple[str, Contents]],
-                self.repos[PTBCONTRIB_REPO_NAME].directory_contents(PTBCONTRIB_REPO_NAME),
+            return await self._gql_client.get_commit(sha=sha, organization=owner, repository=repo)
+        except GraphQLError as exc:
+            self._logger.exception(
+                "Error while getting commit %s for %s/%s", sha[:7], owner, repo, exc_info=exc
             )
-            with self.ptbcontrib_lock:
-                self.ptbcontribs.clear()
-                self.ptbcontribs.update(
-                    {
-                        name: PTBContrib(name, content.html_url)
-                        for name, content in files
-                        if content.type == "dir"
-                    }
-                )
-
-            # Rerun in two hours minutes
-            job_queue.run_once(lambda _: self._ptbcontrib_job(job_queue), 2 * 60 * 60)
-        except GitHubException as exc:
-            if "rate limit" in str(exc):
-                self.logger.warning("GH API rate limit exceeded. Retrying in 70 minutes.")
-                job_queue.run_once(lambda _: self._ptbcontrib_job(job_queue), 60 * 70)
-            else:
-                self.logger.exception(
-                    "Something went wrong fetching issues. Retrying in 10s.", exc_info=exc
-                )
-                job_queue.run_once(lambda _: self._ptbcontrib_job(job_queue), 10)
-
-    def init_ptb_contribs(self, job_queue: JobQueue) -> None:
-        job_queue.run_once(lambda _: self._ptbcontrib_job(job_queue), 5)
-
-    @staticmethod
-    def _build_example_url(example_file_name: str) -> str:
-        return f'{EXAMPLES_URL}#{example_file_name.replace(".", "")}'
-
-    def get_examples_directory(self, pattern: Union[str, Pattern] = None) -> List[Tuple[str, str]]:
-        if isinstance(pattern, str):
-            effective_pattern: Optional[Pattern[Any]] = re.compile(pattern)
-        else:
-            effective_pattern = pattern
-
-        files = cast(
-            List[Tuple[str, Contents]],
-            self.repos[self.default_repo].directory_contents("examples"),
-        )
-        if effective_pattern is None:
-            return [(name, self._build_example_url(name)) for name, _ in files]
-        return [
-            (name, self._build_example_url(name))
-            for name, _ in files
-            if effective_pattern.search(name)
-        ]
-
-
-github_issues = GitHubIssues()
+            return None

components/github.py

@@ -0,0 +1,17 @@
+query getCommit($sha: String!, $organization: String = "python-telegram-bot", $repository: String = "python-telegram-bot") {
+    repository(owner: $organization, name: $repository) {
+        object(expression: $sha) {
+            ... on Commit {
+                author {
+                    user {
+                        login
+                        url
+                    }
+                }
+                url
+                message
+                oid
+            }
+        }
+    }
+}

components/graphql_queries/getCommit.gql

@@ -0,0 +1,19 @@
+query getDiscussions($cursor: String) {
+    repository(owner: "python-telegram-bot", name: "python-telegram-bot") {
+        discussions(last: 100, before: $cursor) {
+            nodes {
+                number
+                title
+                url
+                author {
+                    login
+                    url
+                }
+            }
+            pageInfo {
+                hasPreviousPage
+                startCursor
+            }
+        }
+    }
+}

components/graphql_queries/getDiscussions.gql

@@ -0,0 +1,11 @@
+query getExamples {
+    repository(owner: "python-telegram-bot", name: "python-telegram-bot") {
+        object(expression: "master:examples") {
+            ... on Tree {
+                entries {
+                    name
+                }
+            }
+        }
+    }
+}

components/graphql_queries/getExamples.gql

@@ -0,0 +1,19 @@
+query getIssues($cursor: String) {
+    repository(owner: "python-telegram-bot", name: "python-telegram-bot") {
+        issues(last: 100, before: $cursor) {
+            nodes {
+                number
+                title
+                url
+                author {
+                    login
+                    url
+                }
+            }
+            pageInfo {
+                hasPreviousPage
+                startCursor
+            }
+        }
+    }
+}

components/graphql_queries/getIssues.gql

@@ -0,0 +1,12 @@
+query getPTBContribs {
+    repository(owner: "python-telegram-bot", name: "ptbcontrib") {
+        object(expression: "main:ptbcontrib") {
+            ... on Tree {
+                entries {
+                    name
+                    type
+                }
+            }
+        }
+    }
+}

components/graphql_queries/getPTBContribs.gql

@@ -0,0 +1,19 @@
+query getPullRequests($cursor: String) {
+    repository(owner: "python-telegram-bot", name: "python-telegram-bot") {
+        pullRequests(last: 100, before: $cursor) {
+            nodes {
+                number
+                title
+                url
+                author {
+                    login
+                    url
+                }
+            }
+            pageInfo {
+                hasPreviousPage
+                startCursor
+            }
+        }
+    }
+}

components/graphql_queries/getPullRequests.gql

@@ -0,0 +1,35 @@
+query getThread($number: Int!, $organization: String = "python-telegram-bot", $repository: String = "python-telegram-bot") {
+    repository(owner: $organization, name: $repository) {
+        issueOrPullRequest(number: $number) {
+            ... on Issue {
+                number
+                url
+                title
+                author {
+                    login
+                    url
+                }
+                __typename
+            }
+            ... on PullRequest {
+                number
+                url
+                title
+                author {
+                    login
+                    url
+                }
+                __typename
+            }
+        }
+        discussion(number: $number) {
+            number
+            url
+            title
+            author {
+                login
+                url
+            }
+        }
+    }
+}

components/graphql_queries/getThread.gql

@@ -0,0 +1,170 @@
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from gql import Client, gql
+from gql.client import AsyncClientSession
+from gql.transport.aiohttp import AIOHTTPTransport
+from gql.transport.exceptions import TransportQueryError
+
+from components.const import DEFAULT_REPO_NAME, DEFAULT_REPO_OWNER, PTBCONTRIB_LINK, USER_AGENT
+from components.entrytypes import Commit, Discussion, Example, Issue, PTBContrib, PullRequest
+
+
+class GraphQLClient:
+    def __init__(self, auth: str, user_agent: str = USER_AGENT) -> None:
+        self._transport = AIOHTTPTransport(
+            url="https://api.github.com/graphql",
+            headers={
+                "Authorization": auth,
+                "user-agent": user_agent,
+            },
+        )
+        self._session = AsyncClientSession(Client(transport=self._transport))
+
+    async def initialize(self) -> None:
+        await self._transport.connect()
+
+    async def shutdown(self) -> None:
+        await self._transport.close()
+
+    async def _do_request(
+        self, query_name: str, variable_values: Dict[str, Any] = None
+    ) -> Dict[str, Any]:
+        return await self._session.execute(
+            gql(Path(f"components/graphql_queries/{query_name}.gql").read_text(encoding="utf-8")),
+            variable_values=variable_values,
+        )
+
+    async def get_examples(self) -> List[Example]:
+        """The all examples on the master branch"""
+        result = await self._do_request("getExamples")
+        return [
+            Example(name=file["name"])
+            for file in result["repository"]["object"]["entries"]
+            if file["name"].endswith(".py")
+        ]
+
+    async def get_ptb_contribs(self) -> List[PTBContrib]:
+        """The all ptb_contribs on the main branch"""
+        result = await self._do_request("getPTBContribs")
+        return [
+            PTBContrib(name=contrib["name"], url=f"{PTBCONTRIB_LINK}tree/main/{contrib['name']}")
+            for contrib in result["repository"]["object"]["entries"]
+            if contrib["type"] == "tree"
+        ]
+
+    async def get_thread(
+        self,
+        number: int,
+        organization: str = DEFAULT_REPO_OWNER,
+        repository: str = DEFAULT_REPO_NAME,
+    ) -> Union[Issue, PullRequest, Discussion]:
+        """Get a specific thread (issue/pr/discussion) on any repository. By default, ptb/ptb
+        will be searched"""
+        # The try-except is needed because we query for both issueOrPR & discussion at the same
+        # time, but it will only ever be one of them. Unfortunately we don't know which one …
+        try:
+            result = await self._do_request(
+                "getThread",
+                variable_values={
+                    "number": number,
+                    "organization": organization,
+                    "repository": repository,
+                },
+            )
+        except TransportQueryError as exc:
+            # … but the exc.data will contain the thread that is available
+            if not exc.data:
+                raise exc
+            result = exc.data
+
+        data = result["repository"]
+        thread_data = data["issueOrPullRequest"] or data["discussion"]
+
+        entry_type_data = dict(
+            owner=organization,
+            repo=repository,
+            number=number,
+            title=thread_data["title"],
+            url=thread_data["url"],
+            author=thread_data["author"]["login"],
+        )
+
+        if thread_data.get("__typename") == "Issue":
+            return Issue(**entry_type_data)
+        if thread_data.get("__typename") == "PullRequest":
+            return PullRequest(**entry_type_data)
+        return Discussion(**entry_type_data)
+
+    async def get_commit(
+        self,
+        sha: str,
+        organization: str = DEFAULT_REPO_OWNER,
+        repository: str = DEFAULT_REPO_NAME,
+    ) -> Commit:
+        """Get a specific commit on any repository. By default, ptb/ptb
+        will be searched"""
+        result = await self._do_request(
+            "getCommit",
+            variable_values={
+                "sha": sha,
+                "organization": organization,
+                "repository": repository,
+            },
+        )
+        data = result["repository"]["object"]
+        return Commit(
+            owner=organization,
+            repo=repository,
+            sha=data["oid"],
+            url=data["url"],
+            title=data["message"],
+            author=data["author"]["user"]["login"],
+        )
+
+    async def get_issues(self, cursor: str = None) -> Tuple[List[Issue], Optional[str]]:
+        """Last 100 issues before cursor"""
+        result = await self._do_request("getIssues", variable_values={"cursor": cursor})
+        return [
+            Issue(
+                owner=DEFAULT_REPO_OWNER,
+                repo=DEFAULT_REPO_NAME,
+                number=issue["number"],
+                title=issue["title"],
+                url=issue["url"],
+                author=issue["author"]["login"] if issue["author"] else None,
+            )
+            for issue in result["repository"]["issues"]["nodes"]
+        ], result["repository"]["issues"]["pageInfo"]["startCursor"]
+
+    async def get_pull_requests(
+        self, cursor: str = None
+    ) -> Tuple[List[PullRequest], Optional[str]]:
+        """Last 100 pull requests before cursor"""
+        result = await self._do_request("getPullRequests", variable_values={"cursor": cursor})
+        return [
+            PullRequest(
+                owner=DEFAULT_REPO_OWNER,
+                repo=DEFAULT_REPO_NAME,
+                number=pull_request["number"],
+                title=pull_request["title"],
+                url=pull_request["url"],
+                author=pull_request["author"]["login"] if pull_request["author"] else None,
+            )
+            for pull_request in result["repository"]["pullRequests"]["nodes"]
+        ], result["repository"]["pullRequests"]["pageInfo"]["startCursor"]
+
+    async def get_discussions(self, cursor: str = None) -> Tuple[List[Discussion], Optional[str]]:
+        """Last 100 discussions before cursor"""
+        result = await self._do_request("getDiscussions", variable_values={"cursor": cursor})
+        return [
+            Discussion(
+                owner=DEFAULT_REPO_OWNER,
+                repo=DEFAULT_REPO_NAME,
+                number=discussion["number"],
+                title=discussion["title"],
+                url=discussion["url"],
+                author=discussion["author"]["login"] if discussion["author"] else None,
+            )
+            for discussion in result["repository"]["discussions"]["nodes"]
+        ], result["repository"]["discussions"]["pageInfo"]["startCursor"]

components/graphqlclient.py

@@ -3,21 +3,18 @@
 from uuid import uuid4
 
 from telegram import (
+    InlineKeyboardMarkup,
+    InlineQuery,
     InlineQueryResultArticle,
     InputTextMessageContent,
     Update,
-    InlineQuery,
-    InlineKeyboardMarkup,
 )
 from telegram.error import BadRequest
-from telegram.ext import CallbackContext
+from telegram.ext import ContextTypes
 
-from components.const import (
-    ENCLOSED_REGEX,
-    ENCLOSING_REPLACEMENT_CHARACTER,
-)
+from components.const import ENCLOSED_REGEX, ENCLOSING_REPLACEMENT_CHARACTER
 from components.entrytypes import Issue
-from components.search import search
+from components.search import Search
 
 
 def article(
@@ -36,15 +33,18 @@ def article(
     )
 
 
-def inline_query(update: Update, _: CallbackContext) -> None:  # pylint: disable=R0915
+async def inline_query(
+    update: Update, context: ContextTypes.DEFAULT_TYPE
+) -> None:  # pylint: disable=R0915
     ilq = cast(InlineQuery, update.inline_query)
     query = ilq.query
     switch_pm_text = "❓ Help"
+    search = cast(Search, context.bot_data["search"])
 
     if ENCLOSED_REGEX.search(query):
         results_list = []
         symbols = tuple(ENCLOSED_REGEX.findall(query))
-        search_results = search.multi_search_combinations(symbols)
+        search_results = await search.multi_search_combinations(symbols)
 
         for combination in search_results:
             description = ", ".join(entry.short_description for entry in combination.values())
@@ -78,7 +78,7 @@ def inline_query(update: Update, _: CallbackContext) -> None:  # pylint: disable
                 )
             )
     else:
-        simple_search_results = search.search(query)
+        simple_search_results = await search.search(query)
         if not simple_search_results:
             results_list = []
             switch_pm_text = "❌ No Search Results Found"
@@ -94,7 +94,7 @@ def inline_query(update: Update, _: CallbackContext) -> None:  # pylint: disable
             ]
 
     try:
-        ilq.answer(
+        await ilq.answer(
             results=results_list,
             switch_pm_text=switch_pm_text,
             switch_pm_parameter="inline-help",
@@ -104,7 +104,7 @@ def inline_query(update: Update, _: CallbackContext) -> None:  # pylint: disable
     except BadRequest as exc:
         if "can't parse entities" not in exc.message:
             raise exc
-        ilq.answer(
+        await ilq.answer(
             results=[],
             switch_pm_text="❌ Invalid entities. Click me.",
             switch_pm_parameter="inline-entity-parsing",

components/inlinequeries.py

@@ -1,93 +1,126 @@
-import functools
+import asyncio
+import datetime
 import heapq
 import itertools
-
-from datetime import date
-
-from threading import Lock
-from typing import List, Tuple, Dict, Callable, Any, Optional, Iterable
+from io import BytesIO
+from typing import Any, Dict, Iterable, List, Optional, Tuple, cast
 from urllib.parse import urljoin
-from urllib.request import urlopen, Request
 
+import httpx
+from async_lru import alru_cache
 from bs4 import BeautifulSoup
 from sphinx.util.inventory import InventoryFile
+from telegram.ext import Application, ContextTypes, Job, JobQueue
 
 from .const import (
-    USER_AGENT,
+    DEFAULT_HEADERS,
+    DEFAULT_REPO_NAME,
+    DEFAULT_REPO_OWNER,
     DOCS_URL,
+    EXAMPLES_URL,
+    GITHUB_PATTERN,
     OFFICIAL_URL,
-    WIKI_URL,
+    USER_AGENT,
     WIKI_CODE_SNIPPETS_URL,
     WIKI_FAQ_URL,
-    EXAMPLES_URL,
-    GITHUB_PATTERN,
     WIKI_FRDP_URL,
+    WIKI_URL,
 )
 from .entrytypes import (
-    WikiPage,
-    Example,
+    BaseEntry,
     CodeSnippet,
-    FAQEntry,
     DocEntry,
-    BaseEntry,
+    FAQEntry,
     FRDPEntry,
     ParamDocEntry,
+    WikiPage,
 )
-from .github import github_issues
+from .github import GitHub
 from .taghints import TAG_HINTS
 
 
-def cached_parsing(func: Callable[..., Any]) -> Callable[..., Any]:
-    @functools.wraps(func)
-    def checking_cache_time(self: "Search", *args: Any, **kwargs: Any) -> Any:
-        if date.today() > self.last_cache_date:
-            self.fetch_entries()
-            self.last_cache_date = date.today()
-        return func(self, *args, **kwargs)
-
-    return checking_cache_time
-
-
 class Search:
-    def __init__(self) -> None:
-        self.__lock = Lock()
+    def __init__(self, github_auth: str, github_user_agent: str = USER_AGENT) -> None:
+        self.__lock = asyncio.Lock()
         self._docs: List[DocEntry] = []
         self._official: Dict[str, str] = {}
         self._wiki: List[WikiPage] = []
-        self._examples: List[Example] = []
         self._snippets: List[CodeSnippet] = []
         self._faq: List[FAQEntry] = []
         self._design_patterns: List[FRDPEntry] = []
-        self.last_cache_date = date.today()
-        self.github_session = github_issues
-        self.fetch_entries()
-
-    def fetch_entries(self) -> None:
-        with self.__lock:
-            self.fetch_docs()
-            self.fetch_wiki()
-            self.fetch_examples()
-            self.fetch_wiki_code_snippets()
-            self.fetch_wiki_faq()
-            self.fetch_wiki_design_patterns()
-
-            # This is important: If the docs have changed the cache is useless
-            self.search.cache_clear()
-            self.multi_search_combinations.cache_clear()
-
-    def fetch_official_docs(self) -> None:
-        request = Request(OFFICIAL_URL, headers={"User-Agent": USER_AGENT})
-        with urlopen(request) as file:
-            official_soup = BeautifulSoup(file, "html.parser")
+        self.github = GitHub(auth=github_auth, user_agent=github_user_agent)
+        self._httpx_client = httpx.AsyncClient()
+
+    async def initialize(
+        self, application: Application[Any, Any, Any, Any, Any, JobQueue]
+    ) -> None:
+        await self.github.initialize()
+        application.job_queue.run_once(callback=self.update_job, when=1, data=(None, None, None))
+
+    async def shutdown(self) -> None:
+        await self.github.shutdown()
+        await self._httpx_client.aclose()
+        await self.search.close()  # pylint:disable=no-member
+        await self.multi_search_combinations.close()  # pylint:disable=no-member
+
+    async def update_job(self, context: ContextTypes.DEFAULT_TYPE) -> None:
+        job = cast(Job, context.job)
+        cursors = cast(Tuple[Optional[str], Optional[str], Optional[str]], job.data)
+        restart = not any(cursors)
+
+        if restart:
+            await asyncio.gather(
+                context.application.create_task(self.github.update_examples()),
+                context.application.create_task(self.github.update_ptb_contribs()),
+            )
+            async with self.__lock:
+                await asyncio.gather(
+                    context.application.create_task(self.update_docs()),
+                    context.application.create_task(self.update_wiki()),
+                    context.application.create_task(self.update_wiki_code_snippets()),
+                    context.application.create_task(self.update_wiki_faq()),
+                    context.application.create_task(self.update_wiki_design_patterns()),
+                )
+
+        issue_cursor = (
+            await self.github.update_issues(cursor=cursors[0]) if restart or cursors[0] else None
+        )
+        pr_cursor = (
+            await self.github.update_pull_requests(cursor=cursors[1])
+            if restart or cursors[1]
+            else None
+        )
+        discussion_cursor = (
+            await self.github.update_discussions(cursor=cursors[2])
+            if restart or cursors[2]
+            else None
+        )
+
+        new_cursors = (issue_cursor, pr_cursor, discussion_cursor)
+        when = datetime.timedelta(seconds=30) if any(new_cursors) else datetime.timedelta(hours=12)
+        cast(JobQueue, context.job_queue).run_once(
+            callback=self.update_job, when=when, data=new_cursors
+        )
+
+        # This is important: If the docs have changed the cache is useless
+        self.search.cache_clear()  # pylint:disable=no-member
+        self.multi_search_combinations.cache_clear()  # pylint:disable=no-member
+
+    async def _update_official_docs(self) -> None:
+        response = await self._httpx_client.get(url=OFFICIAL_URL, headers=DEFAULT_HEADERS)
+        official_soup = BeautifulSoup(response.content, "html.parser")
         for anchor in official_soup.select("a.anchor"):
             if "-" not in anchor["href"]:
                 self._official[anchor["href"][1:]] = anchor.next_sibling
 
-    def fetch_docs(self) -> None:
-        self.fetch_official_docs()
-        request = Request(urljoin(DOCS_URL, "objects.inv"), headers={"User-Agent": USER_AGENT})
-        with urlopen(request) as docs_data:
-            data = InventoryFile.load(docs_data, DOCS_URL, urljoin)
+    async def update_docs(self) -> None:
+        await self._update_official_docs()
+        response = await self._httpx_client.get(
+            url=urljoin(DOCS_URL, "objects.inv"),
+            headers=DEFAULT_HEADERS,
+            follow_redirects=True,
+        )
+        data = InventoryFile.load(BytesIO(response.content), DOCS_URL, urljoin)
         self._docs = []
         for entry_type, items in data.items():
             for name, (_, _, url, display_name) in items.items():
@@ -99,11 +132,12 @@ def fetch_docs(self) -> None:
                 tg_url, tg_test, tg_name = "", "", ""
                 name_bits = name.split(".")
 
-                if entry_type in ["py:method", "py:attribute"]:
-                    if "telegram.Bot" in name or "telegram.ext.ExtBot" in name:
-                        tg_test = name_bits[-1]
-                    else:
-                        tg_test = name_bits[-2]
+                if entry_type == "py:method" and (
+                    "telegram.Bot" in name or "telegram.ext.ExtBot" in name
+                ):
+                    tg_test = name_bits[-1]
+                if entry_type == "py:attribute":
+                    tg_test = name_bits[-2]
                 if entry_type == "py:class":
                     tg_test = name_bits[-1]
                 elif entry_type == "py:parameter":
@@ -138,10 +172,9 @@ def fetch_docs(self) -> None:
                         )
                     )
 
-    def fetch_wiki(self) -> None:
-        request = Request(WIKI_URL, headers={"User-Agent": USER_AGENT})
-        with urlopen(request) as file:
-            wiki_soup = BeautifulSoup(file, "html.parser")
+    async def update_wiki(self) -> None:
+        response = await self._httpx_client.get(url=WIKI_URL, headers=DEFAULT_HEADERS)
+        wiki_soup = BeautifulSoup(response.content, "html.parser")
         self._wiki = []
 
         # Parse main pages from custom sidebar
@@ -160,10 +193,11 @@ def fetch_wiki(self) -> None:
 
         self._wiki.append(WikiPage(category="Code Resources", name="Examples", url=EXAMPLES_URL))
 
-    def fetch_wiki_code_snippets(self) -> None:
-        request = Request(WIKI_CODE_SNIPPETS_URL, headers={"User-Agent": USER_AGENT})
-        with urlopen(request) as file:
-            code_snippet_soup = BeautifulSoup(file, "html.parser")
+    async def update_wiki_code_snippets(self) -> None:
+        response = await self._httpx_client.get(
+            url=WIKI_CODE_SNIPPETS_URL, headers=DEFAULT_HEADERS
+        )
+        code_snippet_soup = BeautifulSoup(response.content, "html.parser")
         self._snippets = []
         for headline in code_snippet_soup.select(
             "div#wiki-body h4,div#wiki-body h3,div#wiki-body h2"
@@ -175,20 +209,18 @@ def fetch_wiki_code_snippets(self) -> None:
                 )
             )
 
-    def fetch_wiki_faq(self) -> None:
-        request = Request(WIKI_FAQ_URL, headers={"User-Agent": USER_AGENT})
-        with urlopen(request) as file:
-            faq_soup = BeautifulSoup(file, "html.parser")
+    async def update_wiki_faq(self) -> None:
+        response = await self._httpx_client.get(url=WIKI_FAQ_URL, headers=DEFAULT_HEADERS)
+        faq_soup = BeautifulSoup(response.content, "html.parser")
         self._faq = []
         for headline in faq_soup.select("div#wiki-body h3"):
             self._faq.append(
                 FAQEntry(name=headline.text.strip(), url=urljoin(WIKI_FAQ_URL, headline.a["href"]))
             )
 
-    def fetch_wiki_design_patterns(self) -> None:
-        request = Request(WIKI_FRDP_URL, headers={"User-Agent": USER_AGENT})
-        with urlopen(request) as file:
-            frdp_soup = BeautifulSoup(file, "html.parser")
+    async def update_wiki_design_patterns(self) -> None:
+        response = await self._httpx_client.get(url=WIKI_FRDP_URL, headers=DEFAULT_HEADERS)
+        frdp_soup = BeautifulSoup(response.content, "html.parser")
         self._design_patterns = []
         for headline in frdp_soup.select("div#wiki-body h3,div#wiki-body h2"):
             self._design_patterns.append(
@@ -197,18 +229,14 @@ def fetch_wiki_design_patterns(self) -> None:
                 )
             )
 
-    def fetch_examples(self) -> None:
-        self._examples = []
-        for name, _ in self.github_session.get_examples_directory(r"^.*\.py"):
-            self._examples.append(Example(name=name))
-
     @staticmethod
     def _sort_key(entry: BaseEntry, search_query: str) -> float:
         return entry.compare_to_query(search_query)
 
-    @functools.lru_cache(maxsize=64)
-    @cached_parsing
-    def search(self, search_query: Optional[str], amount: int = None) -> Optional[List[BaseEntry]]:
+    @alru_cache(maxsize=64)  # type: ignore[misc]
+    async def search(
+        self, search_query: Optional[str], amount: int = None
+    ) -> Optional[List[BaseEntry]]:
         """Searches all available entries for appropriate results. This includes:
 
         * wiki pages
@@ -251,34 +279,40 @@ def search(self, search_query: Optional[str], amount: int = None) -> Optional[Li
                 match.groupdict()[x]
                 for x in ("owner", "repo", "number", "sha", "query", "ptbcontrib")
             )
+            owner = owner or DEFAULT_REPO_OWNER
+            repo = repo or DEFAULT_REPO_NAME
 
             # If it's an issue
             if number:
-                issue = github_issues.get_issue(int(number), owner, repo)
+                issue = await self.github.get_thread(int(number), owner, repo)
                 return [issue] if issue else None
             # If it's a commit
             if sha:
-                commit = github_issues.get_commit(sha, owner, repo)
+                commit = await self.github.get_commit(sha, owner, repo)
                 return [commit] if commit else None
             # If it's a search
             if gh_search_query:
                 search_query = gh_search_query
-                search_entries = github_issues.all_issues
+                search_entries = itertools.chain(
+                    self.github.all_issues,
+                    self.github.all_pull_requests,
+                    self.github.all_discussions,
+                )
             elif ptbcontrib:
-                search_entries = github_issues.all_ptbcontribs
+                search_entries = self.github.all_ptbcontribs
 
         if search_query and search_query.startswith("/"):
             search_entries = TAG_HINTS.values()
 
-        with self.__lock:
+        async with self.__lock:
             if not search_entries:
                 search_entries = itertools.chain(
                     self._wiki,
-                    self._examples,
+                    self.github.all_examples,
                     self._faq,
                     self._design_patterns,
                     self._snippets,
-                    github_issues.all_ptbcontribs,
+                    self.github.all_ptbcontribs,
                     self._docs,
                     TAG_HINTS.values(),
                 )
@@ -298,9 +332,8 @@ def search(self, search_query: Optional[str], amount: int = None) -> Optional[Li
                 key=lambda entry: self._sort_key(entry, search_query),  # type: ignore[arg-type]
             )
 
-    @functools.lru_cache(64)
-    @cached_parsing
-    def multi_search_combinations(
+    @alru_cache(maxsize=64)  # type: ignore[misc]
+    async def multi_search_combinations(
         self, search_queries: Tuple[str], results_per_query: int = 3
     ) -> List[Dict[str, BaseEntry]]:
         """For each query, runs :meth:`search` and fetches the ``results_per_query`` most likely
@@ -322,13 +355,10 @@ def multi_search_combinations(
         # Remove duplicates while maintaining the order
         effective_queries = list(dict.fromkeys(search_queries))
         for query in effective_queries:
-            if res := self.search(search_query=query, amount=results_per_query):
+            if res := await self.search(search_query=query, amount=results_per_query):
                 results[query] = res
 
         return [
             dict(zip(effective_queries, query_results))
             for query_results in itertools.product(*results.values())
         ]
-
-
-search = Search()

components/search.py

@@ -1,8 +1,8 @@
 import re
-from typing import Dict, Any, Optional, List, Match
+from typing import Any, Dict, List, Match, Optional
 
 from telegram import InlineKeyboardButton, InlineKeyboardMarkup, Message, MessageEntity
-from telegram.ext import MessageFilter
+from telegram.ext.filters import MessageFilter
 
 from components import const
 from components.const import PTBCONTRIB_LINK
@@ -101,18 +101,20 @@
     },
     "wronglib": {
         "message": (
-            "{query} If you insist on using that other one, please go where you belong: "
-            '<a href="https://telegram.me/joinchat/Bn4ixj84FIZVkwhk2jag6A">pyTelegramBotApi</a>, '
+            "{query} : If you are using a different package/language, we are sure you can "
+            "find some kind of community help on their homepage. Here are a few links for other"
+            "popular libraries: "
+            '<a href="https://t.me/joinchat/Bn4ixj84FIZVkwhk2jag6A">pyTelegramBotApi</a>, '
             '<a href="https://github.com/nickoala/telepot">Telepot</a>, '
-            '<a href="https://t.me/Pyrogram">pyrogram</a>, '
+            '<a href="https://t.me/pyrogramchat">pyrogram</a>, '
             '<a href="https://t.me/TelethonChat">Telethon</a>, '
             '<a href="https://t.me/aiogram">aiogram</a>, '
             '<a href="https://t.me/botogram_users">botogram</a>.'
         ),
         "help": "Other Python wrappers for Telegram",
         "default": (
-            "Hey, I think you're wrong 🧐\nIt looks like you're not using the python-telegram-bot "
-            "library."
+            "Hey, I think you're wrong 🧐\nThis is the support group of the "
+            "<code>python-telegram-bot</code> library."
         ),
     },
     "pastebin": {
@@ -174,8 +176,8 @@
         "message": (
             "{query} This group is for technical questions that come up while you code your own "
             "Telegram bot. If you are looking for ready-to-use bots, please have a look at "
-            "channels like @BotsArchive or @BotList. There are also a number of websites that "
-            "list existing bots."
+            "channels like @BotsArchive or @BotList/@BotlistBot. There are also a number of "
+            "websites that list existing bots."
         ),
         "default": "Hey.",
         "help": "Redirect users to lists of existing bots.",
@@ -190,6 +192,31 @@
         "default": "Hey.",
         "help": "Remind the users of the Code of Conduct.",
     },
+    "docs": {
+        "message": (
+            f"{{query}} You can find our documentation at <a href='{const.DOCS_URL}'>Read the "
+            f"Docs</a>. "
+        ),
+        "default": "Hey.",
+        "help": "Point users to the documentation",
+        "group_command": True,
+    },
+    "wiki": {
+        "message": f"{{query}} You can find our wiki on <a href='{const.WIKI_URL}'>Github</a>.",
+        "default": "Hey.",
+        "help": "Point users to the wiki",
+        "group_command": True,
+    },
+    "help": {
+        "message": (
+            "{query} You can find an explanation of @roolsbot's functionality on '"
+            '<a href="https://github.com/python-telegram-bot/rules-bot/blob/master/README.md">'
+            "GitHub</a>."
+        ),
+        "default": "Hey.",
+        "help": "Point users to the bots readme",
+        "group_command": True,
+    },
 }
 
 
@@ -203,6 +230,7 @@
         description=value["help"],
         default_query=value.get("default"),
         inline_keyboard=InlineKeyboardMarkup(value["buttons"]) if "buttons" in value else None,
+        group_command=value.get("group_command", False),
     )
     for key, value in _TAG_HINTS.items()
 }
@@ -226,7 +254,7 @@ class TagHintFilter(MessageFilter):
     """Custom filter class for filtering for tag hint messages"""
 
     def __init__(self) -> None:
-        self.data_filter = True
+        super().__init__(name="TageHintFilter", data_filter=True)
 
     def filter(self, message: Message) -> Optional[Dict[str, List[Match]]]:
         """Does the filtering. Applies the regex and makes sure that only those tag hints are

components/taghints.py

@@ -4,23 +4,14 @@
 import sys
 import warnings
 from functools import wraps
-from typing import (
-    Optional,
-    List,
-    Callable,
-    TypeVar,
-    Dict,
-    cast,
-    Tuple,
-    Union,
-)
+from typing import Any, Callable, Coroutine, Dict, List, Optional, Tuple, Union, cast
 
 from bs4 import MarkupResemblesLocatorWarning
-from telegram import Update, InlineKeyboardButton, Message
-from telegram.error import BadRequest, Unauthorized
-from telegram.ext import CallbackContext
+from telegram import InlineKeyboardButton, Message, Update
+from telegram.error import BadRequest, Forbidden
+from telegram.ext import CallbackContext, ContextTypes
 
-from .const import RATE_LIMIT_SPACING, ONTOPIC_CHAT_ID, OFFTOPIC_CHAT_ID
+from .const import OFFTOPIC_CHAT_ID, ONTOPIC_CHAT_ID, RATE_LIMIT_SPACING
 from .taghints import TAG_HINTS
 
 # Messages may contain links that we don't care about - so let's ignore the warnings
@@ -33,25 +24,25 @@ def get_reply_id(update: Update) -> Optional[int]:
     return None
 
 
-def reply_or_edit(update: Update, context: CallbackContext, text: str) -> None:
+async def reply_or_edit(update: Update, context: CallbackContext, text: str) -> None:
     chat_data = cast(Dict, context.chat_data)
     if update.edited_message and update.edited_message.message_id in chat_data:
         try:
-            chat_data[update.edited_message.message_id].edit_text(text)
+            await chat_data[update.edited_message.message_id].edit_text(text)
         except BadRequest as exc:
             if "not modified" not in str(exc):
                 raise exc
     else:
         message = cast(Message, update.effective_message)
         issued_reply = get_reply_id(update)
         if issued_reply:
-            chat_data[message.message_id] = context.bot.send_message(
+            chat_data[message.message_id] = await context.bot.send_message(
                 message.chat_id,
                 text,
                 reply_to_message_id=issued_reply,
             )
         else:
-            chat_data[message.message_id] = message.reply_text(text)
+            chat_data[message.message_id] = await message.reply_text(text)
 
 
 def get_text_not_in_entities(message: Message) -> str:
@@ -94,48 +85,47 @@ def build_menu(
     return menu
 
 
-def try_to_delete(message: Message) -> bool:
+async def try_to_delete(message: Message) -> bool:
     try:
-        return message.delete()
-    except (BadRequest, Unauthorized):
+        return await message.delete()
+    except (BadRequest, Forbidden):
         return False
 
 
-def rate_limit_tracker(_: Update, context: CallbackContext) -> None:
+async def rate_limit_tracker(_: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
     data = cast(Dict, context.chat_data).setdefault("rate_limit", {})
 
     for key in data.keys():
         data[key] += 1
 
 
-Func = TypeVar("Func", bound=Callable[[Update, CallbackContext], None])
-
-
 def rate_limit(
-    func: Callable[[Update, CallbackContext], None]
-) -> Callable[[Update, CallbackContext], None]:
+    func: Callable[[Update, ContextTypes.DEFAULT_TYPE], Coroutine[Any, Any, None]]
+) -> Callable[[Update, ContextTypes.DEFAULT_TYPE], Coroutine[Any, Any, None]]:
     """
     Rate limit command so that RATE_LIMIT_SPACING non-command messages are
     required between invocations. Private chats are not rate limited.
     """
 
     @wraps(func)
-    def wrapper(update: Update, context: CallbackContext) -> None:
+    async def wrapper(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
         if chat := update.effective_chat:
             if chat.type == chat.PRIVATE:
-                return func(update, context)
+                return await func(update, context)
 
         # Get rate limit data
         data = cast(Dict, context.chat_data).setdefault("rate_limit", {})
 
         # If we have not seen two non-command messages since last of type `func`
         if data.get(func, RATE_LIMIT_SPACING) < RATE_LIMIT_SPACING:
             logging.debug("Ignoring due to rate limit!")
-            try_to_delete(cast(Message, update.effective_message))
+            context.application.create_task(
+                try_to_delete(cast(Message, update.effective_message)), update=update
+            )
             return None
 
         data[func] = 0
-        return func(update, context)
+        return await func(update, context)
 
     return wrapper
 
@@ -149,11 +139,11 @@ def build_command_list(
 ) -> List[Tuple[str, str]]:
 
     base_commands = [
-        ("docs", "Send the link to the docs."),
-        ("wiki", "Send the link to the wiki."),
-        ("help", "Send the link to this bots README."),
+        (hint.tag, hint.description) for hint in TAG_HINTS.values() if hint.group_command
+    ]
+    hint_commands = [
+        (hint.tag, hint.description) for hint in TAG_HINTS.values() if not hint.group_command
     ]
-    hint_commands = [(hint.tag, hint.description) for hint in TAG_HINTS.values()]
 
     if private:
         return base_commands + hint_commands

components/util.py

@@ -1,3 +1,7 @@
 [tool.black]
 line-length = 99
-target-version = ['py38']
+target-version = ['py38', 'py39', 'py310']
+
+[tool.isort]  # black config
+profile = "black"
+line_length = 99

pyproject.toml

@@ -1,7 +1 @@
-pre-commit
-# Make sure that the versions specified here match the pre-commit settings!
-black==22.3.0
-flake8==4.0.1
-pylint==2.14.3
-mypy==0.961
-pyupgrade==2.34.0
+pre-commit

requirements-dev.txt

@@ -1,9 +1,10 @@
 # Make sure to install those as additional_dependencies in the
 # pre-commit hooks for pylint & mypy
-beautifulsoup4
-thefuzz==0.19.0
-python-Levenshtein
-python-telegram-bot==13.9
-Sphinx
-requests
-github3.py==2.0.0
+beautifulsoup4~=4.11.0
+thefuzz~=0.19.0
+python-Levenshtein~=0.12.0
+python-telegram-bot==20.0a2
+Sphinx~=5.0.2
+httpx~=0.23.0
+gql~=3.3.0
+async-lru~=1.0.3

requirements.txt

@@ -1,62 +1,59 @@
+import asyncio
 import configparser
 import logging
 import os
+from typing import cast
 
 from telegram import (
-    ParseMode,
-    Bot,
-    Update,
+    BotCommandScopeAllGroupChats,
     BotCommandScopeAllPrivateChats,
     BotCommandScopeChat,
-    BotCommandScopeAllGroupChats,
     BotCommandScopeChatAdministrators,
+    Update,
 )
-from telegram.error import BadRequest, Unauthorized
+from telegram.constants import ParseMode
 from telegram.ext import (
+    Application,
+    ApplicationBuilder,
+    CallbackQueryHandler,
+    ChatJoinRequestHandler,
     CommandHandler,
-    Updater,
-    MessageHandler,
-    Filters,
     Defaults,
-    ChatMemberHandler,
     InlineQueryHandler,
-    CallbackQueryHandler,
+    MessageHandler,
+    filters,
 )
 
 from components import inlinequeries
 from components.callbacks import (
-    start,
-    rules,
-    docs,
-    wiki,
-    help_callback,
+    ban_sender_channels,
+    delete_new_chat_members_message,
+    join_request_buttons,
+    join_request_callback,
+    leave_chat,
     off_on_topic,
-    sandwich,
+    raise_app_handler_stop,
     reply_search,
-    delete_new_chat_members_message,
-    greet_new_chat_members,
-    tag_hint,
-    say_potato_command,
+    rules,
+    sandwich,
     say_potato_button,
-    ban_sender_channels,
+    say_potato_command,
+    start,
+    tag_hint,
 )
-from components.errorhandler import error_handler
 from components.const import (
-    OFFTOPIC_RULES,
+    ALLOWED_CHAT_IDS,
+    ALLOWED_USERNAMES,
+    ERROR_CHANNEL_CHAT_ID,
+    OFFTOPIC_CHAT_ID,
     OFFTOPIC_USERNAME,
-    ONTOPIC_RULES,
-    ONTOPIC_USERNAME,
-    ONTOPIC_RULES_MESSAGE_ID,
-    OFFTOPIC_RULES_MESSAGE_ID,
     ONTOPIC_CHAT_ID,
-    OFFTOPIC_CHAT_ID,
+    ONTOPIC_USERNAME,
 )
+from components.errorhandler import error_handler
+from components.search import Search
 from components.taghints import TagHintFilter
-from components.util import (
-    rate_limit_tracker,
-    build_command_list,
-)
-from components.github import github_issues
+from components.util import build_command_list, rate_limit_tracker
 
 if os.environ.get("ROOLSBOT_DEBUG"):
     logging.basicConfig(
@@ -67,136 +64,139 @@
         format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", level=logging.INFO
     )
     logging.getLogger("apscheduler").setLevel(logging.WARNING)
-    logging.getLogger("github3").setLevel(logging.WARNING)
+    logging.getLogger("gql").setLevel(logging.WARNING)
 
 logger = logging.getLogger(__name__)
 
 
-def update_rules_messages(bot: Bot) -> None:
-    try:
-        bot.edit_message_text(
-            chat_id=ONTOPIC_CHAT_ID,
-            message_id=ONTOPIC_RULES_MESSAGE_ID,
-            text=ONTOPIC_RULES,
+async def post_init(application: Application) -> None:
+    bot = application.bot
+    await cast(Search, application.bot_data["search"]).initialize(application)
+
+    # set commands
+    await bot.set_my_commands(
+        build_command_list(private=True),
+        scope=BotCommandScopeAllPrivateChats(),
+    )
+    await bot.set_my_commands(
+        build_command_list(private=False),
+        scope=BotCommandScopeAllGroupChats(),
+    )
+
+    for group_name in [ONTOPIC_CHAT_ID, OFFTOPIC_CHAT_ID]:
+        await bot.set_my_commands(
+            build_command_list(private=False, group_name=group_name),
+            scope=BotCommandScopeChat(group_name),
         )
-    except (BadRequest, Unauthorized) as exc:
-        logger.warning("Updating on-topic rules failed: %s", exc)
-    try:
-        bot.edit_message_text(
-            chat_id=OFFTOPIC_CHAT_ID,
-            message_id=OFFTOPIC_RULES_MESSAGE_ID,
-            text=OFFTOPIC_RULES,
+        await bot.set_my_commands(
+            build_command_list(private=False, group_name=group_name, admins=True),
+            scope=BotCommandScopeChatAdministrators(group_name),
         )
-    except (BadRequest, Unauthorized) as exc:
-        logger.warning("Updating off-topic rules failed: %s", exc)
+
+
+async def post_shutdown(application: Application) -> None:
+    await cast(Search, application.bot_data["search"]).shutdown()
 
 
 def main() -> None:
     config = configparser.ConfigParser()
     config.read("bot.ini")
 
     defaults = Defaults(parse_mode=ParseMode.HTML, disable_web_page_preview=True)
-    updater = Updater(token=config["KEYS"]["bot_api"], defaults=defaults)
-    dispatcher = updater.dispatcher
-    update_rules_messages(updater.bot)
+    application = (
+        ApplicationBuilder()
+        .token(config["KEYS"]["bot_api"])
+        .defaults(defaults)
+        .post_init(post_init)
+        .build()
+    )
+
+    application.bot_data["search"] = Search(github_auth=config["KEYS"]["github_auth"])
 
     # Note: Order matters!
 
-    dispatcher.add_handler(MessageHandler(~Filters.command, rate_limit_tracker), group=-1)
-    dispatcher.add_handler(
+    # Don't handle messages that were sent in the error channel
+    application.add_handler(
+        MessageHandler(filters.Chat(chat_id=ERROR_CHANNEL_CHAT_ID), raise_app_handler_stop),
+        group=-2,
+    )
+    # Leave groups that are not maintained by PTB
+    application.add_handler(
+        MessageHandler(
+            filters.ChatType.GROUPS
+            & ~(filters.Chat(username=ALLOWED_USERNAMES) | filters.Chat(chat_id=ALLOWED_CHAT_IDS)),
+            leave_chat,
+        ),
+        group=-2,
+    )
+
+    application.add_handler(MessageHandler(~filters.COMMAND, rate_limit_tracker), group=-1)
+    application.add_handler(
         MessageHandler(
-            Filters.sender_chat.channel & ~Filters.is_automatic_forward, ban_sender_channels
+            filters.SenderChat.CHANNEL
+            & ~filters.IS_AUTOMATIC_FORWARD
+            & ~filters.Chat(chat_id=ERROR_CHANNEL_CHAT_ID),
+            ban_sender_channels,
+            block=False,
         )
     )
 
     # Simple commands
     # The first one also handles deep linking /start commands
-    dispatcher.add_handler(CommandHandler("start", start))
-    dispatcher.add_handler(CommandHandler("rules", rules))
-    dispatcher.add_handler(CommandHandler("docs", docs))
-    dispatcher.add_handler(CommandHandler("wiki", wiki))
-    dispatcher.add_handler(CommandHandler("help", help_callback))
+    application.add_handler(CommandHandler("start", start))
+    application.add_handler(CommandHandler("rules", rules))
 
     # Stuff that runs on every message with regex
-    dispatcher.add_handler(
+    application.add_handler(
         MessageHandler(
-            Filters.regex(r"(?i)[\s\S]*?((sudo )?make me a sandwich)[\s\S]*?"), sandwich
+            filters.Regex(r"(?i)[\s\S]*?((sudo )?make me a sandwich)[\s\S]*?"), sandwich
         )
     )
-    dispatcher.add_handler(MessageHandler(Filters.regex("/(on|off)_topic"), off_on_topic))
+    application.add_handler(MessageHandler(filters.Regex("/(on|off)_topic"), off_on_topic))
 
     # Tag hints - works with regex
-    dispatcher.add_handler(MessageHandler(TagHintFilter(), tag_hint))
+    application.add_handler(MessageHandler(TagHintFilter(), tag_hint))
 
-    # We need several matches so Filters.regex is basically useless
+    # We need several matches so filters.REGEX is basically useless
     # therefore we catch everything and do regex ourselves
-    dispatcher.add_handler(
-        MessageHandler(Filters.text & Filters.update.messages & ~Filters.command, reply_search)
+    application.add_handler(
+        MessageHandler(filters.TEXT & filters.UpdateType.MESSAGES & ~filters.COMMAND, reply_search)
     )
 
     # Status updates
-    dispatcher.add_handler(
-        ChatMemberHandler(greet_new_chat_members, chat_member_types=ChatMemberHandler.CHAT_MEMBER)
-    )
-    dispatcher.add_handler(
+    application.add_handler(
         MessageHandler(
-            Filters.chat(username=[ONTOPIC_USERNAME, OFFTOPIC_USERNAME])
-            & Filters.status_update.new_chat_members,
+            filters.Chat(username=[ONTOPIC_USERNAME, OFFTOPIC_USERNAME])
+            & filters.StatusUpdate.NEW_CHAT_MEMBERS,
             delete_new_chat_members_message,
+            block=False,
         ),
         group=1,
     )
 
     # Inline Queries
-    dispatcher.add_handler(InlineQueryHandler(inlinequeries.inline_query))
+    application.add_handler(InlineQueryHandler(inlinequeries.inline_query))
 
     # Captcha for userbots
-    dispatcher.add_handler(
+    application.add_handler(
         CommandHandler(
             "say_potato",
             say_potato_command,
-            filters=Filters.chat(username=[ONTOPIC_USERNAME, OFFTOPIC_USERNAME]),
+            filters=filters.Chat(username=[ONTOPIC_USERNAME, OFFTOPIC_USERNAME]),
         )
     )
-    dispatcher.add_handler(CallbackQueryHandler(say_potato_button, pattern="^POTATO"))
-
-    # Error Handler
-    dispatcher.add_error_handler(error_handler)
+    application.add_handler(CallbackQueryHandler(say_potato_button, pattern="^POTATO"))
 
-    updater.start_polling(allowed_updates=Update.ALL_TYPES)
-    logger.info("Listening...")
+    # Join requests
+    application.add_handler(ChatJoinRequestHandler(callback=join_request_callback, block=False))
+    application.add_handler(CallbackQueryHandler(join_request_buttons, pattern="^JOIN"))
 
-    try:
-        github_issues.set_auth(
-            config["KEYS"]["github_client_id"], config["KEYS"]["github_client_secret"]
-        )
-    except KeyError:
-        logging.info("No github api token set. Rate-limit is 60 requests/hour without auth.")
-
-    github_issues.init_ptb_contribs(dispatcher.job_queue)  # type: ignore[arg-type]
-    github_issues.init_issues(dispatcher.job_queue)  # type: ignore[arg-type]
-
-    # set commands
-    updater.bot.set_my_commands(
-        build_command_list(private=True),
-        scope=BotCommandScopeAllPrivateChats(),
-    )
-    updater.bot.set_my_commands(
-        build_command_list(private=False),
-        scope=BotCommandScopeAllGroupChats(),
-    )
-
-    for group_name in [ONTOPIC_CHAT_ID, OFFTOPIC_CHAT_ID]:
-        updater.bot.set_my_commands(
-            build_command_list(private=False, group_name=group_name),
-            scope=BotCommandScopeChat(group_name),
-        )
-        updater.bot.set_my_commands(
-            build_command_list(private=False, group_name=group_name, admins=True),
-            scope=BotCommandScopeChatAdministrators(group_name),
-        )
+    # Error Handler
+    application.add_error_handler(error_handler)
 
-    updater.idle()
+    application.run_polling(allowed_updates=Update.ALL_TYPES, close_loop=False)
+    # Can be used in AppBuilder.post_shutdown once #3126 is released
+    asyncio.get_event_loop().run_until_complete(post_shutdown(application))
 
 
 if __name__ == "__main__":