mm-telegram 0.3.1__tar.gz

mm_telegram-0.3.1/.env.example

@@ -0,0 +1,2 @@
+TELEGRAM_TOKEN=***********
+TELEGRAM_CHAT_ID=****************

mm_telegram-0.3.1/.gitignore

@@ -0,0 +1,15 @@
+.idea
+.venv
+.env
+.coverage
+/htmlcov
+__pycache__
+*.egg-info
+pip-wheel-metadata
+.pytest_cache
+.mypy_cache
+.ruff_cache
+/dist
+/build
+/tmp
+.DS_Store

mm_telegram-0.3.1/.pre-commit-config.yaml

@@ -0,0 +1,10 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: check-toml
+      - id: check-json
+      - id: check-added-large-files

mm_telegram-0.3.1/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: mm-telegram
+Version: 0.3.1
+Requires-Python: >=3.13
+Requires-Dist: mm-http~=0.1.0
+Requires-Dist: python-telegram-bot~=22.1

mm_telegram-0.3.1/README.md

@@ -0,0 +1,85 @@
+# mm-telegram
+
+A Python library for building Telegram bots with type safety and modern async/await patterns.
+
+## Features
+
+- **Type-safe**: Full type annotations with mypy strict mode support
+- **Async/await**: Built on python-telegram-bot with modern async patterns
+- **Message splitting**: Automatic handling of long messages (>4096 chars)
+- **Admin control**: Built-in admin authorization system
+- **Simple API**: Minimal boilerplate for common bot operations
+
+## Quick Start
+
+### Basic Bot
+
+```python
+from mm_telegram import TelegramBot
+from telegram.ext import CommandHandler
+
+async def hello(update, context):
+    await update.message.reply_text("Hello!")
+
+bot = TelegramBot(
+    handlers=[CommandHandler("hello", hello)],
+    bot_data={}
+)
+
+await bot.start(token="YOUR_BOT_TOKEN", admins=[YOUR_USER_ID])
+```
+
+### Send Messages
+
+```python
+from mm_telegram import send_message
+
+result = await send_message(
+    bot_token="YOUR_BOT_TOKEN",
+    chat_id=123456789,
+    message="Your message here"
+)
+
+if result.is_ok():
+    message_ids = result.value
+    print(f"Sent messages: {message_ids}")
+```
+
+## API Reference
+
+### TelegramBot
+
+Main bot wrapper that manages application lifecycle.
+
+```python
+bot = TelegramBot(handlers, bot_data)
+await bot.start(token, admins)
+await bot.shutdown()
+```
+
+- `handlers`: List of telegram handlers (CommandHandler, MessageHandler, etc.)
+- `bot_data`: Initial bot data dictionary
+- `token`: Bot token from @BotFather
+- `admins`: List of admin user IDs
+
+### send_message
+
+Send messages with automatic splitting for long text.
+
+```python
+result = await send_message(
+    bot_token="token",
+    chat_id=123,
+    message="text",
+    timeout=5,
+    inter_message_delay_seconds=3
+)
+```
+
+Returns `Result[list[int]]` with message IDs on success.
+
+### Built-in Handlers
+
+- `/ping` - Responds with "pong"
+- Unknown commands - "Sorry, I didn't understand that command."
+- Admin check - Blocks non-admin users

mm_telegram-0.3.1/justfile

@@ -0,0 +1,40 @@
+version := `uv run python -c 'import tomllib; print(tomllib.load(open("pyproject.toml", "rb"))["project"]["version"])'`
+
+
+clean:
+    rm -rf .pytest_cache .mypy_cache .ruff_cache .coverage dist build src/*.egg-info
+
+build: clean
+    uv build
+
+format:
+    uv run ruff check --select I --fix src tests
+    uv run ruff format src tests
+
+test:
+    uv run pytest -n auto tests
+
+lint: format
+    uv run ruff check src tests
+    uv run mypy src
+
+audit:
+    uv export --no-dev --all-extras --format requirements-txt --no-emit-project > requirements.txt
+    uv run pip-audit -r requirements.txt --disable-pip
+    rm requirements.txt
+    uv run bandit --silent --recursive --configfile "pyproject.toml" src
+
+publish: build lint audit test
+    git diff-index --quiet HEAD
+    uvx twine upload dist/**
+    git tag -a 'v{{version}}' -m 'v{{version}}'
+    git push origin v{{version}}
+
+sync:
+    uv sync --all-extras
+
+pre-commit:
+    uv run pre-commit run --all-files
+
+pre-commit-autoupdate:
+    uv run pre-commit autoupdate

mm_telegram-0.3.1/pyproject.toml

@@ -0,0 +1,73 @@
+[project]
+name = "mm-telegram"
+version = "0.3.1"
+description = ""
+requires-python = ">=3.13"
+dependencies = [
+    "mm-http~=0.1.0",
+    "python-telegram-bot~=22.1",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.uv]
+dev-dependencies = [
+    "pytest~=8.4.0",
+    "pytest-asyncio~=1.0.0",
+    "pytest-xdist~=3.7.0",
+    "ruff~=0.11.13",
+    "pip-audit~=2.9.0",
+    "bandit~=1.8.3",
+    "mypy~=1.16.0",
+    "pre-commit~=4.2.0",
+    "python-dotenv>=1.1.0",
+]
+[tool.mypy]
+python_version = "3.13"
+warn_no_return = false
+strict = true
+exclude = ["^tests/", "^tmp/"]
+
+[tool.ruff]
+line-length = 130
+target-version = "py313"
+[tool.ruff.lint]
+select = ["ALL"]
+ignore = [
+    "TC", # flake8-type-checking, TYPE_CHECKING is dangerous, for example it doesn't work with pydantic
+    "A005", # flake8-builtins: stdlib-module-shadowing
+    "ERA001", # eradicate: commented-out-code
+    "PT", # flake8-pytest-style
+    "D", # pydocstyle
+    "FIX", # flake8-fixme
+    "PLR0911", # refactor: too-many-return-statements
+    "PLR0913", # pylint: too-many-arguments
+    "PLR2004", # pylint: magic-value-comparison
+    "PLC0414", # pylint: useless-import-alias
+    "FBT", # flake8-boolean-trap
+    "EM", # flake8-errmsg
+    "TRY003", # tryceratops: raise-vanilla-args
+    "C901", # mccabe: complex-structure,
+    "BLE001", # flake8-blind-except
+    "S311", # bandit: suspicious-non-cryptographic-random-usage
+    "TD002", # flake8-todos: missing-todo-author
+    "TD003", # flake8-todos: missing-todo-link
+    "RET503", # flake8-return: implicit-return
+    "COM812", # it's used in ruff formatter
+    "ASYNC109",
+]
+[tool.ruff.lint.per-file-ignores]
+"tests/*.py" = ["ANN", "S"]
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+
+[tool.bandit]
+exclude_dirs = ["tests"]
+skips = ["B311"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"

mm_telegram-0.3.1/src/mm_telegram/__init__.py

@@ -0,0 +1,4 @@
+from .bot import TelegramBot, TelegramHandler
+from .message import send_message
+
+__all__ = ["TelegramBot", "TelegramHandler", "send_message"]

mm_telegram-0.3.1/src/mm_telegram/bot.py

@@ -0,0 +1,95 @@
+import logging
+from typing import Any
+
+from telegram import Update
+from telegram.ext import (
+    Application,
+    ApplicationBuilder,
+    ApplicationHandlerStop,
+    BaseHandler,
+    CallbackContext,
+    CommandHandler,
+    ContextTypes,
+    ExtBot,
+    MessageHandler,
+    filters,
+)
+
+logger = logging.getLogger(__name__)
+
+
+type TelegramHandler = BaseHandler[Any, CallbackContext[ExtBot[None], dict[Any, Any], dict[Any, Any], dict[Any, Any]], Any]
+
+
+async def ping(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Responds with 'pong' to /ping command."""
+    if update.effective_chat is not None:
+        await context.bot.send_message(chat_id=update.effective_chat.id, text="pong")
+
+
+async def unknown(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Handles unknown commands with a default response."""
+    if update.effective_chat is not None:
+        await context.bot.send_message(chat_id=update.effective_chat.id, text="Sorry, I didn't understand that command.")
+
+
+async def is_admin(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Checks if user is admin and blocks access if not.
+
+    Raises ApplicationHandlerStop if user is not in the admins list.
+    """
+    admins: list[int] = context.bot_data.get("admins", [])
+
+    if update.effective_user is None or update.message is None:
+        raise ApplicationHandlerStop
+
+    if update.effective_user.id not in admins:
+        logger.warning("is not admin", extra={"telegram_user_id": update.effective_user.id})
+        await update.message.reply_text("Who are you?")
+        raise ApplicationHandlerStop
+
+
+class TelegramBot:
+    """Telegram bot wrapper that manages application lifecycle and handlers."""
+
+    app: Application[Any, Any, Any, Any, Any, Any] | None
+
+    def __init__(self, handlers: list[TelegramHandler], bot_data: dict[str, object]) -> None:
+        """Initialize bot with custom handlers and initial bot data."""
+        self.handlers = handlers
+        self.bot_data = bot_data
+        self.app = None
+
+    async def start(self, token: str, admins: list[int]) -> None:
+        """Start the bot with given token and admin list.
+
+        Raises ValueError if no admins are provided.
+        """
+        if not admins:
+            raise ValueError("No admins provided")
+        logger.debug("Starting telegram bot...")
+        app = ApplicationBuilder().token(token).build()
+        for key, value in self.bot_data.items():
+            app.bot_data[key] = value
+        app.bot_data["admins"] = admins
+
+        for handler in self.handlers:
+            app.add_handler(handler)
+
+        app.add_handler(CommandHandler("ping", ping))
+        app.add_handler(MessageHandler(filters.COMMAND, unknown))
+
+        await app.initialize()
+        await app.start()
+        if app.updater is not None:
+            await app.updater.start_polling()
+            logger.debug("Telegram bot started.")
+
+        self.app = app
+
+    async def shutdown(self) -> None:
+        """Stop the bot and clean up resources."""
+        if self.app is not None:
+            await self.app.shutdown()
+            self.app = None
+            logger.debug("Telegram bot stopped.")

mm_telegram-0.3.1/src/mm_telegram/message.py

@@ -0,0 +1,63 @@
+import asyncio
+
+from mm_http import http_request
+from mm_result import Result
+
+
+async def send_message(
+    bot_token: str,
+    chat_id: int,
+    message: str,
+    timeout: float = 5,
+    inter_message_delay_seconds: int = 3,
+) -> Result[list[int]]:
+    """
+    Sends a message to a Telegram chat.
+
+    If the message exceeds the Telegram character limit (4096),
+    it will be split into multiple messages and sent sequentially
+    with a delay between each part.
+
+    Args:
+        bot_token: The Telegram bot token.
+        chat_id: The target chat ID.
+        message: The message text to send.
+        timeout: The HTTP request timeout in seconds. Defaults to 5.
+        inter_message_delay_seconds: The delay in seconds between sending
+            parts of a long message. Defaults to 3.
+
+    Returns:
+        A Result object containing a list of message IDs for the sent messages
+        on success, or an error details on failure. The 'extra' field in the
+        Result contains the raw responses from the Telegram API.
+    """
+    messages = _split_string(message, 4096)
+    responses = []
+    result_message_ids = []
+    while True:
+        text_part = messages.pop(0)
+        params = {"chat_id": chat_id, "text": text_part}
+        res = await http_request(
+            f"https://api.telegram.org/bot{bot_token}/sendMessage", method="post", json=params, timeout=timeout
+        )
+        responses.append(res.to_dict())
+        if res.is_err():
+            return Result.err(res.error or "error sending message", extra={"responses": responses})
+
+        message_id = res.parse_json_body("result.message_id", none_on_error=True)
+        if message_id:
+            result_message_ids.append(message_id)
+        else:
+            # Log the unexpected response for debugging?
+            return Result.err("unknown_response_structure", extra={"responses": responses})
+
+        if len(messages):
+            await asyncio.sleep(inter_message_delay_seconds)
+        else:
+            break
+    return Result.ok(result_message_ids, extra={"responses": responses})
+
+
+def _split_string(text: str, chars_per_string: int) -> list[str]:
+    """Splits a string into a list of strings, each with a maximum length."""
+    return [text[i : i + chars_per_string] for i in range(0, len(text), chars_per_string)]

mm_telegram-0.3.1/tests/conftest.py

@@ -0,0 +1,23 @@
+import os
+
+import pytest
+from dotenv import load_dotenv
+
+load_dotenv()
+
+TELEGRAM_TOKEN = os.getenv("TELEGRAM_TOKEN", "")
+TELEGRAM_CHAT_ID = os.getenv("TELEGRAM_CHAT_ID", "")
+
+
+@pytest.fixture
+def telegram_token() -> str:
+    if not TELEGRAM_TOKEN:
+        raise ValueError("TELEGRAM_TOKEN is not set")
+    return TELEGRAM_TOKEN
+
+
+@pytest.fixture
+def telegram_chat_id() -> int:
+    if not TELEGRAM_CHAT_ID:
+        raise ValueError("TELEGRAM_CHAT_ID is not set")
+    return int(TELEGRAM_CHAT_ID)

mm_telegram-0.3.1/tests/test_bot.py

@@ -0,0 +1,262 @@
+from typing import cast
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from telegram import Update
+from telegram.ext import (
+    Application,
+    ApplicationHandlerStop,
+    BaseHandler,
+    CallbackContext,
+    CommandHandler,
+    ContextTypes,
+    MessageHandler,
+    filters,
+)
+
+from mm_telegram.bot import TelegramBot, TelegramHandler, is_admin, ping, unknown
+
+
+@pytest.fixture
+def mock_update() -> Update:
+    """Fixture to create a mock Update object."""
+    update = MagicMock(spec=Update)
+    update.effective_chat = MagicMock()
+    update.effective_chat.id = 12345
+    update.effective_user = MagicMock()
+    update.effective_user.id = 67890
+    update.message = MagicMock()
+    update.message.reply_text = AsyncMock()
+    return update
+
+
+@pytest.fixture
+def mock_context() -> ContextTypes.DEFAULT_TYPE:
+    """Fixture to create a mock CallbackContext object."""
+    context = MagicMock(spec=CallbackContext)
+    context.bot = AsyncMock()
+    context.bot_data = {}
+    return context
+
+
+@pytest.fixture
+def mock_application() -> MagicMock:
+    """Fixture to create a mock Application object."""
+    app = MagicMock(spec=Application)
+    app.update_queue = AsyncMock()
+    app.bot_data = {}
+    app.initialize = AsyncMock()
+    app.start = AsyncMock()
+    app.shutdown = AsyncMock()
+    app.updater = MagicMock()
+    app.updater.start_polling = AsyncMock()
+    app.add_handler = MagicMock()
+    app.process_update = AsyncMock()
+    return app
+
+
+def test_telegram_bot_init() -> None:
+    """Test TelegramBot initialization."""
+    mock_handler = MagicMock(spec=BaseHandler[Update, ContextTypes.DEFAULT_TYPE, object])
+    handlers: list[TelegramHandler] = [mock_handler]
+    bot_data: dict[str, object] = {"key": "value"}
+    bot = TelegramBot(handlers=handlers, bot_data=bot_data)
+
+    assert bot.handlers == handlers
+    assert bot.bot_data == bot_data
+    assert bot.app is None
+
+
+@pytest.mark.asyncio
+@patch("mm_telegram.bot.ApplicationBuilder")
+async def test_telegram_bot_start_success(mock_application_builder_cls: MagicMock, mock_application: MagicMock) -> None:
+    """Test TelegramBot.start successfully initializes and starts the application."""
+    mock_builder_instance = MagicMock()
+    mock_builder_instance.token.return_value = mock_builder_instance
+    mock_builder_instance.build.return_value = mock_application
+    mock_application_builder_cls.return_value = mock_builder_instance
+
+    # Make lambda async
+    async def dummy_handler(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+        pass
+
+    custom_handler = CommandHandler("custom", dummy_handler)
+    handlers: list[TelegramHandler] = [custom_handler]
+    initial_bot_data: dict[str, object] = {"initial_key": "initial_value"}
+    bot = TelegramBot(handlers=handlers, bot_data=initial_bot_data)
+
+    token = "test_token"
+    admins = [123, 456]
+
+    await bot.start(token=token, admins=admins)
+
+    mock_application_builder_cls.assert_called_once_with()
+    mock_builder_instance.token.assert_called_once_with(token)
+    mock_builder_instance.build.assert_called_once_with()
+
+    assert mock_application.bot_data["initial_key"] == "initial_value"
+    assert mock_application.bot_data["admins"] == admins
+
+    # Check handlers: 1 custom + 2 default (ping, unknown)
+    assert mock_application.add_handler.call_count == 3
+    # Check specific handlers were added
+    added_handlers = [call.args[0] for call in mock_application.add_handler.call_args_list]
+    assert custom_handler in added_handlers
+    assert any(isinstance(h, CommandHandler) and h.callback == ping for h in added_handlers)
+    assert any(isinstance(h, MessageHandler) and h.callback == unknown and h.filters == filters.COMMAND for h in added_handlers)
+
+    mock_application.initialize.assert_awaited_once()
+    mock_application.start.assert_awaited_once()
+    assert bot.app == mock_application
+    if mock_application.updater:
+        mock_application.updater.start_polling.assert_awaited_once()
+
+
+@pytest.mark.asyncio
+async def test_telegram_bot_start_no_admins_raises_value_error() -> None:
+    """Test TelegramBot.start raises ValueError if no admins are provided."""
+    bot = TelegramBot(handlers=[], bot_data={})
+    with pytest.raises(ValueError, match="No admins provided"):
+        await bot.start(token="test_token", admins=[])
+
+
+@pytest.mark.asyncio
+async def test_telegram_bot_shutdown(
+    mock_application: MagicMock,  # Use the fixture
+) -> None:
+    """Test TelegramBot.shutdown calls app.shutdown()."""
+    bot = TelegramBot(handlers=[], bot_data={})
+    bot.app = mock_application  # Assign the mocked application
+
+    await bot.shutdown()
+
+    mock_application.shutdown.assert_awaited_once()
+    assert bot.app is None
+
+
+@pytest.mark.asyncio
+async def test_telegram_bot_shutdown_no_app() -> None:
+    """Test TelegramBot.shutdown does nothing if app is None."""
+    bot = TelegramBot(handlers=[], bot_data={})
+    assert bot.app is None
+    # Should not raise any error and complete successfully
+    await bot.shutdown()
+    assert bot.app is None  # Still None
+
+
+@pytest.mark.asyncio
+async def test_ping_handler(mock_update: Update, mock_context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Test the ping handler sends 'pong'."""
+    assert mock_update.effective_chat is not None
+    await ping(mock_update, mock_context)
+    cast(AsyncMock, mock_context.bot.send_message).assert_awaited_once_with(chat_id=mock_update.effective_chat.id, text="pong")
+
+
+@pytest.mark.asyncio
+async def test_ping_handler_no_effective_chat(mock_update: Update, mock_context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Test the ping handler does nothing if effective_chat is None."""
+    cast(MagicMock, mock_update).configure_mock(effective_chat=None)
+
+    await ping(mock_update, mock_context)
+    cast(AsyncMock, mock_context.bot.send_message).assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_unknown_handler(mock_update: Update, mock_context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Test the unknown handler sends a specific message."""
+    assert mock_update.effective_chat is not None  # From fixture
+    await unknown(mock_update, mock_context)
+    cast(AsyncMock, mock_context.bot.send_message).assert_awaited_once_with(
+        chat_id=mock_update.effective_chat.id, text="Sorry, I didn't understand that command."
+    )
+
+
+@pytest.mark.asyncio
+async def test_unknown_handler_no_effective_chat(mock_update: Update, mock_context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Test the unknown handler does nothing if effective_chat is None."""
+    cast(MagicMock, mock_update).configure_mock(effective_chat=None)
+    await unknown(mock_update, mock_context)
+    cast(AsyncMock, mock_context.bot.send_message).assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_is_admin_user_is_admin(mock_update: Update, mock_context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Test is_admin allows an admin user."""
+    admin_user_id = 67890
+    mock_context.bot_data["admins"] = [admin_user_id]
+    assert mock_update.effective_user is not None
+    mock_update.effective_user.id = admin_user_id
+
+    # Should not raise ApplicationHandlerStop
+    await is_admin(mock_update, mock_context)
+    # Ensure no reply was sent (meaning access granted)
+    assert mock_update.message is not None
+    cast(AsyncMock, mock_update.message.reply_text).assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_is_admin_user_not_admin(mock_update: Update, mock_context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Test is_admin blocks a non-admin user and replies."""
+    non_admin_user_id = 11111
+    mock_context.bot_data["admins"] = [12345]  # Some other admin
+    assert mock_update.effective_user is not None
+    mock_update.effective_user.id = non_admin_user_id
+    assert mock_update.message is not None
+
+    with pytest.raises(ApplicationHandlerStop):
+        await is_admin(mock_update, mock_context)
+
+    assert mock_update.message is not None
+    cast(AsyncMock, mock_update.message.reply_text).assert_awaited_once_with("Who are you?")
+
+
+@pytest.mark.asyncio
+async def test_is_admin_no_admins_in_bot_data(mock_update: Update, mock_context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Test is_admin blocks if 'admins' list is not in bot_data."""
+    # Ensure 'admins' key is missing or empty
+    if "admins" in mock_context.bot_data:
+        del mock_context.bot_data["admins"]
+    # Or mock_context.bot_data["admins"] = [] -> this also works due to `get("admins", [])`
+
+    assert mock_update.effective_user is not None
+    mock_update.effective_user.id = 12345  # Any user ID
+    assert mock_update.message is not None
+
+    with pytest.raises(ApplicationHandlerStop):
+        await is_admin(mock_update, mock_context)
+
+    assert mock_update.message is not None
+    cast(AsyncMock, mock_update.message.reply_text).assert_awaited_once_with("Who are you?")
+
+
+@pytest.mark.asyncio
+async def test_is_admin_no_effective_user(mock_update: Update, mock_context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Test is_admin blocks if effective_user is None."""
+    cast(MagicMock, mock_update).configure_mock(effective_user=None)
+    mock_context.bot_data["admins"] = [12345]
+
+    with pytest.raises(ApplicationHandlerStop):
+        await is_admin(mock_update, mock_context)
+    # No reply_text should be called because it exits before that
+    assert mock_update.message is not None
+    cast(AsyncMock, mock_update.message.reply_text).assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_is_admin_no_message(mock_update: Update, mock_context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Test is_admin blocks if message is None (after effective_user check)."""
+    # effective_user must exist for this path
+    assert mock_update.effective_user is not None
+    mock_update.effective_user.id = 11111  # Non-admin, to try to reach reply_text path
+    mock_context.bot_data["admins"] = [67890]  # Different admin
+
+    cast(MagicMock, mock_update).configure_mock(message=None)
+
+    with pytest.raises(ApplicationHandlerStop):
+        await is_admin(mock_update, mock_context)
+    # reply_text is on update.message, so if message is None, this can't be called.
+    # The check `if update.message is None: raise ApplicationHandlerStop` prevents it.
+    # If reply_text were on context.bot.send_message, we'd check it. But it's on update.message.
+
+
+# End of tests