fix pixiv exception import

.dockerignore

@@ -27,5 +27,5 @@
 .python-version
 LICENSE
 README.md
-pers_data
+data/
 cert/

.github/workflows/docker.yml

@@ -4,6 +4,8 @@ on:
   push:
     tags:
       - v*
+    branches:
+      - master
 
 env:
   APP_NAME: telegram-twitter-media-bot
@@ -13,6 +15,17 @@ jobs:
   docker:
     runs-on: ubuntu-latest
     steps:
+      - name: Docker meta
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ env.DOCKERHUB_REPO }}
+          tags: |
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}.{{patch}}
+            type=semver,pattern={{major}}.{{minor}}
+            type=semver,pattern={{major}}
+            type=sha
       -
         name: Set up QEMU
         uses: docker/setup-qemu-action@v3
@@ -25,18 +38,12 @@ jobs:
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
-      - name: Generate APP Version
-        run: echo APP_VERSION=`git describe --tags --always` >> $GITHUB_ENV
       -
         name: Build and push
         uses: docker/build-push-action@v5
         with:
           push: true
-          platforms: |
-            linux/amd64
           build-args: |
             APP_NAME=${{ env.APP_NAME }}
-            APP_VERSION=${{ env.APP_VERSION }}
-          tags: |
-            ${{ env.DOCKERHUB_REPO }}:latest
-            ${{ env.DOCKERHUB_REPO }}:${{ env.APP_VERSION }}
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}

.gitignore

@@ -1,6 +1,13 @@
 **/.idea
 __pycache__/
 cert/
-pers_data
+data/
 docker-compose.yml
-x.py
+utils/x.py
+
+.env
+
+
+# Added by cargo
+
+/target

Dockerfile

@@ -1,4 +1,4 @@
-FROM python:3.12-slim-bullseye
+FROM python:3.13-slim-bullseye
 
 LABEL maintainer="admin@yoursfunny.top"
 
@@ -7,7 +7,7 @@ ENV PYTHONUNBUFFERED=1
 
 RUN set -eux; \
 	apt-get update; \
-	apt-get install -y gosu; \
+	apt-get install -y git gosu; \
 	rm -rf /var/lib/apt/lists/*; \
 # verify that the binary works
 	gosu nobody true

common.py

@@ -1,11 +1,19 @@
-import logging
-import re
 import os
 
-BOT_TOKEN = os.getenv("BOT_TOKEN")
-ADMIN = os.getenv("ADMIN").split(",")
+try:
+    import uvloop
+    import asyncio
 
-WEBHOOK = os.getenv("WEBHOOK", False)
+    asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
+except ImportError:
+    uvloop = None
+
+BOT_TOKEN = os.getenv("BOT_TOKEN")
+ADMIN = [int(i) for i in os.getenv("BOT_ADMIN", "").split(",") if i]
+
+PIXIV_REFRESH_TOKEN = os.getenv("PIXIV_REFRESH_TOKEN")
+
+WEBHOOK = os.getenv("WEBHOOK").strip().lower() in ("true", "yes", "1")
 if WEBHOOK:
     WEBHOOK_LISTEN = os.getenv("WEBHOOK_LISTEN", "0.0.0.0")
     WEBHOOK_PORT = int(os.getenv("WEBHOOK_PORT", 8443))
@@ -13,13 +21,3 @@ if WEBHOOK:
     WEBHOOK_KEY = os.getenv("WEBHOOK_KEY", "cert/private.key")
     WEBHOOK_CERT = os.getenv("WEBHOOK_CERT", "cert/cert.pem")
     WEBHOOK_SECRET_TOKEN = os.getenv("WEBHOOK_SECRET_TOKEN")
-
-x_url_regex = re.compile(r"^(?:https?://)(?:www\.|mobile\.|)(x|twitter)\.com/.+/status/(\d+)")
-x_media_regex = re.compile(r"^(?:https?://)(pbs|video)\.twimg\.com/(.*)")
-x_tco_regex = re.compile(r"(?:https?://)t\.co/.+$", re.M)
-
-logging.basicConfig(
-    level=os.getenv("LOG_LEVEL", "WARNING"),
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger(__name__)

docker-compose.yml.example

@@ -1,13 +1,13 @@
-version: '3.7'
 services:
   tgxmb: image: yoursfunny/telegram-twitter-media-bot: latest
     restart: always
-    ports:
-      - "8443:8443"
+#    ports:
+#      - "8443:8443"
     environment:
       LOCAL_USER_ID: '1000'
       BOT_TOKEN: ''
       BOT_ADMIN: ''
+      PIXIV_REFRESH_TOKEN: ''
       WEBHOOK: false
       WEBHOOK_LISTEN: '127.0.0.1'
       WEBHOOK_PORT: 8443
@@ -16,6 +16,7 @@ services:
       WEBHOOK_CERT: './cert/cert.pem'
       WEBHOOK_SECRET_TOKEN: 'secret-token'
 #      LOG_LEVEL: 'WARNING'
-#    volumes:
+volumes:
+      - ./data: /app/data
 #      - ./cert:/app/cert
     container_name: tgxmb

main.py

@@ -1,84 +1,264 @@
-from aiohttp import ClientSession
-from telegram import Update, Chat
-from telegram.constants import ParseMode, ChatAction
-from telegram.ext import (
-    Application,
-    ApplicationBuilder,
-    ContextTypes,
-    Defaults,
-    filters,
-    InlineQueryHandler,
-    PicklePersistence,
-    MessageHandler, CommandHandler
-)
+from __future__ import annotations
+
+import html
+from functools import wraps
+from typing import TYPE_CHECKING
+
+from telegram import InlineKeyboardButton, InlineKeyboardMarkup, MessageEntity
+from telegram.constants import ChatAction, ChatType, ParseMode
+from telegram.ext import (ApplicationBuilder, CallbackQueryHandler, CommandHandler, ContextTypes, Defaults,
+                          InlineQueryHandler, MessageHandler, PicklePersistence, filters)
 
 import common
-from tweet import TGTweet
+import utils.regex as regex
+from utils.context import ChatData, CustomContext, EditMessage
+from utils.logger import get_logger
+from utils.net import NetClient
+from utils.pixiv import ProcessPixiv
+from utils.telegram import Telegram
+
+if TYPE_CHECKING:
+    from telegram import Message, Update
+    from telegram.ext import Application
+
+logger = get_logger(__name__)
 
 
-async def inline_query(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+def send_action(action):
+    def decorator(func):
+        @wraps(func)
+        async def command_func(update: Update, context: CustomContext, *args, **kwargs):
+            try:
+                await update.effective_chat.send_action(action)
+            finally:
+                return await func(update, context, *args, **kwargs)
+
+        return command_func
+
+    return decorator
+
+
+def extract_urls(message: Message) -> set[str]:
+    types = [MessageEntity.URL, MessageEntity.TEXT_LINK]
+    res = message.parse_entities(types)
+    res.update(message.parse_caption_entities(types))
+    res.update({key: key.url for key in res if key.type == MessageEntity.TEXT_LINK})
+    return set(res.values())
+
+
+async def inline_query(update: Update, context: CustomContext) -> None:
     query = update.inline_query.query
     if query == "":
         return
-    async with TGTweet(context.bot_data['client'], query) as tweet:
-        result = list(tweet.inline_query_generator)
-        await update.inline_query.answer(result)
+    logger.info(f"Query: {query}")
+    async with Telegram(query) as tweet:
+        if not tweet:
+            return
+        await update.inline_query.answer(tweet.inline_query_result())
 
 
-async def reply_media(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
-    await update.effective_chat.send_action(ChatAction.UPLOAD_PHOTO)
-    # url = update.message.text.split(" ")[0]
-    url = update.message.text
-    async with TGTweet(context.bot_data['client'], url) as tweet:
-        media = list(tweet.pm_media_generator)
-        message_sent = await update.effective_message.reply_media_group(
-            media, caption=tweet.message_text,
-            # reply_to_message_id=update.message.message_id
-        )
-    if 'forward_channel_id' in context.user_data:
-        try:
-            await update.effective_chat.copy_messages(
-                chat_id=context.user_data['forward_channel_id'],
-                message_ids=[m.id for m in message_sent],
+@send_action(ChatAction.UPLOAD_PHOTO)
+async def url_media(update: Update, context: CustomContext, url: str) -> None:
+    async with Telegram(url) as tweet:
+        if not tweet:
+            return
+        media = tweet.message_media_result()
+        if not media:
+            await update.effective_message.reply_text(
+                "No media found or media type is not supported.",
+                reply_to_message_id=update.message.message_id,
             )
-        except Exception as e:
-            await update.effective_message.reply_text(str(e))
+            return
+        message_to_send = await update.effective_message.reply_media_group(
+            media,
+            caption=tweet.message_text,
+            reply_to_message_id=update.message.message_id,
+        ) if not isinstance(media[0], tuple) else await update.effective_message.reply_animation(
+            media[0][0],
+            caption=tweet.message_text,
+            reply_to_message_id=update.message.message_id,
+            has_spoiler=media[0][1]
+        )
+        if not isinstance(message_to_send, tuple):
+            message_to_send = (message_to_send,)
+        url = tweet.url
+    if context.chat_data.edit_before_forward:
+        message_reply = await update.effective_message.reply_text(
+            "Reply to edit message.",
+            reply_markup=InlineKeyboardMarkup.from_column(
+                [InlineKeyboardButton(name, callback_data=f"template|{name}") for name in
+                 context.chat_data.template.keys()] + [InlineKeyboardButton("↩️ Confirm", callback_data="forward")]
+            ),
+            reply_to_message_id=update.message.message_id,
+        )
+        context.chat_data.edit_message[message_reply.id] = EditMessage(
+            url=url,
+            forward=message_to_send
+        )
+        return
+    if context.chat_data.forward_channel_id:
+        await forward_message(update, context, message_to_send)
 
 
-async def cmd_set_forward_channel(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
-    await update.effective_chat.send_action(ChatAction.TYPING)
+async def handel_url_media(update: Update, context: CustomContext) -> None:
+    url = update.message.text
+    logger.info(f"Receiving url: {url}")
+    await url_media(update, context, url)
+
+
+async def forward_message(
+        update: Update,
+        context: CustomContext,
+        message_to_send: tuple[Message, ...],
+) -> None:
+    try:
+        await update.effective_chat.copy_messages(
+            context.chat_data.forward_channel_id,
+            [m.id for m in message_to_send]
+        )
+    except Exception as e:
+        await update.effective_message.reply_text(str(e))
+
+
+async def edit_message(update: Update, context: CustomContext) -> bool:
+    if not (reply := update.message.reply_to_message):
+        return False
+    _edit_message = context.chat_data.edit_message.get(reply.id, None)
+    if not _edit_message:
+        return False
+    new_text = '<a href="{0}">{1}</a>'.format(
+        _edit_message.url,
+        html.escape(update.message.text)
+    )
+    update_text = context.chat_data.template[template].replace("[]", new_text) if (
+        template := _edit_message.template) else new_text
+    await _edit_message.forward[0].edit_caption(update_text)
+    return True
+
+
+async def handle_message(update: Update, context: CustomContext) -> None:
+    if await edit_message(update, context):
+        return
+    if not (urls := extract_urls(update.message)):
+        return
+    for url in urls:
+        await url_media(update, context, url)
+
+
+async def query_forward_message(update: Update, context: CustomContext) -> None:
+    _edit_message = context.chat_data.edit_message[update.effective_message.id]
+    await forward_message(update, context, _edit_message.forward)
+    await update.callback_query.answer('✅ Forwarded')
+    await update.callback_query.delete_message()
+    del _edit_message
+
+
+async def query_template(update: Update, context: CustomContext) -> None:
+    query = update.callback_query
+    await query.answer()
+    name = query.data.split("|")[1]
+    _edit_message = context.chat_data.edit_message[query.message.message_id]
+    _edit_message.template = name
+    await _edit_message.forward[0].edit_caption(context.chat_data.template[name])
+
+
+@send_action(ChatAction.TYPING)
+async def cmd_start(update: Update, context: CustomContext) -> None:
+    await update.effective_message.reply_text(
+        "Welcome to the Twitter Fetcher Bot!\n"
+        "You can use this bot to fetch tweets from Twitter and forward them to a channel.\n"
+        "Use /set_forward_channel to set a channel to forward tweets.\n"
+        "Use /remove_forward_channel to remove the channel.\n"
+        "Use /edit_before_forward to enable or disable edit before forward.\n"
+        "Use /set_template to set a template for the forwarded message.\n"
+        "Use /bot_dict to see the bot's data.\n"
+        "Use /clear_edit_message to clear the edit message cache.\n"
+        "You can also reply to a message with a tweet URL to fetch the tweet and forward it to the channel.\n"
+        "You can also use inline query to search for tweets."
+    )
+
+
+@send_action(ChatAction.TYPING)
+async def cmd_set_forward_channel(update: Update, context: CustomContext) -> None:
     if not context.args:
         await update.effective_message.reply_text("Please provide a channel username or id.")
         return
     channel = context.args[0]
     try:
-        channel: Chat = context.bot.get_chat(channel)
+        channel = await context.bot.get_chat(channel)
     except Exception as e:
         await update.effective_message.reply_text(str(e))
         return
-    if channel.type != "CHANNEL":
+    if channel.type != ChatType.CHANNEL:
         await update.effective_message.reply_text("That is not a channel.")
         return
-    channel_admin = await channel.get_administrators()
+    try:
+        channel_admin = await channel.get_administrators()
+    except Exception as e:
+        await update.effective_message.reply_text(str(e) + "\nPlease add the bot to the channel and set as admin")
+        return
+    user = filter(lambda x: x.user.id == update.effective_user.id, channel_admin)
+    user = next(user, None)
+    if not user:
+        await update.effective_message.reply_text("You are not an admin of the channel.")
+        return
     user_bot = filter(lambda x: x.user.id == context.bot.id, channel_admin)
     user_bot = next(user_bot, None)
-    if not user_bot:
-        await update.effective_message.reply_text("I am not an admin in that channel.")
-        return
     if user_bot.can_post_messages:
-        context.user_data['forward_channel_id'] = channel.id
+        context.chat_data.forward_channel_id = channel.id
         await update.effective_message.reply_text("Add successfully.")
 
 
-async def cmd_remove_forward_channel(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
-    await update.effective_chat.send_action(ChatAction.TYPING)
-    if 'forward_channel_id' in context.user_data:
-        del context.user_data['forward_channel_id']
+@send_action(ChatAction.TYPING)
+async def cmd_remove_forward_channel(update: Update, context: CustomContext) -> None:
+    if context.chat_data.forward_channel_id:
+        context.chat_data.forward_channel_id = None
         await update.effective_message.reply_text("Remove successfully.")
         return
     await update.effective_message.reply_text("No channel to remove.")
 
 
+@send_action(ChatAction.TYPING)
+async def cmd_edit_before_forward(update: Update, context: CustomContext) -> None:
+    if context.chat_data.forward_channel_id is None:
+        await update.effective_message.reply_text("Please enable forward channel first.")
+        return
+    if context.chat_data.edit_before_forward:
+        context.chat_data.edit_before_forward = False
+        context.chat_data.edit_message.clear()
+        await update.effective_message.reply_text("Disable edit before forward.")
+        return
+    context.chat_data.edit_before_forward = True
+    await update.effective_message.reply_text("Enable edit before forward.")
+
+
+@send_action(ChatAction.TYPING)
+async def cmd_set_template(update: Update, context: CustomContext) -> None:
+    reply = update.effective_message.reply_to_message
+    if not reply:
+        await update.effective_message.reply_text("Please reply to a message to set as template.")
+        return
+    if '[]' not in (template := reply.text_html):
+        await update.effective_message.reply_text("Please reply to a message with [] to set as template.")
+        return
+    if not context.args:
+        await update.effective_message.reply_text("Please provide a name for the template.")
+        return
+    context.chat_data.template[''.join(context.args)] = template
+    await update.effective_message.reply_text("Template set.")
+
+
+@send_action(ChatAction.TYPING)
+async def cmd_user_dict(update: Update, context: CustomContext) -> None:
+    await update.effective_message.reply_text(html.escape(str(context.chat_data)), disable_web_page_preview=True)
+
+
+@send_action(ChatAction.TYPING)
+async def cmd_clear_edit_message(update: Update, context: CustomContext) -> None:
+    context.chat_data.edit_message.clear()
+    await update.effective_message.reply_text("Edit message cleared.")
+
+
 async def post_init(application: Application) -> None:
     # commands = [
     #     BotCommand('start', CMD_START),
@@ -87,42 +267,54 @@ async def post_init(application: Application) -> None:
     DESCRIPTION = "A bot to fetch tweets from Twitter."
     await application.bot.set_my_description(DESCRIPTION)
     await application.bot.set_my_short_description(DESCRIPTION)
-    application.bot_data['client'] = ClientSession()
+    NetClient.init_client()
+    if common.PIXIV_REFRESH_TOKEN:
+        await ProcessPixiv.init_client(common.PIXIV_REFRESH_TOKEN)
 
 
 async def post_stop(application: Application) -> None:
-    await application.bot.send_message(common.ADMIN[0], "Shutting down...")
+    if common.ADMIN:
+        await application.bot.send_message(common.ADMIN[0], "Shutting down...")
 
 
 async def post_shutdown(application: Application) -> None:
-    await application.bot_data['client'].close()
+    await NetClient.close_client()
 
 
 def main():
     defaults = Defaults(parse_mode=ParseMode.HTML, allow_sending_without_reply=True)
-    persistence = PicklePersistence(filepath='pers_data')
-    # proxy_url = 'http://127.0.0.1:10809'
+    persistence = PicklePersistence(filepath='data/pers.pkl')
     application = (ApplicationBuilder()
                    .token(common.BOT_TOKEN)
                    .defaults(defaults)
                    .persistence(persistence)
+                   .context_types(ContextTypes(context=CustomContext, chat_data=ChatData))
                    .post_init(post_init)
                    .post_stop(post_stop)
                    .post_shutdown(post_shutdown)
-                   # .proxy(proxy_url)
-                   # .get_updates_proxy(proxy_url)
+                   .concurrent_updates(True)
+                   .http_version('2')
                    .build()
                    )
 
-    # user_filter = filters.User()
-    # user_filter.add_user_ids(common.admin)
+    user_filter = filters.User()
+    user_filter.add_user_ids(common.ADMIN)
 
     handlers = [
-        MessageHandler(filters.Regex(common.x_url_regex) & filters.ChatType.PRIVATE, reply_media),
-        # MessageHandler(None, reply_media),
-        InlineQueryHandler(inline_query, common.x_url_regex),
+        InlineQueryHandler(inline_query),
+        MessageHandler((filters.Regex(regex.x_url) | filters.Regex(regex.pixiv_url)) | filters.Regex(
+            regex.bsky_url) & filters.ChatType.PRIVATE,
+                       handel_url_media),
+        CommandHandler("start", cmd_start),
         CommandHandler("set_forward_channel", cmd_set_forward_channel),
         CommandHandler("remove_forward_channel", cmd_remove_forward_channel),
+        CommandHandler("edit_before_forward", cmd_edit_before_forward),
+        CommandHandler("set_template", cmd_set_template),
+        MessageHandler(~filters.COMMAND & filters.ChatType.PRIVATE, handle_message),
+        CallbackQueryHandler(query_forward_message, pattern="forward"),
+        CallbackQueryHandler(query_template, pattern=r"^template\|"),
+        CommandHandler("bot_dict", cmd_user_dict),
+        CommandHandler("clear_edit_message", cmd_clear_edit_message),
     ]
 
     application.add_handlers(handlers)

requirements.txt

@@ -1,2 +1,4 @@
-python-telegram-bot[webhooks]~=21.0.1
-aiohttp[speedups]~=3.9.3
+python-telegram-bot[webhooks]~=22.8
+httpx[http2]~=0.27
+uvloop~=0.22; sys_platform != 'win32'
+async-pixiv~=1.1.2

tweet.py

@@ -1,201 +0,0 @@
-from typing import Generator
-
-from aiohttp import ClientSession
-from telegram import (
-    InlineQueryResultPhoto,
-    InlineQueryResultVideo,
-    InputMediaPhoto,
-    InputMediaVideo
-)
-from common import x_url_regex, x_media_regex, x_tco_regex
-
-twimg_url = 'https://pbs.twimg.com/'
-vx_api_url = 'https://api.vxtwitter.com/status/'
-
-message_raw_text = """{url}
-<a href="{author_url}">{author}</a>: {text}
-"""
-
-
-async def fetch_json(session: ClientSession, url: str) -> dict:
-    async with session.get(url) as response:
-        assert response.status == 200
-        return await response.json()
-
-
-class TweetMedia:
-    def __init__(self, url: str, thumb: str, media_type: str):
-        self._url: str = url
-        self._thumb: str = thumb
-        self._type: str = media_type
-
-    @property
-    def _uri(self) -> str | None:
-        match = x_media_regex.match(self._url)
-        if match:
-            return match.group(2).removesuffix('.jpg')
-        return None
-
-    @property
-    def url(self) -> str:
-        match self._type:
-            case "image":
-                return f"{twimg_url}{self._uri}?format=jpg&name=orig"
-            case "video":
-                return self._url
-
-    @property
-    def thumb(self) -> str:
-        match self._type:
-            case "image":
-                return f"{twimg_url}{self._uri}?format=jpg&name=thumb"
-            case "video":
-                return self._thumb
-
-    @property
-    def type(self) -> str:
-        return self._type
-
-
-class Tweet:
-    def __init__(
-            self,
-            tweet_id: str,
-            author: str,
-            author_id: str,
-            text: str,
-            media: list[TweetMedia],
-            sensitive: bool = False
-    ):
-        self._id: str = tweet_id
-        self._author: str = author
-        self._author_id: str = author_id
-        self._text: str = text
-        self._media: list[TweetMedia] = media
-        self._sensitive: bool = sensitive
-
-    @property
-    def id(self) -> str:
-        return self._id
-
-    @property
-    def url(self) -> str:
-        return f"https://twitter.com/{self._author_id}/status/{self._id}"
-
-    @property
-    def author(self) -> str:
-        return self._author
-
-    @property
-    def author_url(self) -> str:
-        return f"https://twitter.com/{self._author_id}"
-
-    @property
-    def text(self) -> str:
-        return self._text
-
-    @property
-    def media(self) -> list[TweetMedia]:
-        return self._media
-
-    @property
-    def sensitive(self) -> bool:
-        return self._sensitive
-
-
-class TGTweet(Tweet):
-    def __init__(self, session: ClientSession, url: str):
-        self._session: ClientSession = session
-        self._url: str = url
-        self._id: str = self._tweet_id
-        assert self._id
-
-    async def __aenter__(self):
-        self._tweet: dict = await self._fetch_tweet(self._id)
-        super().__init__(*self._init_properties)
-        return self
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        pass
-
-    async def _fetch_tweet(self, tweet_id: str) -> dict:
-        return await fetch_json(self._session, vx_api_url + tweet_id)
-
-    @property
-    def _tweet_id(self) -> str | None:
-        match = x_url_regex.match(self._url)
-        if match:
-            return match.group(1).strip('/')
-        return None
-
-    @property
-    def _tweet_text(self) -> str:
-        match = x_tco_regex.search(self._tweet['text'])
-        return self._tweet['text'][:match.start()].strip(" ") if match else self._tweet['text']
-
-    @property
-    def _tweet_media(self) -> list[TweetMedia]:
-        return [
-            TweetMedia(
-                url=x['url'],
-                thumb=x['thumbnail_url'],
-                media_type=x['type']
-            )
-            for x in self._tweet['media_extended']
-        ]
-
-    @property
-    def _init_properties(self) -> tuple:
-        author = self._tweet['user_name']
-        author_id = self._tweet['user_screen_name']
-        text = self._tweet_text
-        media = self._tweet_media
-        sensitive = self._tweet['possibly_sensitive']
-        return self._id, author, author_id, text, media, sensitive
-
-    @property
-    def message_text(self) -> str:
-        return message_raw_text.format(
-            url=self.url,
-            author_url=self.author_url,
-            author=self.author,
-            text=self.text
-        )
-
-    @property
-    def inline_query_generator(self) -> Generator[InlineQueryResultPhoto | InlineQueryResultVideo, None, None]:
-        for i, tweet_media in enumerate(self.media):
-            if tweet_media.type == "image":
-                yield InlineQueryResultPhoto(
-                    id=self.id,
-                    photo_url=tweet_media.url,
-                    thumbnail_url=tweet_media.thumb,
-                    title=self.url,
-                    description=self.text,
-                    caption=self.message_text if not i else None
-                )
-            elif tweet_media.type == "video":
-                yield InlineQueryResultVideo(
-                    id=self.id,
-                    video_url=tweet_media.url,
-                    mime_type="video/mp4",
-                    thumbnail_url=tweet_media.thumb,
-                    title=self.url,
-                    description=self.text,
-                    caption=self.message_text if not i else None
-                )
-
-    @property
-    def pm_media_generator(self) -> Generator[InputMediaPhoto | InputMediaVideo, None, None]:
-        for tweet_media in self.media:
-            if tweet_media.type == "image":
-                yield InputMediaPhoto(
-                    media=tweet_media.url,
-                    has_spoiler=self.sensitive
-                )
-            elif tweet_media.type == "video":
-                yield InputMediaVideo(
-                    media=tweet_media.url,
-                    has_spoiler=self.sensitive,
-                    thumbnail=tweet_media.thumb
-                )

utils/bsky.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+from functools import cached_property
+from typing import TYPE_CHECKING
+
+from utils.net import NetClient
+from utils.regex import bsky_url
+
+if TYPE_CHECKING:
+    from utils.types import BskyEmbedImages, BskyInfo, BskyEmbedVideo, BskyEmbedExternal
+
+bsky_api_url = 'https://public.api.bsky.app/xrpc/app.bsky.feed.getPostThread'
+
+SENSITIVE_TAG = {'sexual', 'nudity', 'porn', 'graphic-media'}
+
+class BskyMedia:
+    __slots__ = ('_url', '_thumb', '_type', '__dict__')
+
+    def __init__(self, url: str, thumb: str, media_type: str):
+        self._url: str = url
+        self._thumb: str = thumb
+        self._type: str = media_type
+
+    def __str__(self):
+        return f"BskyMedia(url={self.url}, thumb={self.thumb}, type={self.type})"
+
+    @property
+    def url(self) -> str:
+        return self._url
+
+    @property
+    def thumb(self) -> str:
+        return self._thumb
+
+    @property
+    def type(self) -> str:
+        return self._type
+
+
+class Bsky:
+    __slots__ = ('_id', '_author', '_author_id', '_text', '_media', '_sensitive', '__dict__')
+
+    def __init__(
+            self,
+            id: str,
+            author: str,
+            author_id: str,
+            text: str,
+            media: list[BskyMedia],
+            sensitive: bool = False
+    ):
+        self._id: str = id
+        self._author: str = author
+        self._author_id: str = author_id
+        self._text: str = text
+        self._media: list[BskyMedia] = media
+        self._sensitive: bool = sensitive
+
+    @property
+    def id(self) -> str:
+        return self._id
+
+    @cached_property
+    def url(self) -> str:
+        return f"https://bsky.app/profile/{self._author_id}/post/{self._id}"
+
+    @property
+    def author(self) -> str:
+        return self._author
+
+    @cached_property
+    def author_url(self) -> str:
+        return f"https://bsky.app/profile/{self._author_id}"
+
+    @property
+    def text(self) -> str:
+        return self._text
+
+    @property
+    def media(self) -> list[BskyMedia]:
+        return self._media
+
+    @property
+    def sensitive(self) -> bool:
+        return self._sensitive
+
+
+class ProcessBsky:
+    __slots__ = ('_url', '_id', '_bsky')
+
+    def __init__(self, url: str):
+        self._url: str = url
+
+    async def __aenter__(self):
+        bsky = await self._fetch_bsky()
+        if not bsky['thread'].get('post'):
+            raise ValueError(f"BSky post not found: {bsky}")
+        self._bsky = bsky['thread']['post']
+        return Bsky(
+            id=self._id,
+            author=self._bsky['author']['displayName'],
+            author_id=self._bsky['author']['handle'],
+            text=self._bsky['record']['text'],
+            media=self._bsky_media,
+            sensitive=self._sensitive
+        )
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        pass
+
+    async def _fetch_bsky(self) -> BskyInfo:
+        match = bsky_url.match(self._url)
+        if not match:
+            raise ValueError(f"Invalid Bsky URL: {self._url}")
+        auther_id, self._id = match.groups()
+        return await NetClient.fetch_json(
+            bsky_api_url,
+            params={'uri': f'at://{auther_id}/app.bsky.feed.post/{self._id}', 'depth': 0}
+        )
+
+    @property
+    def _bsky_media(self) -> list[BskyMedia]:
+        if not self._bsky.get('embed'):
+            return []
+        match (embed := self._bsky['embed'])['$type']:
+            case 'app.bsky.embed.images#view':
+                embed: BskyEmbedImages
+                return [
+                    BskyMedia(
+                        url=image['fullsize'],
+                        thumb=image['thumb'],
+                        media_type='image'
+                    )
+                    for image in embed['images']
+                ]
+            case 'app.bsky.embed.video#view':
+                embed: BskyEmbedVideo
+                return [
+                    BskyMedia(
+                        url=embed['playlist'],
+                        thumb=embed['thumbnail'],
+                        media_type='video'
+                    )
+                ]
+            case 'app.bsky.embed.external#view':
+                embed: BskyEmbedExternal
+                return [
+                    BskyMedia(
+                        url=embed['external']['uri'],
+                        thumb=embed['external']['thumb'],
+                        media_type='external'
+                    )
+                ]
+            case _:
+                raise NotImplementedError(f"Unknown Bsky embed type: {embed['$type']}")
+
+    @property
+    def _sensitive(self) -> bool:
+        return any(
+            tag in label['val']
+            for label in self._bsky['labels']
+            for tag in SENSITIVE_TAG
+        )

utils/context.py

@@ -0,0 +1,42 @@
+import dataclasses
+from typing import Optional
+
+from telegram import Message
+from telegram.ext import Application, CallbackContext, ExtBot
+
+
+@dataclasses.dataclass(repr=False)
+class EditMessage:
+    url: str
+    forward: tuple[Message, ...]
+    template: str = ""
+
+    def __str__(self):
+        forward = ", ".join(f"Message({f.id})" for f in self.forward)
+        return f"EditMessage(url={self.url}, forward={forward}, template={self.template})"
+
+    __repr__ = __str__
+
+
+class ChatData:
+    def __init__(self):
+        self.forward_channel_id: Optional[int] = None
+        self.edit_before_forward: bool = False
+        self.edit_message: dict[int, EditMessage] = {}
+        self.template: dict[str, str] = {}
+
+    def __str__(self):
+        return f"ChatData(forward_channel_id={self.forward_channel_id}, edit_before_forward={self.edit_before_forward}, " \
+               f"edit_message={self.edit_message}, template={self.template})"
+
+    __repr__ = __str__
+
+
+class CustomContext(CallbackContext[ExtBot, dict, ChatData, dict]):
+    def __init__(
+            self,
+            application: Application,
+            chat_id: Optional[int] = None,
+            user_id: Optional[int] = None
+    ):
+        super().__init__(application=application, chat_id=chat_id, user_id=user_id)

utils/logger.py

@@ -0,0 +1,11 @@
+import logging
+import os
+
+logging.basicConfig(
+    level=os.getenv("LOG_LEVEL", "WARNING"),
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+
+
+def get_logger(name: str) -> logging.Logger:
+    return logging.getLogger(name)

utils/net.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from httpx import AsyncClient
+
+
+def create_client() -> AsyncClient:
+    return AsyncClient(http2=True)
+
+
+async def close_client(_client: AsyncClient) -> None:
+    return await _client.aclose()
+
+
+async def fetch_json(_client: AsyncClient, url: str, params: dict = None) -> dict:
+    response = await _client.get(url, params=params)
+    assert response.is_success, f"Failed to fetch {url}, status code {response.status_code}"
+    return response.json()
+
+
+class NetClient:
+    _httpx_client: AsyncClient
+
+    @classmethod
+    def init_client(cls) -> None:
+        cls._httpx_client = create_client()
+
+    @classmethod
+    async def close_client(cls) -> None:
+        await close_client(cls._httpx_client)
+
+    @classmethod
+    def get_client(cls) -> AsyncClient:
+        return cls._httpx_client
+
+    @classmethod
+    async def fetch_json(cls, url: str, params: dict = None) -> dict:
+        return await fetch_json(cls._httpx_client, url, params)

utils/pixiv.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+from typing import Literal, TYPE_CHECKING
+
+from async_pixiv import PixivClient
+from async_pixiv.error import APIError
+
+if TYPE_CHECKING:
+    from async_pixiv.model.illust import Illust
+
+
+class PixivMedia:
+    __slots__ = ('_url', '_thumb')
+
+    def __init__(self, url: str, thumb: str):
+        self._url: str = url
+        self._thumb: str = thumb
+
+    def __str__(self):
+        return f"PixivMedia(url={self.url}, thumb={self.thumb}, large={self.large})"
+
+    @property
+    def url(self) -> str:
+        return self._url
+
+    @property
+    def thumb(self) -> str:
+        return self._thumb
+
+    @property
+    def large(self) -> str:
+        url = self._url.replace("img-original", "img-master").removesuffix(".jpg").removesuffix(".png")
+        return url + "_master1200.jpg"
+
+
+class Pixiv:
+    __slots__ = ('_illust',)
+
+    def __init__(self, illust: Illust):
+        self._illust: Illust = illust
+
+    @property
+    def url(self) -> str:
+        return str(self._illust.link).rstrip('/')
+
+    @property
+    def type(self) -> Literal["illust", "manga", "ugoira"]:
+        return self._illust.type.value
+
+    @property
+    def title(self) -> str:
+        return self._illust.title
+
+    @property
+    def author(self) -> str:
+        return self._illust.user.name
+
+    @property
+    def author_url(self) -> str:
+        return str(self._illust.user.link).rstrip('/')
+
+    @property
+    def description(self) -> str:
+        return self._illust.caption
+
+    @property
+    def tags(self) -> list[str]:
+        return [tag.name for tag in self._illust.tags]
+
+    @property
+    def is_multiple_pages(self) -> bool:
+        return self._illust.page_count > 1
+
+    @property
+    def is_nsfw(self) -> bool:
+        return self._illust.is_nsfw
+
+    @property
+    def is_ai(self) -> bool:
+        return self._illust.ai_type.value == 2
+
+    @property
+    def images(self) -> list[PixivMedia]:
+        if self.is_multiple_pages:
+            return [
+                PixivMedia(
+                    url=page.image_urls.original,
+                    thumb=page.image_urls.medium
+                )
+                for page in self._illust.meta_pages
+            ]
+        else:
+            return [
+                PixivMedia(  # should observe if image_url.original is always None for single page
+                    url=self._illust.image_urls.original or self._illust.meta_single_page.original,
+                    thumb=self._illust.image_urls.medium
+                )
+            ]
+
+
+class _ProcessPixiv:
+    _client: PixivClient
+
+    @classmethod
+    async def init_client(cls, token: str) -> None:
+        cls._client = PixivClient()
+        await cls._client.login_with_token(token)
+        cls._token = token
+
+    @classmethod
+    async def close_client(cls) -> None:
+        await cls._client.close()
+
+    @classmethod
+    async def refresh_token(cls):
+        await cls._client.login_with_token(cls._token)
+
+
+class ProcessPixiv(_ProcessPixiv):
+    __slots__ = ('_url', '_illust')
+
+    def __init__(self, url: str):
+        self._url: str = url
+
+    async def __aenter__(self):
+        self._illust = await self._fetch_illust()
+        return Pixiv(self._illust)
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        pass
+
+    async def _fetch_illust(self) -> Illust:
+        illust_id = self._parse_illust_id()
+        try:
+            return (await self._client.ILLUST.detail(illust_id)).illust
+        except APIError:
+            await self.refresh_token()
+            return (await self._client.ILLUST.detail(illust_id)).illust  # TODO use retry here
+
+    def _parse_illust_id(self) -> int:
+        return int(self._url.split("/")[-1])

utils/regex.py

@@ -0,0 +1,11 @@
+import re
+
+x_url = re.compile(
+    r"^(?:https?://)?(?:www\.|mobile\.)?(?:x|twitter|fixvx|vxtwitter|fixupx|fxtwitter)\.com/(.+)/status/(\d+)")
+x_media_url = re.compile(r"^(?:https?://)?(pbs|video)\.twimg\.com/(.*)")
+x_tco_url = re.compile(r"(?:https?://)?t\.co/.+$", re.M)
+message_url = re.compile(r"\[.+]", re.S)
+
+pixiv_url = re.compile(r"^(?:https?://)?(?:www\.)?pixiv\.net/(?:en/)?(?:artworks/|i/)(\d+)")
+
+bsky_url = re.compile(r"^(?:https?://)?bsky\.app/profile/(.+)/post/(.+)")

utils/telegram.py

@@ -0,0 +1,288 @@
+from __future__ import annotations
+
+import html
+from functools import cached_property
+from typing import Generator, TYPE_CHECKING
+from uuid import uuid4
+
+from telegram import InlineQueryResultMpeg4Gif, InlineQueryResultPhoto, InlineQueryResultVideo, InputMediaPhoto, \
+    InputMediaVideo
+
+from common import PIXIV_REFRESH_TOKEN
+from .bsky import ProcessBsky
+from .logger import get_logger
+from .pixiv import ProcessPixiv
+from .regex import bsky_url, pixiv_url, x_url
+from .tweet import ProcessTweet
+
+if TYPE_CHECKING:
+    from .types import TypeInlineQueryResult, TypeMessageMediaResult
+
+logger = get_logger(__name__)
+
+message_raw_text_tweet = """{url}
+<a href="{author_url}">{author}</a>: {text}
+"""
+
+message_raw_text_pixiv = """<a href="{url}">{text}</a> / <a href="{author_url}">{author}</a>
+{tags}
+"""
+
+
+class Telegram:
+    def __init__(self, url: str):
+        self._url = url
+
+    async def __aenter__(self):
+        if x_url.match(self._url):
+            async with TelegramTweet(self._url) as tweet:
+                return tweet
+        elif PIXIV_REFRESH_TOKEN and pixiv_url.match(self._url):
+            async with TelegramPixiv(self._url) as pixiv:
+                return pixiv
+        elif bsky_url.match(self._url):
+            async with TelegramBsky(self._url) as bsky:
+                return bsky
+        else:
+            return None  # TODO add raise and catch
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        pass
+
+
+class TelegramTweet:
+    message_raw_text = message_raw_text_tweet
+    __slots__ = ('_url', '_tweet', '__dict__')
+
+    def __init__(self, url: str):
+        self._url: str = url
+
+    async def __aenter__(self):
+        async with ProcessTweet(self._url) as tweet:
+            self._tweet = tweet
+            return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        pass
+
+    @property
+    def url(self) -> str:
+        return self._tweet.url
+
+    @cached_property
+    def message_text(self) -> str:
+        tweet = self._tweet
+        return self.message_raw_text.format(
+            url=tweet.url,
+            author_url=tweet.author_url,
+            author=html.escape(tweet.author),
+            text=html.escape(tweet.text)
+        )
+
+    def inline_query_result(self) -> tuple[TypeInlineQueryResult, ...]:
+        return tuple(self.inline_query_generator())
+
+    def message_media_result(self) -> tuple[TypeMessageMediaResult, ...]:
+        return tuple(self.message_media_generator())
+
+    def inline_query_generator(self) -> Generator[TypeInlineQueryResult, None, None]:
+        tweet = self._tweet
+        for tweet_media in tweet.media:
+            logger.info(str(tweet_media))
+            if tweet_media.type == "image":
+                yield InlineQueryResultPhoto(
+                    id=str(uuid4()),
+                    photo_url=tweet_media.url,
+                    thumbnail_url=tweet_media.thumb,
+                    caption=self.message_text
+                )
+            elif tweet_media.type == "video":
+                yield InlineQueryResultVideo(
+                    id=str(uuid4()),
+                    video_url=tweet_media.url,
+                    mime_type="video/mp4",
+                    thumbnail_url=tweet_media.thumb,
+                    title=tweet.text,
+                    caption=self.message_text
+                )
+            elif tweet_media.type == "gif":
+                yield InlineQueryResultMpeg4Gif(
+                    id=str(uuid4()),
+                    mpeg4_url=tweet_media.url,
+                    thumbnail_url=tweet_media.thumb,
+                    caption=self.message_text
+                )
+
+    def message_media_generator(self) -> Generator[TypeMessageMediaResult, None, None]:
+        tweet = self._tweet
+        for tweet_media in tweet.media:
+            logger.info(str(tweet_media))
+            if tweet_media.type == "image":
+                yield InputMediaPhoto(
+                    media=tweet_media.url,
+                    has_spoiler=tweet.sensitive
+                )
+            elif tweet_media.type == "video":
+                yield InputMediaVideo(
+                    media=tweet_media.url,
+                    has_spoiler=tweet.sensitive,
+                    thumbnail=tweet_media.thumb
+                )
+            elif tweet_media.type == "gif":
+                if len(tweet.media) == 1:
+                    yield tweet_media.url, tweet.sensitive
+                yield InputMediaVideo(
+                    media=tweet_media.url,
+                    has_spoiler=tweet.sensitive,
+                    thumbnail=tweet_media.thumb
+                )
+
+
+class TelegramPixiv:
+    message_raw_text = message_raw_text_pixiv
+    __slots__ = ('_url', '_pixiv')
+
+    def __init__(self, url: str):
+        self._url = url
+
+    async def __aenter__(self):
+        async with ProcessPixiv(self._url) as pixiv:
+            self._pixiv = pixiv
+            return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        pass
+
+    @property
+    def url(self) -> str:
+        return self._pixiv.url
+
+    @property
+    def message_text(self) -> str:
+        pixiv = self._pixiv
+        return self.message_raw_text.format(
+            url=pixiv.url,
+            author_url=pixiv.author_url,
+            author=html.escape(pixiv.author),
+            text=html.escape(pixiv.title),
+            tags=html.escape(" ".join(f"#{name}" for name in pixiv.tags))
+        )
+
+    def inline_query_result(self) -> tuple[TypeInlineQueryResult, ...]:
+        return tuple(i for i in self.inline_query_generator() if i)
+
+    def message_media_result(self) -> tuple[TypeMessageMediaResult, ...]:
+        return tuple(i for i in self.message_media_generator() if i)
+
+    def inline_query_generator(self) -> Generator[TypeInlineQueryResult, None, None]:
+        pixiv = self._pixiv
+        for media in pixiv.images:
+            logger.info(str(media))
+            if pixiv.type in ("illust", "manga"):
+                yield InlineQueryResultPhoto(
+                    id=str(uuid4()),
+                    photo_url=media.large,
+                    thumbnail_url=media.thumb,
+                    caption=self.message_text
+                )
+            else:
+                yield
+
+    def message_media_generator(self) -> Generator[TypeMessageMediaResult, None, None]:
+        pixiv = self._pixiv
+        for media in pixiv.images:
+            logger.info(str(media))
+            if pixiv.type in ("illust", "manga"):
+                yield InputMediaPhoto(
+                    media=media.large,
+                    has_spoiler=pixiv.is_nsfw
+                )
+            else:
+                yield
+
+
+class TelegramBsky:
+    message_raw_text = message_raw_text_tweet
+    __slots__ = ('_url', '_bsky', '__dict__')
+
+    def __init__(self, url: str):
+        self._url: str = url
+
+    async def __aenter__(self):
+        async with ProcessBsky(self._url) as bsky:
+            self._bsky = bsky
+            return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        pass
+
+    @property
+    def url(self) -> str:
+        return self._bsky.url
+
+    @cached_property
+    def message_text(self) -> str:
+        bsky = self._bsky
+        return self.message_raw_text.format(
+            url=bsky.url,
+            author_url=bsky.author_url,
+            author=html.escape(bsky.author),
+            text=html.escape(bsky.text)
+        )
+
+    def inline_query_result(self) -> tuple[TypeInlineQueryResult, ...]:
+        return tuple(i for i in self.inline_query_generator() if i)
+
+    def message_media_result(self) -> tuple[TypeMessageMediaResult, ...]:
+        return tuple(i for i in self.message_media_generator() if i)
+
+    def inline_query_generator(self) -> Generator[TypeInlineQueryResult, None, None]:
+        bsky = self._bsky
+        for bsky_media in bsky.media:
+            logger.info(str(bsky_media))
+            if bsky_media.type == "image":
+                yield InlineQueryResultPhoto(
+                    id=str(uuid4()),
+                    photo_url=bsky_media.url,
+                    thumbnail_url=bsky_media.thumb,
+                    caption=self.message_text
+                )
+            elif bsky_media.type == "video":
+                # yield InlineQueryResultVideo(
+                #     id=str(uuid4()),
+                #     video_url=bsky_media.url,
+                #     mime_type="video/mp4",
+                #     thumbnail_url=bsky_media.thumb,
+                #     title=bsky.text,
+                #     caption=self.message_text
+                # )
+                yield
+            elif bsky_media.type == "external":
+                # yield InlineQueryResultVideo(
+                #     id=str(uuid4()),
+                #     video_url=bsky_media.url,
+                #     mime_type="image/gif",
+                #     thumbnail_url=bsky_media.thumb,
+                #     title=bsky.text,
+                #     caption=self.message_text
+                # )
+                yield
+
+    def message_media_generator(self) -> Generator[TypeMessageMediaResult, None, None]:
+        bsky = self._bsky
+        for bsky_media in bsky.media:
+            logger.info(str(bsky_media))
+            if bsky_media.type == "image":
+                yield InputMediaPhoto(
+                    media=bsky_media.url,
+                    has_spoiler=bsky.sensitive
+                )
+            elif bsky_media.type == "video":
+                # yield InputMediaVideo(
+                #     media=bsky_media.url,
+                #     has_spoiler=bsky.sensitive,
+                #     thumbnail=bsky_media.thumb
+                # )
+                yield
+            elif bsky_media.type == "external":
+                yield bsky_media.url, bsky.sensitive

utils/tweet.py

@@ -0,0 +1,152 @@
+from __future__ import annotations
+
+from functools import cached_property
+from typing import TYPE_CHECKING
+
+from .net import NetClient
+from .regex import x_media_url, x_tco_url, x_url
+
+if TYPE_CHECKING:
+    from .types import TweetInfo
+
+twimg_url = 'https://pbs.twimg.com/'
+vx_api_url = 'https://api.vxtwitter.com/{0}/status/{1}'
+
+
+class TweetMedia:
+    __slots__ = ('_url', '_thumb', '_type', '__dict__')
+
+    def __init__(self, url: str, thumb: str, media_type: str):
+        self._url: str = url
+        self._thumb: str = thumb
+        self._type: str = media_type
+
+    def __str__(self):
+        return f"TweetMedia(url={self.url}, thumb={self.thumb}, type={self.type})"
+
+    @cached_property
+    def _uri(self) -> str | None:
+        if match := x_media_url.match(self._url):
+            return match.group(2).removesuffix('.jpg').removesuffix('.png')
+        return None
+
+    @cached_property
+    def url(self) -> str:
+        match self._type:
+            case "image":
+                return f"{twimg_url}{self._uri}?format=jpg&name=4096x4096"
+            case "video":
+                return self._url
+            case "gif":
+                return self._url
+            case _:
+                return self._url
+
+    @cached_property
+    def thumb(self) -> str:
+        match self._type:
+            case "image":
+                return f"{twimg_url}{self._uri}?format=jpg&name=thumb"
+            case "video":
+                return self._thumb
+            case "gif":
+                return self._thumb
+            case _:
+                return self._thumb
+
+    @property
+    def type(self) -> str:
+        return self._type
+
+
+class Tweet:
+    __slots__ = ('_id', '_author', '_author_id', '_text', '_media', '_sensitive', '__dict__')
+
+    def __init__(
+            self,
+            tweet_id: str,
+            author: str,
+            author_id: str,
+            text: str,
+            media: list[TweetMedia],
+            sensitive: bool = False
+    ):
+        self._id: str = tweet_id
+        self._author: str = author
+        self._author_id: str = author_id
+        self._text: str = text
+        self._media: list[TweetMedia] = media
+        self._sensitive: bool = sensitive
+
+    @property
+    def id(self) -> str:
+        return self._id
+
+    @cached_property
+    def url(self) -> str:
+        return f"https://x.com/{self._author_id}/status/{self._id}"
+
+    @property
+    def author(self) -> str:
+        return self._author
+
+    @cached_property
+    def author_url(self) -> str:
+        return f"https://x.com/{self._author_id}"
+
+    @property
+    def text(self) -> str:
+        return self._text
+
+    @property
+    def media(self) -> list[TweetMedia]:
+        return self._media
+
+    @property
+    def sensitive(self) -> bool:
+        return self._sensitive
+
+
+class ProcessTweet:
+    __slots__ = ('_url', '_tweet')
+
+    def __init__(self, url: str):
+        self._url: str = url
+
+    async def __aenter__(self):
+        self._tweet = await self._fetch_tweet()
+        return Tweet(
+            tweet_id=self._tweet["tweetID"],
+            author=self._tweet["user_name"],
+            author_id=self._tweet["user_screen_name"],
+            text=self._tweet_text,
+            media=self._tweet_media,
+            sensitive=self._tweet["possibly_sensitive"]
+        )
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        pass
+
+    async def _fetch_tweet(self) -> TweetInfo:
+        match = x_url.match(self._url)
+        assert match, f"Invalid URL: {self._url}"
+        auther_id, tweet_id = match.groups()
+        return await NetClient.fetch_json(vx_api_url.format(auther_id, tweet_id))
+
+    @property
+    def _tweet_text(self) -> str:
+        match = x_tco_url.search(self._tweet['text'])
+        return self._tweet['text'][:match.start()].strip() if match else self._tweet['text']
+
+    @property
+    def _tweet_media(self) -> list[TweetMedia]:
+        return [
+            TweetMedia(
+                url=tweet_media['url'],
+                thumb=tweet_media['thumbnail_url'],
+                media_type=tweet_media['type']
+            )
+            for tweet_media in self._tweet['media_extended']
+        ]
+
+

utils/types.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from typing import Literal, TypedDict
+
+from telegram import InlineQueryResultMpeg4Gif, InlineQueryResultPhoto, InlineQueryResultVideo, InputMediaPhoto, \
+    InputMediaVideo
+
+TypeInlineQueryResult = InlineQueryResultMpeg4Gif | InlineQueryResultPhoto | InlineQueryResultVideo
+InputMediaAnimation = tuple[str, bool]
+TypeMessageMediaResult = InputMediaPhoto | InputMediaVideo | InputMediaAnimation
+
+
+class TweetInfo(TypedDict):
+    tweetID: str
+    user_name: str
+    user_screen_name: str
+    text: str
+    media_extended: list[dict]
+    possibly_sensitive: bool
+
+
+class BskyInfo(TypedDict):
+    thread: BskyThread
+
+
+class BskyThread(TypedDict):
+    post: BskyPost
+
+
+class BskyPost(TypedDict):
+    author: BskyAuthor
+    record: BskyPostRecord
+    embed: BskyEmbedImages | BskyEmbedVideo | BskyEmbedExternal
+    labels: list[BskyLabel]
+
+
+class BskyAuthor(TypedDict):
+    handle: str
+    displayName: str
+
+
+class BskyPostRecord(TypedDict):
+    text: str
+
+
+class BskyLabel(TypedDict):
+    val: str
+
+
+class BskyEmbedImage(TypedDict):
+    thumb: str
+    fullsize: str
+
+
+BskyEmbedImages = TypedDict('BskyEmbedImages', {
+    '$type': Literal['app.bsky.embed.images#view'],
+    'images': list[BskyEmbedImage]
+})
+
+BskyEmbedVideo = TypedDict('BskyEmbedVideo', {
+    '$type': Literal['app.bsky.embed.video#view'],
+    'playlist': str,
+    'thumbnail': str
+})
+
+
+class BskyEmbedExternalItem(TypedDict):
+    uri: str
+    thumb: str
+
+
+BskyEmbedExternal = TypedDict('BskyEmbedExternal', {
+    '$type': Literal['app.bsky.embed.external#view'],
+    'external': BskyEmbedExternalItem
+})