threadkiller 3.0.3__tar.gz → 4.0.0__tar.gz

{threadkiller-3.0.3 → threadkiller-4.0.0}/.editorconfig

@@ -24,3 +24,9 @@ indent_style = space
 # YAML does not support tabs, and looks weird with 4 spaces
 indent_size = 2
 indent_style = space
+
+[*.ftl]
+
+# Fluent does not support tabs
+indent_size = 4
+indent_style = space

{threadkiller-3.0.3 → threadkiller-4.0.0}/.idea/inspectionProfiles/Project_Default.xml

@@ -6,7 +6,7 @@
     <inspection_tool class="LessResolvedByNameOnly" enabled="true" level="WARNING" enabled_by_default="true" />
     <inspection_tool class="LessUnresolvedMixin" enabled="true" level="ERROR" enabled_by_default="true" />
     <inspection_tool class="LessUnresolvedVariable" enabled="true" level="ERROR" enabled_by_default="true" />
-    <inspection_tool class="LongLine" enabled="true" level="WEAK WARNING" enabled_by_default="true" />
+    <inspection_tool class="LongLine" enabled="false" level="WEAK WARNING" enabled_by_default="false" />
     <inspection_tool class="PoetryPackageVersion" enabled="true" level="SERVER PROBLEM" enabled_by_default="true" />
     <inspection_tool class="ProblematicWhitespace" enabled="true" level="WEAK WARNING" enabled_by_default="true" />
     <inspection_tool class="PyAbstractClassInspection" enabled="true" level="ERROR" enabled_by_default="true" />
@@ -26,17 +26,12 @@
     <inspection_tool class="PyMissingTypeHintsInspection" enabled="true" level="WEAK WARNING" enabled_by_default="true" />
     <inspection_tool class="PyNestedDecoratorsInspection" enabled="true" level="WARNING" enabled_by_default="true" />
     <inspection_tool class="PyNoneFunctionAssignmentInspection" enabled="true" level="WARNING" enabled_by_default="true" />
-    <inspection_tool class="PyPackageRequirementsInspection" enabled="false" level="ERROR" enabled_by_default="false">
-      <option name="ignoredPackages">
-        <value>
-          <list size="0" />
-        </value>
-      </option>
-    </inspection_tool>
+    <inspection_tool class="PyPackageRequirementsInspection" enabled="false" level="ERROR" enabled_by_default="false" />
     <inspection_tool class="PyPep8NamingInspection" enabled="true" level="WEAK WARNING" enabled_by_default="true">
       <option name="ignoredErrors">
         <list>
           <option value="N806" />
+          <option value="N802" />
         </list>
       </option>
     </inspection_tool>

{threadkiller-3.0.3 → threadkiller-4.0.0}/.idea/misc.xml

@@ -6,4 +6,7 @@
   <component name="ProjectRootManager" version="2" languageLevel="JDK_16" project-jdk-name="Poetry (threadkiller)" project-jdk-type="Python SDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
+  <component name="TaskProjectConfiguration">
+    <server type="Forgejo" url="https://g.starshard.space" />
+  </component>
 </project>

{threadkiller-3.0.3 → threadkiller-4.0.0}/Containerfile

@@ -23,7 +23,7 @@ CMD []
 LABEL org.opencontainers.image.title="Threadkiller"
 LABEL org.opencontainers.image.description="Telegram bot to delete messages sent outside of threads"
 LABEL org.opencontainers.image.authors="Stefano Pigozzi <me@steffo.eu>"
-LABEL org.opencontainers.image.version="3.0.0"
+LABEL org.opencontainers.image.version="4.0.0"
 LABEL org.opencontainers.image.licenses="EUPL-1.2"
 LABEL org.opencontainers.image.url="https://g.starshard.space/steffo/-/packages/container/threadkiller/latest"
 LABEL org.opencontainers.image.source="https://g.starshard.space/steffo/threadkiller"

{threadkiller-3.0.3 → threadkiller-4.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: threadkiller
-Version: 3.0.3
+Version: 4.0.0
 Summary: Telegram bot to delete messages sent outside of threads
 Project-URL: Source, https://g.starshard.space/steffo/threadkiller
 Project-URL: Issues, https://g.starshard.space/steffo/threadkiller/issues
@@ -23,4 +23,6 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Communications :: Chat
 Requires-Python: >=3.14
 Requires-Dist: cfig[cli]>=0.3.10
+Requires-Dist: coloredlogs>=15.0.1
+Requires-Dist: fluent-runtime
 Requires-Dist: python-telegram-bot>=22.8

{threadkiller-3.0.3 → threadkiller-4.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "threadkiller"
-version = "3.0.3"
+version = "4.0.0"
 description = "Telegram bot to delete messages sent outside of threads"
 authors = [
 	{ name = "Stefano Pigozzi", email = "me@steffo.eu" },
@@ -33,6 +33,8 @@ requires-python = ">=3.14"
 dependencies = [
 	"python-telegram-bot>=22.8",
 	"cfig[cli]>=0.3.10",
+	"fluent-runtime", # From git
+	"coloredlogs>=15.0.1",
 ]
 
 [project.scripts]
@@ -49,6 +51,9 @@ Telegram = "https://t.me/the_threadkiller_bot?startgroup=yes"
 requires = ["hatchling"]
 build-backend = "hatchling.build"
 
+[tool.uv.sources]
+fluent-runtime = { git = "https://github.com/projectfluent/python-fluent", subdirectory = "fluent.runtime" }
+
 [[tool.uv.index]]
 name = "pypi"
 url = "https://upload.pypi.org/simple/"

threadkiller-4.0.0/threadkiller/__main__.py

@@ -0,0 +1,36 @@
+from asyncio import new_event_loop, set_event_loop
+from logging import getLogger
+
+from threadkiller.application import make_application
+from .config import config, TG_BOT_TOKEN
+from .log import install_logging
+from .metadata import set_commands
+
+log = getLogger(__name__)
+
+
+def main():
+    log.debug("Verifying configuration")
+    config.proxies.resolve()
+
+    log.debug("Initializing logging")
+    install_logging()
+
+    log.info("Initializing")
+
+    log.debug("Creating event loop")
+    loop = new_event_loop()
+    set_event_loop(loop)
+
+    log.debug("Creating application")
+    application = make_application(token=TG_BOT_TOKEN.__wrapped__)
+
+    log.debug("Registering commands")
+    loop.run_until_complete(set_commands(bot=application.bot))
+
+    log.info("Initializing updater")
+    application.run_polling()
+
+
+if __name__ == "__main__":
+    main()

threadkiller-4.0.0/threadkiller/application.py

@@ -0,0 +1,144 @@
+import logging
+
+from telegram.ext import ApplicationBuilder, MessageHandler, CommandHandler, Application, filters
+
+from . import handlers
+
+log = logging.getLogger(__name__)
+
+
+def make_application(token: str) -> Application:
+    """
+    Create the :class:`telegram.ext.Application` object powering the bot, and register all commands to it.
+
+    :param token: The bot token to use to authenticate to Telegram.
+    """
+    log.debug("Creating application")
+    application: Application = ApplicationBuilder().token(token).build()
+
+    log.debug("Registering start command for private chats")
+    # noinspection bad-argument-type
+    application.add_handler(
+        CommandHandler(
+            callback=handlers.on_command_start_private,
+            command="start",
+            filters=filters.ChatType.PRIVATE,
+            block=False,
+        )
+    )
+
+    log.debug("Registering start command for group chats")
+    # noinspection bad-argument-type
+    application.add_handler(
+        CommandHandler(
+            callback=handlers.on_command_start_group,
+            command="start",
+            filters=filters.ChatType.GROUPS,
+            block=False,
+        )
+    )
+
+    log.debug("Registering addtogroup command")
+    # noinspection bad-argument-type
+    application.add_handler(
+        CommandHandler(
+            callback=handlers.on_command_addtogroup,
+            command="addtogroup",
+            filters=filters.ChatType.PRIVATE,
+            block=False,
+        )
+    )
+
+    log.debug("Registering help command")
+    # noinspection bad-argument-type
+    application.add_handler(
+        CommandHandler(
+            callback=handlers.on_command_help,
+            command="help",
+            filters=filters.ChatType.PRIVATE,
+            block=False,
+        )
+    )
+
+    log.debug("Registering settings command")
+    # noinspection bad-argument-type
+    application.add_handler(
+        CommandHandler(
+            callback=handlers.on_command_settings,
+            command="settings",
+            filters=filters.ChatType.PRIVATE,
+            block=False,
+        )
+    )
+
+    log.debug("Registering settings command")
+    # noinspection bad-argument-type
+    application.add_handler(
+        CommandHandler(
+            callback=handlers.on_command_settings,
+            command="settings",
+            filters=filters.ChatType.PRIVATE,
+            block=False,
+        )
+    )
+
+    log.debug("Registering support command")
+    # noinspection bad-argument-type
+    application.add_handler(
+        CommandHandler(
+            callback=handlers.on_command_support,
+            command="support",
+            filters=filters.ChatType.PRIVATE,
+            block=False,
+        )
+    )
+
+    log.debug("Registering version command")
+    # noinspection bad-argument-type
+    application.add_handler(
+        CommandHandler(
+            callback=handlers.on_command_version,
+            command="version",
+            filters=filters.ChatType.PRIVATE,
+            block=False,
+        )
+    )
+
+    log.debug("Registering privacy command")
+    # noinspection bad-argument-type
+    application.add_handler(
+        CommandHandler(
+            callback=handlers.on_command_privacy,
+            command="privacy",
+            filters=filters.ChatType.PRIVATE,
+            block=False,
+        )
+    )
+
+    log.debug("Registering donate command")
+    # noinspection bad-argument-type
+    application.add_handler(
+        CommandHandler(
+            callback=handlers.on_command_donate,
+            command="donate",
+            filters=filters.ChatType.PRIVATE,
+            block=False,
+        )
+    )
+
+    log.debug("Registering group message handler")
+    # noinspection bad-argument-type
+    application.add_handler(
+        MessageHandler(
+            callback=handlers.on_message_group,
+            filters=~filters.REPLY & filters.ChatType.GROUPS & ~filters.User(user_id=777000) & ~filters.StatusUpdate.ALL & ~filters.COMMAND,
+            block=False,
+        )
+    )
+
+    return application
+
+
+__all__ = (
+    "make_application",
+)

threadkiller-4.0.0/threadkiller/config.py

@@ -0,0 +1,83 @@
+import cfig
+
+config = cfig.Configuration()
+
+
+@config.required()
+def TG_BOT_TOKEN(val: str) -> str:
+    """
+    Token used to authenticate as a Telegram bot.
+
+    Obtain one at https://t.me/BotFather .
+    """
+    return val
+
+
+@config.optional()
+def SUPPORT_GROUP_LINK(val: str | None) -> str | None:
+    """
+    Invite link to the bot's support group.
+
+    Displayed in /support.
+    """
+    return val
+
+
+@config.optional()
+def SUPPORT_EMAIL_RAW(val: str | None) -> str | None:
+    """
+    Email of the bot's owner, without `mailto:` prefix.
+
+    Displayed in /support.
+    """
+    return val
+
+
+@config.optional()
+def SUPPORT_OWNER_LINK(val: str | None) -> str | None:
+    """
+    t.me link of the bot's owner.
+
+    Displayed in /support.
+    """
+    return val
+
+
+@config.optional()
+def LINK_SOURCE(val: str | None) -> str:
+    """
+    Link to the bot's source code.
+
+    Displayed in /version.
+    """
+    if val is None:
+        return "https://g.starshard.space/steffo/threadkiller"
+    else:
+        return val
+
+
+@config.optional()
+def LINK_DONATE(val: str | None) -> str:
+    """
+    Link to the bot's source code.
+
+    Displayed in /version.
+    """
+    if val is None:
+        return "https://liberapay.com/Steffo/"
+    else:
+        return val
+
+
+__all__ = (
+    "config",
+    "TG_BOT_TOKEN",
+    "SUPPORT_GROUP_LINK",
+    "SUPPORT_EMAIL_RAW",
+    "SUPPORT_OWNER_LINK",
+    "LINK_SOURCE",
+    "LINK_DONATE",
+)
+
+if __name__ == "__main__":
+    config.cli()

threadkiller-4.0.0/threadkiller/handlers.py

@@ -0,0 +1,305 @@
+from importlib.metadata import version
+from logging import getLogger
+
+from fluent.runtime import FluentLocalization
+from telegram import Update, Chat, User, Message, error
+from telegram.constants import ParseMode
+from telegram.ext import CallbackContext
+
+from .config import SUPPORT_EMAIL_RAW, SUPPORT_GROUP_LINK, SUPPORT_OWNER_LINK, LINK_DONATE, LINK_SOURCE
+from .locale import localize
+
+log = getLogger(__name__)
+
+
+@localize
+async def on_command_start_private(update: Update, context: CallbackContext, *, locale: FluentLocalization) -> None:
+    """
+    Handler for the /start command.
+    """
+    log.debug("Handling /start in private chat")
+
+    # This invariant is covered by the application, before the handler is called
+    chat = update.effective_chat
+    assert isinstance(chat, Chat)
+
+    await chat.send_message(
+        text=locale.format_value("command-start-private-success", {
+            "bot-name": context.bot.username,
+        }),
+        parse_mode=ParseMode.HTML,
+    )
+
+
+@localize
+async def on_command_start_group(update: Update, context: CallbackContext, *, locale: FluentLocalization) -> None:
+    """
+    Handler for the /start command.
+    """
+    log.debug("Handling /start in group")
+
+    # These invariants are covered by the application, before the handler is called
+    chat = update.effective_chat
+    message = update.effective_message
+    sender = update.effective_sender
+    assert isinstance(chat, Chat)
+    assert isinstance(message, Message)
+    assert isinstance(sender, User)
+
+    await chat.send_message(
+        text=locale.format_value("command-start-group-success", {
+            "bot-name": context.bot.username,
+            "url-donate": LINK_DONATE.__wrapped__,
+        }),
+        parse_mode=ParseMode.HTML,
+    )
+
+
+@localize
+async def on_command_addtogroup(update: Update, context: CallbackContext, *, locale: FluentLocalization) -> None:
+    """
+    Handler for the /addtogroup command.
+    """
+    log.debug("Handling /addtogroup")
+
+    # These invariants are covered by the application, before the handler is called
+    chat = update.effective_chat
+    message = update.effective_message
+    sender = update.effective_sender
+    assert isinstance(chat, Chat)
+    assert isinstance(message, Message)
+    assert isinstance(sender, User)
+
+    await chat.send_message(
+        text=locale.format_value("command-addtogroup-success", {
+            "bot-name": context.bot.username,
+            "url-notify": f"https://t.me/{context.bot.username}?startgroup=yes&admin=anonymous",
+            "url-delete": f"https://t.me/{context.bot.username}?startgroup=yes&admin=anonymous+delete_messages",
+        }),
+        parse_mode=ParseMode.HTML,
+    )
+
+
+@localize
+async def on_command_help(update: Update, context: CallbackContext, *, locale: FluentLocalization) -> None:
+    """
+    Handler for the /help command.
+    """
+    log.debug("Handling /help")
+
+    # These invariants are covered by the application, before the handler is called
+    chat = update.effective_chat
+    message = update.effective_message
+    sender = update.effective_sender
+    assert isinstance(chat, Chat)
+    assert isinstance(message, Message)
+    assert isinstance(sender, User)
+
+    await chat.send_message(
+        text=locale.format_value("command-help-success", {
+            "bot-name": context.bot.username,
+        }),
+        parse_mode=ParseMode.HTML,
+    )
+
+
+@localize
+async def on_command_settings(update: Update, context: CallbackContext, *, locale: FluentLocalization) -> None:
+    """
+    Handler for the /settings command.
+    """
+    log.debug("Handling /settings")
+
+    # These invariants are covered by the application, before the handler is called
+    chat = update.effective_chat
+    message = update.effective_message
+    sender = update.effective_sender
+    assert isinstance(chat, Chat)
+    assert isinstance(message, Message)
+    assert isinstance(sender, User)
+
+    await chat.send_message(
+        text=locale.format_value("command-settings-success", {
+            "bot-name": context.bot.username,
+        }),
+        parse_mode=ParseMode.HTML,
+    )
+
+
+@localize
+async def on_command_support(update: Update, context: CallbackContext, *, locale: FluentLocalization) -> None:
+    """
+    Handler for the /support command.
+    """
+    log.debug("Handling /support")
+
+    # These invariants are covered by the application, before the handler is called
+    chat = update.effective_chat
+    message = update.effective_message
+    sender = update.effective_sender
+    assert isinstance(chat, Chat)
+    assert isinstance(message, Message)
+    assert isinstance(sender, User)
+
+    fluent_message = locale.format_message("command-support-success", {
+        "bot-name": context.bot.username,
+        "bot-group": SUPPORT_GROUP_LINK.__wrapped__ if SUPPORT_GROUP_LINK is not None else None,
+        "bot-email": SUPPORT_EMAIL_RAW.__wrapped__ if SUPPORT_EMAIL_RAW is not None else None,
+        "bot-owner": SUPPORT_OWNER_LINK.__wrapped__ if SUPPORT_OWNER_LINK is not None else None,
+    })
+
+    text = fluent_message.value
+    assert text is not None
+
+    if SUPPORT_GROUP_LINK:
+        text += "\n"
+        text += fluent_message.attributes["group"]
+
+    if SUPPORT_EMAIL_RAW:
+        text += "\n"
+        text += fluent_message.attributes["email"]
+
+    if SUPPORT_OWNER_LINK:
+        text += "\n"
+        text += fluent_message.attributes["owner"]
+
+    if not (SUPPORT_GROUP_LINK or SUPPORT_EMAIL_RAW or SUPPORT_OWNER_LINK):
+        text += "\n"
+        text += fluent_message.attributes["none"]
+
+    await chat.send_message(
+        text=text,
+        parse_mode=ParseMode.HTML,
+    )
+
+
+@localize
+async def on_command_version(update: Update, context: CallbackContext, *, locale: FluentLocalization) -> None:
+    """
+    Handler for the /version command.
+    """
+    log.debug("Handling /version")
+
+    # These invariants are covered by the application, before the handler is called
+    chat = update.effective_chat
+    message = update.effective_message
+    sender = update.effective_sender
+    assert isinstance(chat, Chat)
+    assert isinstance(message, Message)
+    assert isinstance(sender, User)
+
+    bot_software = "threadkiller"
+    bot_version = version(bot_software)
+
+    await chat.send_message(
+        text=locale.format_value("command-version-success", {
+            "bot-name": context.bot.username,
+            "bot-software": bot_software,
+            "bot-version": bot_version,
+            "url-source": LINK_SOURCE.__wrapped__,
+        }),
+        parse_mode=ParseMode.HTML,
+    )
+
+
+@localize
+async def on_command_privacy(update: Update, context: CallbackContext, *, locale: FluentLocalization) -> None:
+    """
+    Handler for the /privacy command.
+    """
+    log.debug("Handling /privacy")
+
+    # These invariants are covered by the application, before the handler is called
+    chat = update.effective_chat
+    message = update.effective_message
+    sender = update.effective_sender
+    assert isinstance(chat, Chat)
+    assert isinstance(message, Message)
+    assert isinstance(sender, User)
+
+    await chat.send_message(
+        text=locale.format_value("command-privacy-success", {
+            "bot-name": context.bot.username,
+            "url-telegram-api": "https://core.telegram.org/bots",
+        }),
+        parse_mode=ParseMode.HTML,
+    )
+
+
+@localize
+async def on_command_donate(update: Update, context: CallbackContext, *, locale: FluentLocalization) -> None:
+    """
+    Handler for the /donate command.
+    """
+    log.debug("Handling /donate")
+
+    # These invariants are covered by the application, before the handler is called
+    chat = update.effective_chat
+    message = update.effective_message
+    sender = update.effective_sender
+    assert isinstance(chat, Chat)
+    assert isinstance(message, Message)
+    assert isinstance(sender, User)
+
+    await chat.send_message(
+        text=locale.format_value("command-donate-success", {
+            "bot-name": context.bot.username,
+            "url-donate": LINK_DONATE.__wrapped__,
+        }),
+        parse_mode=ParseMode.HTML,
+    )
+
+
+@localize
+async def on_message_group(update: Update, context: CallbackContext, locale: FluentLocalization) -> None:
+    """
+    Handler for any message received in a group.
+    """
+    log.debug("Handling group message")
+
+    # These invariants are covered by the application, before the handler is called
+    chat = update.effective_chat
+    message = update.effective_message
+    sender = update.effective_sender
+    assert isinstance(chat, Chat)
+    assert isinstance(message, Message)
+    assert isinstance(sender, User)
+
+    await message.copy(
+        chat_id=chat.id,
+        api_kwargs=dict(
+            ephemeral_message_parameters=dict(
+                receiver_user_id=sender.id,
+            )
+        ),
+    )
+
+    try:
+        await message.delete()
+    except (error.Forbidden, error.BadRequest):
+        text = locale.format_value("message-notified")
+    else:
+        text = locale.format_value("message-deleted")
+
+    await chat.send_message(
+        text=text,
+        parse_mode=ParseMode.HTML,
+        api_kwargs=dict(
+            ephemeral_message_parameters=dict(
+                receiver_user_id=sender.id,
+            )
+        ),
+    )
+
+
+__all__ = (
+    "on_command_start_private",
+    "on_command_addtogroup",
+    "on_command_help",
+    "on_command_settings",
+    "on_command_support",
+    "on_command_version",
+    "on_command_privacy",
+    "on_command_donate",
+    "on_message_group",
+)