def create_result_article_track_audio(datas, quality):
results = []
for data in datas:
ids = data['id']
link = get_url_path(data['link'])
match = select_dwsongs(link, quality)
if match:
audio_file_id = match[0]
article = InlineQueryResultCachedAudio(
id=ids,
audio_file_id=audio_file_id,
)
else:
article = InlineQueryResultAudio(
id=ids,
audio_url=data['preview'],
title=data['title'],
performer=data['artist']['name'],
audio_duration=data['duration'],
input_message_content=InputTextMessageContent(data['link']))
results.append(article)
return results
def inline_query_result_audio():
return InlineQueryResultAudio(TestInlineQueryResultAudio.id,
TestInlineQueryResultAudio.audio_url,
TestInlineQueryResultAudio.title,
performer=TestInlineQueryResultAudio.performer,
audio_duration=TestInlineQueryResultAudio.audio_duration,
caption=TestInlineQueryResultAudio.caption,
input_message_content=TestInlineQueryResultAudio.input_message_content,
reply_markup=TestInlineQueryResultAudio.reply_markup)
def test_equality(self):
a = InlineQueryResultAudio(self.id, self.audio_url, self.title)
b = InlineQueryResultAudio(self.id, self.title, self.title)
c = InlineQueryResultAudio(self.id, '', self.title)
d = InlineQueryResultAudio('', self.audio_url, self.title)
e = InlineQueryResultVoice(self.id, '', '')
assert a == b
assert hash(a) == hash(b)
assert a is not b
assert a == c
assert hash(a) == hash(c)
assert a != d
assert hash(a) != hash(d)
assert a != e
assert hash(a) != hash(e)
def get_clips(_: CallbackContext) -> None:
global results, names
results.clear()
names.clear()
links, names = util.clips()
# Adds all clips and names into one list
for link, name in zip(links, names):
results.append(
InlineQueryResultAudio(id=uuid4(),
audio_url=link,
title=name,
performer="Shani Sir"))
def inlinequery(update: Update, context: CallbackContext):
client = Client()
results = []
for song in client.search_songs(update.inline_query.query):
results.append(InlineQueryResultAudio(
id=song['nid'],
title=song['title'],
performer=song['artist'],
audio_duration=song['duration'],
audio_url='https://{0}/get_song?id=T{1}'.format(config.get_option('proxy', 'host'), song['nid'])
))
update.inline_query.answer(results)
def inline_query_callback(self, bot, update):
self.log_and_botan_track("link_inline")
inline_query_id = update.inline_query.id
text = update.inline_query.query
results = []
urls = self.prepare_urls(msg_or_text=text, direct_urls=True)
for url in urls:
for direct_url in urls[url].splitlines(): # TODO: fix non-mp3 and allow only sc/bc
logger.debug(direct_url)
results.append(
InlineQueryResultAudio(id=str(uuid4()), audio_url=direct_url, title="FAST_INLINE_DOWNLOAD"))
try:
bot.answer_inline_query(inline_query_id, results)
except:
pass
def response_inline(bot, update):
"""
Handle inline queries
The user sends a message with a desired game voice line and the bot sends a voice
message with the best voice line.
"""
message = update.inline_query.query
user = update.inline_query.from_user
specific_hero = None
if message.find("/") >= 0:
specific_hero, query = message.split("/")
specific_hero.strip()
query.strip()
else:
query = message
query.strip()
LOGGER.info("New query from: %s %s\nQuery: %s", user.first_name,
user.last_name, message)
print("Finding the query...")
lines = get_responses(query, specific_hero)
results = list()
if not lines:
pass
else:
for each in lines:
heroname = each["Character"]
audiodesc = "Character: {} --- Text: \"{}\"".format(
heroname, each["Text"])
print(audiodesc)
sresult = InlineQueryResultAudio(id=uuid4(),
audio_url=each["URL"],
title="\"{}\"".format(
each["Text"]),
performer=heroname)
results.append(sresult)
bot.answerInlineQuery(update.inline_query.id,
results=results,
cache_time=1)
def inlinequery(update: Update, context: CallbackContext) -> None:
"""Handle the inline query."""
query = update.inline_query.query
results = []
for k, v in d.items():
if re.search(query, k, re.IGNORECASE):
results.append(
InlineQueryResultAudio(
id=uuid4(),
audio_url="{}{}".format(dcr8_url, v),
title="{}".format(k)
),
)
update.inline_query.answer(results, auto_pagination=True)
def test_equality(self):
a = InlineQueryResultVoice(self.id_, self.voice_url, self.title)
b = InlineQueryResultVoice(self.id_, self.voice_url, self.title)
c = InlineQueryResultVoice(self.id_, "", self.title)
d = InlineQueryResultVoice("", self.voice_url, self.title)
e = InlineQueryResultAudio(self.id_, "", "")
assert a == b
assert hash(a) == hash(b)
assert a is not b
assert a == c
assert hash(a) == hash(c)
assert a != d
assert hash(a) != hash(d)
assert a != e
assert hash(a) != hash(e)
def test_equality(self):
a = InlineQueryResultArticle(self.id, self.title, self.input_message_content)
b = InlineQueryResultArticle(self.id, self.title, self.input_message_content)
c = InlineQueryResultArticle(self.id, "", self.input_message_content)
d = InlineQueryResultArticle("", self.title, self.input_message_content)
e = InlineQueryResultAudio(self.id, "", "")
assert a == b
assert hash(a) == hash(b)
assert a is not b
assert a == c
assert hash(a) == hash(c)
assert a != d
assert hash(a) != hash(d)
assert a != e
assert hash(a) != hash(e)
def inlinequery(bot, update):
query = update.inline_query.query
results = list()
# search and trim result to 50, which is max result count for inline query answer
audios = search(query)[:50]
try:
if audios:
for audio in audios:
results.append(
InlineQueryResultAudio(id=uuid4(),
audio_url=audio['download'],
title=audio["title"],
performer=audio["artist"],
audio_duration=audio["duration"]))
update.inline_query.answer(results=results,
cache_time=INLINE_QUERY_CACHE_TIME)
except Exception as e:
error(bot, update, e)
def inline_caps(bot, update):
query = update.inline_query.query
print(update.inline_query.query, update.inline_query.from_user.first_name,
update.inline_query.from_user.last_name)
if not query:
return
results = list()
print('searchin\'...')
phrases_results = search(query)
i = 0
for phrase in phrases_results:
results.append(
InlineQueryResultAudio(id=i,
title=phrase['name'][:-4],
audio_url=phrase['link']))
i += 1
if i >= 50:
break
bot.answer_inline_query(update.inline_query.id, results)
def buildInlineAudioResults(audios, linksMode):
durationText = lambda duration: time.strftime('%M:%S', time.gmtime(duration))
albumOrDuration = lambda audio: f"Album: {audio['album']}" if ('album' in audio) else f"Duration: {durationText(audio['duration'])}"
audiosMapper = lambda audio: InlineQueryResultAudio(
id=uuid4(),
audio_url=audio['download'],
title=audio["title"],
performer=audio["artist"],
audio_duration=audio["duration"]
)
articleMapper = lambda audio: InlineQueryResultArticle(
id=uuid4(),
thumb_url=audio.get('cover_url_small') or audio.get('cover'),
hide_url=True,
url=audio['download'],
title=audio["title"],
description="Artist: {}\n{}".format(audio['artist'], albumOrDuration(audio)),
audio_duration=audio["duration"],
input_message_content=InputTextMessageContent(audio['download'])
)
return list(map(articleMapper if linksMode else audiosMapper, audios[:50]))
def buildInlineAudioResults(audios, linksMode):
durationText = lambda duration: time.strftime('%M:%S', time.gmtime(duration
))
albumOrDuration = lambda audio: f"Album: {audio['album']}" if (
'album' in audio) else f"Duration: {durationText(audio['duration'])}"
audiosMapper = lambda audio: InlineQueryResultAudio(
id=uuid4(),
audio_url=audio['download'],
title=audio["title"],
performer=audio["artist"],
audio_duration=audio["duration"])
articleMapper = lambda audio: InlineQueryResultArticle(
id=uuid4(),
thumb_url='https://github.com/ACHIYA96/Misc/blob/main/achi1.jpg',
hide_url=True,
url=audio['download'],
title=audio["title"],
description="Artist: {}\n{} [____ACHIYA____]".format(
audio['artist'], albumOrDuration(audio)),
audio_duration=audio["duration"],
input_message_content=InputTextMessageContent(audio['download']))
return list(map(articleMapper if linksMode else audiosMapper, audios[:50]))
def format_results(result) -> InlineQueryResult:
_result: InlineQueryResult = None
if result.TAG == 'Track':
url = result.getStreamURL()
html_message = f'<a href="{url}">{result.grandparentTitle} - \
{result.title}</a>\n<i>{result.parentTitle}</i>'
_result: InlineQueryResultAudio = InlineQueryResultAudio(
id=uuid4(),
audio_url=url,
title=result.title,
performer=result.grandparentTitle,
audio_duration=int(result.duration / 1000), # milli sec to sec
caption=result.parentTitle,
input_message_content=InputTextMessageContent(
html_message, parse_mode=ParseMode.HTML))
elif result.TAG == 'Artist':
pass
return _result
def inlinequery(bot, update):
query = update.inline_query.query
results = list()
# search and trim result to 50, which is max result count
for inline query answer
audios = search(query)[: 50];
try:
if audios:
for audio in audios:
results.append(
InlineQueryResultAudio(
id = uuid4(),
audio_url = audio['download'],
title = audio["title"],
performer = audio["artist"],
audio_duration = audio["duration"]
)
)
update.inline_query.answer(results = results, cache_time = INLINE_QUERY_CACHE_TIME)
except Exception, e:
error(bot, update, e)
def search(query):
if len(query.strip()) < 1:
query = text.get_random_artist()
logger.info("Search query is '%s'" % query)
payload = {
def inline_query(bot, update):
word = update.inline_query.query
results = list()
if len(word) >= 1:
with connection.cursor() as cursor:
sql = "select * from CantonDict where word=%s limit 1"
cursor.execute(sql, (word[0]))
result = cursor.fetchone()
if result:
canton_dict = CantonDict(result)
else:
canton_dict = CantonDict(word[0])
with connection.cursor() as cursor:
sql = "INSERT INTO `CantonDict`" \
" (`word`, `url`,`examples`,`brief_explains`,`audios`" \
",`cangjie_pattern`,`char_can_notes`,`eng_meanings`,`word_example`,`homonyms`)" \
" VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)"
cursor.execute(
sql,
(word[0], canton_dict.url, str(
canton_dict.examples).replace("[", "").replace(
"]", ""), str(canton_dict.brief_explains).replace(
"[", "").replace("]", ""),
str(canton_dict.audios).replace("[", "").replace(
"]", ""), canton_dict.cangjie_pattern,
str(canton_dict.char_can_notes).replace("[", "").replace(
"]", ""), canton_dict.eng_meanings,
str(canton_dict.word_example).replace("[", "").replace(
"]", ""), str(canton_dict.homonyms).replace(
"[", "").replace("]", "")))
connection.commit()
if len(canton_dict.audios) == len(canton_dict.char_can_notes):
for index in range(len(canton_dict.audios)):
both = canton_dict.char_can_notes[
index] and canton_dict.examples[index]
results.append(
InlineQueryResultAudio(
id=uuid4(),
title="「{0}」讀音：{1},{2}".format(
word[0], canton_dict.char_can_notes[index],
canton_dict.examples[index])
if both else "「{0}」讀音：{1}{2}".format(
word[0], canton_dict.char_can_notes[index],
canton_dict.examples[index]),
audio_url=
'http://humanum.arts.cuhk.edu.hk/Lexis/lexi-mf/{0}'.
format(canton_dict.audios[index])))
if canton_dict.word_example:
example_line = list()
empty = True
for example in canton_dict.examples:
example_line.append(example.replace("'", "").strip())
if example.replace("'", "").strip():
empty = False
if len(example_line) > 0 and not empty:
results.append(
InlineQueryResultArticle(
id=uuid4(),
title="「{0}」例子".format(word[0]),
input_message_content=InputTextMessageContent(
"「{0}」例子\n{1}".format(word[0],
"\n".join(example_line)))))
if canton_dict.brief_explains:
is_str = type(canton_dict.brief_explains) is str
results.append(
InlineQueryResultArticle(
id=uuid4(),
title="「{0}」略說".format(word[0]),
input_message_content=InputTextMessageContent(
"「{0}」{1}".format(
word[0],
ast.literal_eval(
canton_dict.brief_explains.
replace('\\\\', '\\')).decode()) if is_str else
canton_dict.brief_explains[0].decode('utf8'))))
if canton_dict.eng_meanings:
results.append(
InlineQueryResultArticle(
id=uuid4(),
title="「{0}」English meaning".format(word[0]),
input_message_content=InputTextMessageContent(
"「{0}」English meaning\n{1}".format(
word[0], canton_dict.eng_meanings))))
if len(canton_dict.audios) == len(canton_dict.homonyms):
for index in range(len(canton_dict.audios)):
results.append(
InlineQueryResultArticle(
id=uuid4(),
title="「{0}」({1})同音字".format(
word[0], canton_dict.audios[index][6:-4]),
input_message_content=InputTextMessageContent(
"「{0}」{1} 同音字\n{2}".format(
word[0], canton_dict.audios[index][6:-4],
canton_dict.homonyms[index]))))
if canton_dict.cangjie_pattern:
results.append(
InlineQueryResultArticle(
id=uuid4(),
title="「{0}」倉頡碼".format(word[0]),
input_message_content=InputTextMessageContent(
"「{0}」倉頡碼：{1}".format(word[0],
canton_dict.cangjie_pattern))))
if canton_dict.url:
results.append(
InlineQueryResultArticle(
id=uuid4(),
title="「{0}」更多".format(word[0]),
input_message_content=InputTextMessageContent(
canton_dict.url)))
update.inline_query.answer(results)
def ProcessInlineQuery(bot, update):
#start = timeit.timeit()
query = update.inline_query.query
inline = list()
releases = list()
addInline = inline.append
addRelease = releases.append
if len(query) > 0:
if query == 'new albums':
message = ''
local = arrow.utcnow().to('Europe/Berlin')
newReleases = Releases.newReleases(config, 'DE')
if len(newReleases['albums']['items']) > 0:
message += 'New Releases {0}\n\n'.format(
local.format('YYYY-MM-DD HH:mm'))
count = 1
for album in newReleases['albums']['items']:
message += '{0}. [{1}]({2}) by {3}\n'.format(
count, album['name'],
album['external_urls']['spotify'],
album['artists'][0]['name'])
addRelease(
InlineQueryResultArticle(
id=uuid4(),
title=Parse.AlbumReleaseInlineTitle(count, album),
reply_markup=InlineKeyboardMarkup([[
InlineKeyboardButton('Go to Spotify',
url=Parse.AlbumUrl(album))
]]),
input_message_content=InputTextMessageContent(
Parse.AlbumReleaseInlineInputMessage(album),
ParseMode.MARKDOWN, False),
description=Parse.AlbumInlineDescription(album),
thumb_url=Parse.AlbumThumbUrl(album),
thumb_width=640,
thumb_height=640))
count += 1
addInline(
InlineQueryResultArticle(
id=uuid4(),
title='New Releases {0}\n\n'.format(
local.format('YYYY-MM-DD HH:mm')),
reply_markup=None,
input_message_content=InputTextMessageContent(
message, ParseMode.MARKDOWN, True)))
for release in releases:
addInline(release)
else:
results = Search.getResults(query, config)
if len(results['tracks']['items']) > 0:
for track in results['tracks']['items']:
if Parse.TrackPreviewUrl(track) != None:
addInline(
InlineQueryResultAudio(
id='spotify:track:{0}'.format(
track['id']), #uuid4(),
audio_url=Parse.TrackPreviewUrl(track),
performer=Parse.TrackArtists(track),
title=Parse.TrackInlineTitle(track),
reply_markup=InlineKeyboardMarkup(
[[
InlineKeyboardButton(
'Go to Spotify',
url=Parse.TrackUrl(track)),
InlineKeyboardButton(
'Lyrics',
callback_data='spotify:track:{0}'.
format(track['id']))
],
[
InlineKeyboardButton(
'Stats 4 Nerds',
callback_data='stats:{0}'.format(
track['id']))
]]),
input_message_content=InputTextMessageContent(
Parse.TrackInlineInputMessage(track),
ParseMode.MARKDOWN, False)))
else:
addInline(
InlineQueryResultArticle(
id='spotify:track:{0}'.format(
track['id']), #uuid4(),
title=Parse.TrackInlineTitleWithOutPreview(
track),
reply_markup=InlineKeyboardMarkup(
[[
InlineKeyboardButton(
'Go to Spotify',
url=Parse.TrackUrl(track)),
InlineKeyboardButton(
'Lyrics',
callback_data='spotify:track:{0}'.
format(track['id']))
],
[
InlineKeyboardButton(
'Stats 4 Nerds',
callback_data='stats:{0}'.format(
track['id']))
]]),
input_message_content=InputTextMessageContent(
Parse.TrackInlineInputMessage(track),
ParseMode.MARKDOWN, False),
description=Parse.
TrackInlineDescriptionWithOutPreview(track),
url=Parse.TrackUrl(track),
hide_url=True,
thumb_url=Parse.TrackThumbUrl(track),
thumb_width=640,
thumb_height=640))
if len(results['artists']['items']) > 0:
for artist in results['artists']['items']:
addInline(
InlineQueryResultArticle(
id=uuid4(),
title=Parse.ArtistInlineTitle(artist),
reply_markup=InlineKeyboardMarkup([[
InlineKeyboardButton(
'Go to Spotify',
url=Parse.ArtistUrl(artist))
]]),
input_message_content=InputTextMessageContent(
Parse.ArtistInlineInputMessage(artist),
ParseMode.MARKDOWN, False),
description=Parse.ArtistInlineDescription(artist),
thumb_url=Parse.ArtistThumbUrl(artist),
thumb_width=640,
thumb_height=640))
if len(results['albums']['items']) > 0:
for album in results['albums']['items']:
addInline(
InlineQueryResultArticle(
id=uuid4(),
title=Parse.AlbumInlineTitle(album),
reply_markup=InlineKeyboardMarkup([[
InlineKeyboardButton('Go to Spotify',
url=Parse.AlbumUrl(album))
]]),
input_message_content=InputTextMessageContent(
Parse.AlbumInlineInputMessage(album),
ParseMode.MARKDOWN, False),
description=Parse.AlbumInlineDescription(album),
thumb_url=Parse.AlbumThumbUrl(album),
thumb_width=640,
thumb_height=640))
if len(results['playlists']['items']) > 0:
for playlist in results['playlists']['items']:
addInline(
InlineQueryResultArticle(
id=uuid4(),
title=Parse.PlaylistInlineTitle(playlist),
reply_markup=InlineKeyboardMarkup([[
InlineKeyboardButton(
'Go to Spotify',
url=Parse.PlaylistUrl(playlist))
]]),
input_message_content=InputTextMessageContent(
Parse.PlaylistInlineInputMessage(playlist),
ParseMode.MARKDOWN, False),
description=Parse.PlaylistInlineDescription(
playlist),
thumb_url=Parse.PlaylistThumbUrl(playlist),
thumb_width=640,
thumb_height=640))
bot.answerInlineQuery(update.inline_query.id, inline)
logger.info('INLINE: @{0}({1}): {2}'.format(
update.inline_query.from_user.username,
update.inline_query.from_user.id, update.inline_query.query))
elif len(query) == 0 or query == None:
addInline(
InlineQueryResultArticle(
id=uuid4(),
title='to get the new Releases',
description='type in "new albums"',
reply_markup=None,
input_message_content=InputTextMessageContent(
'How to use my inline query?\n\nto get the new Releases type in "`new albums`"',
parse_mode=ParseMode.MARKDOWN)))
addInline(
InlineQueryResultArticle(
id=uuid4(),
title='to get the a track/album/artist/playlist',
description='type in "track/album/artist/playlist"',
reply_markup=None,
input_message_content=InputTextMessageContent(
'How to use my inline query?\n\nto get the a track/album/artist/playlist type in "`track/album/artist/playlist`"',
parse_mode=ParseMode.MARKDOWN)))
bot.answerInlineQuery(update.inline_query.id,
inline,
switch_pm_text='How to use my inline query?',
switch_pm_parameter='help')
logger.info('INLINE: @{0}({1}): {2}'.format(
update.inline_query.from_user.username,
update.inline_query.from_user.id, update.inline_query.query))
else:
pass
def inlineparse(update, context):
inline_query = update.inline_query
query = inline_query.query
helpmsg = [
InlineQueryResultArticle(
id=uuid4(),
title="帮助",
description="将 Bot 添加到群组可以自动匹配消息, Inline 模式只可发单张图。",
reply_markup=sourcecodemarkup,
input_message_content=InputTextMessageContent(
"欢迎使用 @bilifeedbot 的 Inline 模式来转发动态，您也可以将 Bot 添加到群组自动匹配消息。"),
)
]
if not query:
inline_query.answer(helpmsg)
return
try:
url = re.search(regex, query).group(0)
except AttributeError:
inline_query.answer(helpmsg)
return
logger.info(f"Inline: {url}")
f = asyncio.run(feedparser(url))
if not f:
logger.warning("解析错误！")
return
if not f.mediaurls:
results = [
InlineQueryResultArticle(
id=uuid4(),
title=f.user,
description=f.content,
reply_markup=origin_link(f.url),
input_message_content=InputTextMessageContent(
captions(f),
parse_mode=ParseMode.MARKDOWN_V2,
disable_web_page_preview=True,
),
)
]
else:
if f.mediatype == "video":
results = [
InlineQueryResultVideo(
id=uuid4(),
caption=captions(f),
title=f.user,
description=f.content,
mime_type="video/mp4",
parse_mode=ParseMode.MARKDOWN_V2,
reply_markup=origin_link(f.url),
thumb_url=f.mediathumb,
video_url=f.mediaurls[0],
)
]
if f.mediatype == "audio":
results = [
InlineQueryResultAudio(
id=uuid4(),
caption=captions(f),
title=f.mediatitle,
description=f.content,
audio_duration=f.mediaduration,
audio_url=f.mediaurls[0],
parse_mode=ParseMode.MARKDOWN_V2,
performer=f.user,
reply_markup=origin_link(f.url),
thumb_url=f.mediathumb,
)
]
else:
results = [
InlineQueryResultGif(
id=uuid4(),
caption=captions(f),
title=f"{f.user}: {f.content}",
gif_url=img,
parse_mode=ParseMode.MARKDOWN_V2,
reply_markup=origin_link(f.url),
thumb_url=img,
) if ".gif" in img else InlineQueryResultPhoto(
id=uuid4(),
caption=captions(f),
title=f.user,
description=f.content,
parse_mode=ParseMode.MARKDOWN_V2,
photo_url=img + "@1280w.jpg",
reply_markup=origin_link(f.url),
thumb_url=img + "@512w_512h.jpg",
) for img in f.mediaurls
]
if len(results) == 1:
results.extend(helpmsg)
inline_query.answer(results)
def audios_mapper(audio):
return InlineQueryResultAudio(id=str(uuid4()),
audio_url=audio['download'],
title=audio["title"],
performer=audio["artist"],
audio_duration=audio["duration"])
def answer_results(f: feed, fallback: bool = False):
if not f.mediaurls:
results = [
InlineQueryResultArticle(
id=str(uuid4()),
title=f.user,
description=f.content,
reply_markup=origin_link(f.url),
input_message_content=InputTextMessageContent(
captions(f, fallback),
parse_mode=None
if fallback else ParseMode.MARKDOWN_V2,
),
)
]
else:
if f.mediatype == "video":
results = [
InlineQueryResultVideo(
id=str(uuid4()),
caption=captions(f, fallback),
title=f.user,
description=f.content,
mime_type="video/mp4",
parse_mode=None
if fallback else ParseMode.MARKDOWN_V2,
reply_markup=origin_link(f.url),
thumb_url=f.mediathumb,
video_url=f.mediaurls[0],
)
]
if f.mediatype == "audio":
results = [
InlineQueryResultAudio(
id=str(uuid4()),
caption=captions(f, fallback),
title=f.mediatitle,
description=f.content,
audio_duration=f.mediaduration,
audio_url=f.mediaurls[0],
parse_mode=None
if fallback else ParseMode.MARKDOWN_V2,
performer=f.user,
reply_markup=origin_link(f.url),
thumb_url=f.mediathumb,
)
]
else:
results = [
InlineQueryResultGif(
id=str(uuid4()),
caption=captions(f, fallback),
title=f"{f.user}: {f.content}",
gif_url=img,
parse_mode=None
if fallback else ParseMode.MARKDOWN_V2,
reply_markup=origin_link(f.url),
thumb_url=img,
) if ".gif" in img else InlineQueryResultPhoto(
id=str(uuid4()),
caption=captions(f, fallback),
title=f.user,
description=f.content,
parse_mode=None
if fallback else ParseMode.MARKDOWN_V2,
photo_url=img + "@1280w.jpg",
reply_markup=origin_link(f.url),
thumb_url=img + "@512w_512h.jpg",
) for img in f.mediaurls
]
results.extend(helpmsg)
inline_query.answer(results)