use cached property

common.py

@@ -2,8 +2,15 @@ import logging
 import os
 import re
 
+try:
+    import uvloop, asyncio
+
+    asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
+except ImportError:
+    uvloop = None
+
 BOT_TOKEN = os.getenv("BOT_TOKEN")
-ADMIN = os.getenv("BOT_ADMIN").split(",")
+ADMIN = [int(i) for i in os.getenv("BOT_ADMIN").split(",")]
 
 WEBHOOK = os.getenv("WEBHOOK", False)
 if WEBHOOK:
@@ -14,13 +21,16 @@ if WEBHOOK:
     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_url_regex = re.compile(r"^(?:https?://)(?:www\.|mobile\.|)(?:x|twitter|fixvx|vxtwitter)\.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)
-message_url_regex = re.compile(r"\{.+\}", re.S)
+message_url_regex = re.compile(r"\[.+]", re.S)
 
 logging.basicConfig(
     level=os.getenv("LOG_LEVEL", "WARNING"),
     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
 )
-logger = logging.getLogger(__name__)
+
+
+def get_logger(name: str) -> logging.Logger:
+    return logging.getLogger(name)

main.py

@@ -1,23 +1,22 @@
+from __future__ import annotations
+
 import html
 from functools import wraps
+from typing import TYPE_CHECKING
 
-from aiohttp import ClientSession
+from telegram import InlineKeyboardButton, InlineKeyboardMarkup
-from telegram import Update, Chat, InlineKeyboardMarkup, InlineKeyboardButton, ForceReply, Message
+from telegram.constants import ChatAction, ChatType, ParseMode
-from telegram.constants import ParseMode, ChatAction, ChatType
+from telegram.ext import (ApplicationBuilder, CallbackQueryHandler, CommandHandler, Defaults,
-from telegram.ext import (
+                          InlineQueryHandler, MessageHandler, PicklePersistence, filters)
-    Application,
-    ApplicationBuilder,
-    ContextTypes,
-    Defaults,
-    filters,
-    InlineQueryHandler,
-    PicklePersistence,
-    MessageHandler,
-    CommandHandler, CallbackQueryHandler
-)
 
 import common
-from tweet import TGTweet
+from tweet import TelegramTweet
+
+if TYPE_CHECKING:
+    from telegram import Chat, Message, Update
+    from telegram.ext import Application, ContextTypes
+
+logger = common.get_logger(__name__)
 
 
 def send_action(action):
@@ -36,7 +35,7 @@ async def inline_query(update: Update, context: ContextTypes.DEFAULT_TYPE) -> No
     query = update.inline_query.query
     if query == "":
         return
-    common.logger.info(f"Query: {query}")
+    logger.info(f"Query: {query}")
     async with TGTweet(query) as tweet:
         result = list(tweet.inline_query_generator)
         await update.inline_query.answer(result)
@@ -45,19 +44,28 @@ async def inline_query(update: Update, context: ContextTypes.DEFAULT_TYPE) -> No
 @send_action(ChatAction.UPLOAD_PHOTO)
 async def url_media(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
     url = update.message.text
-    common.logger.info(f"Receiving url: {url}")
+    logger.info(f"Receiving url: {url}")
     async with TGTweet(url) as tweet:
         media = list(tweet.pm_media_generator)
         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 tweet.is_single_gif 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.user_data.get('edit_before_forward', False):
         message_reply = await update.effective_message.reply_text(
-            "Reply to edit message.",
+            "Reply to edit message. [URL]",
-            reply_markup=ForceReply(selective=True, input_field_placeholder="{URL}"),
+            reply_markup=InlineKeyboardMarkup.from_button(
+                InlineKeyboardButton("↩️ Confirm", callback_data="forward")
+            ),
             reply_to_message_id=update.message.message_id,
         )
         context.user_data['message_reply'] = message_reply
@@ -87,20 +95,25 @@ async def edit_message(update: Update, context: ContextTypes.DEFAULT_TYPE) -> No
         return
     if update.message.reply_to_message != context.user_data['message_reply']:
         return
-    update_text = update.message.text
+    template = context.user_data.get('template', None)
-    match = common.message_url_regex.search(update_text)
+    message_url = '<a href="{0}">{1}</a>'
-    if match:
+    url = context.user_data['message_url']
-        match = match.span()
+    if template:
-        update_text = update_text[:match[0]] + '<a href="{0}">{1}</a>'.format(
+        update_text = template.replace("[]", message_url.format(
-            context.user_data['message_url'], update_text[match[0] + 1:match[1] - 1]
+            url,
-        ) + update_text[match[1]:]
+            html.escape(update.message.text)
+        ))
+    else:
+        update_text = html.escape(update.message.text)
+        match = common.message_url_regex.search(update_text)
+        if match:
+            match = match.span()
+            update_text = update_text[:match[0]] + message_url.format(
+                url,
+                update_text[match[0] + 1:match[1] - 1]
+            ) + update_text[match[1]:]
     message_to_send = context.user_data['message_to_send']
-    await message_to_send[0].edit_caption(html.escape(update_text))
+    await message_to_send[0].edit_caption(update_text)
-    await context.user_data['message_reply'].edit_message_reply_markup(
-        InlineKeyboardMarkup.from_button(
-            InlineKeyboardButton("↩️ Confirm", callback_data="forward")
-        )
-    )
 
 
 async def query_forward_message(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
@@ -156,12 +169,33 @@ async def cmd_edit_before_forward(update: Update, context: ContextTypes.DEFAULT_
     ebf_status = context.user_data.get('edit_before_forward', False)
     if ebf_status:
         context.user_data['edit_before_forward'] = False
+        context.user_data.pop('message_reply', None)
+        context.user_data.pop('message_to_send', None)
+        context.user_data.pop('message_url', None)
         await update.effective_message.reply_text("Disable edit before forward.")
         return
     context.user_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: ContextTypes.DEFAULT_TYPE) -> 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 reply.text_html:
+        await update.effective_message.reply_text("Please reply to a message with [] to set as template.")
+        return
+    context.user_data['template'] = reply.text_html
+    await update.effective_message.reply_text("Template set.")
+
+
+@send_action(ChatAction.TYPING)
+async def cmd_user_dict(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    await update.effective_message.reply_text(str(context.user_data))
+
+
 async def post_init(application: Application) -> None:
     # commands = [
     #     BotCommand('start', CMD_START),
@@ -170,7 +204,7 @@ 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)
-    TGTweet.set_session(ClientSession())
+    TGTweet.init_client()
 
 
 async def post_stop(application: Application) -> None:
@@ -178,7 +212,7 @@ async def post_stop(application: Application) -> None:
 
 
 async def post_shutdown(application: Application) -> None:
-    await TGTweet.close_session()
+    await TGTweet.close_client()
 
 
 def main():
@@ -191,20 +225,23 @@ def main():
                    .post_init(post_init)
                    .post_stop(post_stop)
                    .post_shutdown(post_shutdown)
+                   .concurrent_updates(True)
                    .build()
                    )
 
-    # user_filter = filters.User()
+    user_filter = filters.User()
-    # user_filter.add_user_ids(common.admin)
+    user_filter.add_user_ids(common.ADMIN)
 
     handlers = [
-        MessageHandler(filters.Regex(common.x_url_regex) & filters.ChatType.PRIVATE, url_media),
         InlineQueryHandler(inline_query, common.x_url_regex),
+        MessageHandler(filters.Regex(common.x_url_regex) & filters.ChatType.PRIVATE, url_media),
         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, edit_message),
         CallbackQueryHandler(query_forward_message, pattern="forward"),
+        CommandHandler("bot_dict", cmd_user_dict, filters=user_filter),
     ]
 
     application.add_handlers(handlers)

requirements.txt

@@ -1,2 +1,3 @@
-python-telegram-bot[webhooks]~=21.1.1
+python-telegram-bot[webhooks]~=21.3
-aiohttp[speedups]~=3.9.3
+httpx[http2]~=0.27.0
+uvloop~=0.19.0; sys_platform != 'win32'

tweet.py

@@ -1,17 +1,21 @@
+from __future__ import annotations
+
 import html
-from typing import Generator
+from functools import cached_property
+from typing import TYPE_CHECKING
+from uuid import uuid4
 
-from aiohttp import ClientSession
+from httpx import AsyncClient
-from telegram import (
+from telegram import (InlineQueryResultMpeg4Gif, InlineQueryResultPhoto, InlineQueryResultVideo, InputMediaPhoto,
-    InlineQueryResultPhoto,
+                      InputMediaVideo)
-    InlineQueryResultVideo,
+
-    InlineQueryResultMpeg4Gif,
+from common import get_logger, x_media_regex, x_tco_regex, x_url_regex
-    InputMediaPhoto,
+
-    InputMediaVideo,
+if TYPE_CHECKING:
-    InputMediaAnimation
+    from typing import Generator, TypedDict
-)
+
+logger = get_logger(__name__)
 
-from common import x_url_regex, x_media_regex, x_tco_regex, logger
 
 twimg_url = 'https://pbs.twimg.com/'
 vx_api_url = 'https://api.vxtwitter.com/{0}/status/{1}'
@@ -21,14 +25,24 @@ message_raw_text = """{url}
 """
 
 
-async def fetch_json(session: ClientSession, url: str) -> dict:
+def create_client() -> AsyncClient:
+    return AsyncClient(http2=True)
+
+
+async def close_client(_client: AsyncClient) -> None:
+    await _client.aclose()
+
+
+async def fetch_json(_client: AsyncClient, url: str) -> dict:
     logger.info(f"Fetching {url}")
-    async with session.get(url) as response:
+    response = await _client.get(url)
-        assert response.status == 200, f"Failed to fetch {url}, status code {response.status}"
+    assert response.status_code == response.is_success, f"Failed to fetch {url}, status code {response.status_code}"
-        return await response.json()
+    return response.json()
 
 
 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
@@ -37,14 +51,14 @@ class TweetMedia:
     def __str__(self):
         return f"Media[url: {self.url} thumb: {self.thumb} type: {self.type}]"
 
-    @property
+    @cached_property
     def _uri(self) -> str | None:
         match = x_media_regex.match(self._url)
         if match:
             return match.group(2).removesuffix('.jpg').removesuffix('.png')
         return None
 
-    @property
+    @cached_property
     def url(self) -> str:
         match self._type:
             case "image":
@@ -56,7 +70,7 @@ class TweetMedia:
             case _:
                 return self._url
 
-    @property
+    @cached_property
     def thumb(self) -> str:
         match self._type:
             case "image":
@@ -74,6 +88,8 @@ class TweetMedia:
 
 
 class Tweet:
+    __slots__ = ('_id', '_author', '_author_id', '_text', '_media', '_sensitive', '__dict__')
+
     def __init__(
             self,
             tweet_id: str,
@@ -94,7 +110,7 @@ class Tweet:
     def id(self) -> str:
         return self._id
 
-    @property
+    @cached_property
     def url(self) -> str:
         return f"https://twitter.com/{self._author_id}/status/{self._id}"
 
@@ -102,7 +118,7 @@ class Tweet:
     def author(self) -> str:
         return self._author
 
-    @property
+    @cached_property
     def author_url(self) -> str:
         return f"https://twitter.com/{self._author_id}"
 
@@ -120,11 +136,65 @@ class Tweet:
 
 
 class TGTweet(Tweet):
-    _session: ClientSession
+class TweetInfo(TypedDict):
+    tweetID: str
+    user_name: str
+    user_screen_name: str
+    text: str
+    media_extended: list[dict]
+    possibly_sensitive: bool
+
+
+class ProcessTweet:
+    __slots__ = ('_httpx_client', '_url', '_tweet')
+
+    def __init__(self, httpx_client: AsyncClient, url: str):
+        self._httpx_client: AsyncClient = httpx_client
+        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_regex.match(self._url)
+        assert match, f"Invalid URL: {self._url}"
+        auther_id, tweet_id = match.group()
+        return await fetch_json(self._httpx_client, vx_api_url.format(auther_id, tweet_id))
+
+    @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=tweet_media['url'],
+                thumb=tweet_media['thumbnail_url'],
+                media_type=tweet_media['type']
+            )
+            for tweet_media in self._tweet['media_extended']
+        ]
+
+
+class TelegramTweet:
 
     def __init__(self, url: str):
         self._url: str = url
         self._api_param: tuple[str] = self._tweet_id
+        self._is_single_gif: bool = False
         assert self._api_param
 
     async def __aenter__(self):
@@ -136,15 +206,15 @@ class TGTweet(Tweet):
         pass
 
     @classmethod
-    def set_session(cls, session: ClientSession) -> None:
+    def init_client(cls) -> None:
-        cls._session = session
+        cls._httpx_client = create_client()
 
     @classmethod
-    async def close_session(cls) -> None:
+    async def close_client(cls) -> None:
-        await cls._session.close()
+        await close_client(cls._httpx_client)
 
     async def _fetch_tweet(self, api_param: tuple[str]) -> dict:
-        return await fetch_json(self._session, vx_api_url.format(*api_param))
+        return await fetch_json(self._httpx_client, vx_api_url.format(*api_param))
 
     @property
     def _tweet_id(self) -> tuple[str] | None:
@@ -179,6 +249,10 @@ class TGTweet(Tweet):
         sensitive = self._tweet['possibly_sensitive']
         return id, author, author_id, text, media, sensitive
 
+    @property
+    def is_single_gif(self) -> bool:
+        return self._is_single_gif
+
     @property
     def message_text(self) -> str:
         return message_raw_text.format(
@@ -192,18 +266,18 @@ class TGTweet(Tweet):
     def inline_query_generator(self) -> Generator[
         InlineQueryResultPhoto | InlineQueryResultVideo | InlineQueryResultMpeg4Gif, None, None
     ]:
-        for i, tweet_media in enumerate(self.media):
+        for tweet_media in self.media:
             logger.info(str(tweet_media))
             if tweet_media.type == "image":
                 yield InlineQueryResultPhoto(
-                    id=str(i),
+                    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(i),
+                    id=str(uuid4()),
                     video_url=tweet_media.url,
                     mime_type="video/mp4",
                     thumbnail_url=tweet_media.thumb,
@@ -212,14 +286,14 @@ class TGTweet(Tweet):
                 )
             elif tweet_media.type == "gif":
                 yield InlineQueryResultMpeg4Gif(
-                    id=str(i),
+                    id=str(uuid4()),
                     mpeg4_url=tweet_media.url,
                     thumbnail_url=tweet_media.thumb,
                     caption=self.message_text
                 )
 
     @property
-    def pm_media_generator(self) -> Generator[InputMediaPhoto | InputMediaVideo | InputMediaAnimation, None, None]:
+    def pm_media_generator(self) -> Generator[InputMediaPhoto | InputMediaVideo | tuple[str, bool], None, None]:
         for tweet_media in self.media:
             logger.info(str(tweet_media))
             if tweet_media.type == "image":
@@ -234,7 +308,10 @@ class TGTweet(Tweet):
                     thumbnail=tweet_media.thumb
                 )
             elif tweet_media.type == "gif":
-                yield InputMediaAnimation(
+                if len(self.media) == 1:
+                    self._is_single_gif = True
+                    yield tweet_media.url, self.sensitive
+                yield InputMediaVideo(
                     media=tweet_media.url,
                     has_spoiler=self.sensitive,
                     thumbnail=tweet_media.thumb