def inlineinfo(query: str, update: Update, context: CallbackContext) -> None:
"""Handle the inline query."""
bot = context.bot
query = update.inline_query.query
log.info(query)
user_id = update.effective_user.id
try:
search = query.split(" ", 1)[1]
except IndexError:
search = user_id
try:
user = bot.get_chat(int(search))
except (BadRequest, ValueError):
user = bot.get_chat(user_id)
chat = update.effective_chat
sql.update_user(user.id, user.username)
text = (f"<b>General:</b>\n"
f"ID: <code>{user.id}</code>\n"
f"First Name: {html.escape(user.first_name)}")
if user.last_name:
text += f"\nLast Name: {html.escape(user.last_name)}"
if user.username:
text += f"\nUsername: @{html.escape(user.username)}"
text += f"\nPermanent user link: {mention_html(user.id, 'link')}"
try:
spamwtc = sw.get_ban(int(user.id))
if spamwtc:
text += "<b>\n\nSpamWatch:\n</b>"
text += "<b>This person is banned in Spamwatch!</b>"
text += f"\nReason: <pre>{spamwtc.reason}</pre>"
text += "\nAppeal at @SpamWatchSupport"
else:
text += "<b>\n\nSpamWatch:</b>\n Not banned"
except:
pass # don't crash if api is down somehow...
try:
status = client.raw_output(int(user.id))
ptid = status["results"]["private_telegram_id"]
op = status["results"]["attributes"]["is_operator"]
ag = status["results"]["attributes"]["is_agent"]
wl = status["results"]["attributes"]["is_whitelisted"]
ps = status["results"]["attributes"]["is_potential_spammer"]
sp = status["results"]["spam_prediction"]["spam_prediction"]
hamp = status["results"]["spam_prediction"]["ham_prediction"]
blc = status["results"]["attributes"]["is_blacklisted"]
if blc:
blres = status["results"]["attributes"]["blacklist_reason"]
else:
blres = None
text += "\n\n<b>SpamProtection:</b>"
text += f"<b>\nPrivate Telegram ID:</b> <code>{ptid}</code>\n"
text += f"<b>Operator:</b> <code>{op}</code>\n"
text += f"<b>Agent:</b> <code>{ag}</code>\n"
text += f"<b>Whitelisted:</b> <code>{wl}</code>\n"
text += f"<b>Spam Prediction:</b> <code>{sp}</code>\n"
text += f"<b>Ham Prediction:</b> <code>{hamp}</code>\n"
text += f"<b>Potential Spammer:</b> <code>{ps}</code>\n"
text += f"<b>Blacklisted:</b> <code>{blc}</code>\n"
text += f"<b>Blacklist Reason:</b> <code>{blres}</code>\n"
except HostDownError:
text += "\n\n<b>SpamProtection:</b>"
text += "\nCan't connect to Intellivoid SpamProtection API\n"
nation_level_present = False
num_chats = sql.get_user_num_chats(user.id)
text += f"\nChat count: <code>{num_chats}</code>"
if user.id == OWNER_ID:
text += f"\nThis person is my owner"
nation_level_present = True
elif user.id in DEV_USERS:
text += f"\nThis Person is a part of Eagle Union"
nation_level_present = True
elif user.id in SUDO_USERS:
text += f"\nThe Nation level of this person is Royal"
nation_level_present = True
elif user.id in SUPPORT_USERS:
text += f"\nThe Nation level of this person is Sakura"
nation_level_present = True
elif user.id in SARDEGNA_USERS:
text += f"\nThe Nation level of this person is Sardegna"
nation_level_present = True
elif user.id in WHITELIST_USERS:
text += f"\nThe Nation level of this person is Neptunia"
nation_level_present = True
if nation_level_present:
text += ' [<a href="https://t.me/{}?start=nations">?</a>]'.format(
bot.username)
kb = InlineKeyboardMarkup([
[
InlineKeyboardButton(
text="Report Error",
url=f"https://t.me/YorktownEagleUnion",
),
InlineKeyboardButton(
text="Search again",
switch_inline_query_current_chat=".info ",
),
],
])
results = [
InlineQueryResultArticle(
id=str(uuid4()),
title=f"User info of {html.escape(user.first_name)}",
input_message_content=InputTextMessageContent(
text, parse_mode=ParseMode.HTML,
disable_web_page_preview=True),
reply_markup=kb),
]
update.inline_query.answer(results, cache_time=5)
def command_inline(update, context):
'''Process the message from inline query'''
# type(text) is str.
text = update.inline_query.query
text = text.strip()
if len(text) == 0:
return 0
uuid_me = uuid.uuid4()
results = list()
uid = update.inline_query.from_user.id
uid_hash = encrypt.blake2b_hash(str(uid))
if config.maintenance_mode:
results.append(
InlineQueryResultArticle(
id=uuid_me,
title=config.SERVER_ERROR_EXPRESSION,
description=config.MAINTENANCE_EXPRESSION,
input_message_content=InputTextMessageContent(
config.MAINTENANCE_EXPRESSION, parse_mode=ParseMode.HTML)))
try:
update.inline_query.answer(results,
cache_time=60,
is_personal=True)
except Exception:
pass
return 0
if sql.sql_check_user(uid_hash) != 1:
plain_text = 'Sorry, we can\'t decrypt this ciphertext'
results.append(
InlineQueryResultArticle(
id=uuid_me,
title=config.SERVER_ERROR_EXPRESSION,
description=plain_text,
input_message_content=InputTextMessageContent(
config.SERVER_ERROR_EXPRESSION,
parse_mode=ParseMode.HTML)))
try:
update.inline_query.answer(results,
cache_time=60,
is_personal=True)
except Exception:
pass
return 0
if 'seinline[' in text:
try:
cipher_text_hash = text.split('seinline')[1][1:-1]
except IndexError:
return -1
if len(cipher_text_hash) == 0 or not check_string(cipher_text_hash):
return -1
# Check the cipher_text.
cipher_text = sql.sql_get_cipher_text(cipher_text_hash)
# print('commands(cipher_text): ' + cipher_text)
if not cipher_text:
# try:
# bot.editMessageText(
# message_id=update.callback_query.message.message_id,
# chat_id=update.callback_query.message.chat.id,
# text='This ciphertext has expired. %s' % (
# config.GOOD_EXPRESSION),
# parse_mode=ParseMode.HTML,
# # reply_markup=keyboards.inline_chtm_keyboard()
# )
# except Exception:
# pass
results.append(
InlineQueryResultArticle(
id=uuid_me,
title=config.EXPIRE_ERROR_EXPRESSION,
description='please check your input',
input_message_content=InputTextMessageContent(
config.SERVER_ERROR_EXPRESSION,
parse_mode=ParseMode.HTML)))
try:
update.inline_query.answer(results,
cache_time=60,
is_personal=True)
except Exception:
pass
return -1
# Check the plain_text.
plain_text = messages.symmetric_decrypt_inline(update, context,
uid_hash, cipher_text)
# print('commands(plain_text): ' + plain_text)
if not plain_text:
results.append(
InlineQueryResultArticle(
id=uuid_me,
title=config.SERVER_ERROR_EXPRESSION,
description='please check your input',
input_message_content=InputTextMessageContent(
config.SERVER_ERROR_EXPRESSION,
parse_mode=ParseMode.HTML)))
try:
update.inline_query.answer(results,
cache_time=60,
is_personal=True)
except Exception:
pass
return -1
results.append(
InlineQueryResultArticle(
id=uuid_me,
title='De-Result',
description=plain_text,
input_message_content=InputTextMessageContent(
plain_text, parse_mode=ParseMode.HTML)))
try:
update.inline_query.answer(results,
cache_time=60,
is_personal=True)
except Exception:
pass
else:
cipher_text = messages.symmetric_encrypt_inline(
update, context, uid_hash, text)
cipher_text_hash = encrypt.sha256_hash(cipher_text)
if not cipher_text or cipher_text == -1 or not cipher_text_hash:
results.append(
InlineQueryResultArticle(
id=uuid_me,
title=config.SERVER_ERROR_EXPRESSION,
description='please check your input',
input_message_content=InputTextMessageContent(
config.SERVER_ERROR_EXPRESSION,
parse_mode=ParseMode.HTML)))
try:
update.inline_query.answer(results,
cache_time=60,
is_personal=True)
except Exception:
pass
return -1
switch_inline_query_str = 'seinline[%s]' % cipher_text_hash
keyboard = keyboards.inline_keyboard(switch_inline_query_str)
sql.sql_insert_cipher_text(uid_hash, cipher_text_hash, cipher_text)
# Disable the sql_get_emoji_mode in the inline mode.
# if 1 == 2:
if sql.sql_get_emoji_mode(uid_hash):
# if user want to use the emoji encrption.
try:
cipher_data = cipher_text.split('sencrypted')[1][1:-1]
# print(cipher_text)
except IndexError:
return -1
if len(cipher_data) == 0 or not check_string(cipher_data):
return -1
emoji_text = encrypt.convert_str_to_emoji_c(cipher_data)
# print(emoji_text)
# emoji_text = 'sencrypted[%s]' % emoji_text
results.append(
InlineQueryResultArticle(
id=uuid_me,
title='En-Result',
description='id: %s' % str(uuid_me)[0:8],
input_message_content=InputTextMessageContent(
emoji_text, parse_mode=ParseMode.HTML),
reply_markup=keyboard))
try:
update.inline_query.answer(results,
cache_time=60,
is_personal=True)
except Exception:
pass
else:
results.append(
InlineQueryResultArticle(
id=uuid_me,
title='En-Result',
description='id: %s' % str(uuid_me)[0:8],
input_message_content=InputTextMessageContent(
cipher_text, parse_mode=ParseMode.HTML),
reply_markup=keyboard))
try:
update.inline_query.answer(results,
cache_time=60,
is_personal=True)
except Exception:
pass
class TestInlineQueryResultAudio:
id_ = 'id'
type_ = 'audio'
audio_url = 'audio url'
title = 'title'
performer = 'performer'
audio_duration = 'audio_duration'
caption = 'caption'
parse_mode = 'Markdown'
caption_entities = [MessageEntity(MessageEntity.ITALIC, 0, 7)]
input_message_content = InputTextMessageContent('input_message_content')
reply_markup = InlineKeyboardMarkup(
[[InlineKeyboardButton('reply_markup')]])
def test_expected_values(self, inline_query_result_audio):
assert inline_query_result_audio.type == self.type_
assert inline_query_result_audio.id == self.id_
assert inline_query_result_audio.audio_url == self.audio_url
assert inline_query_result_audio.title == self.title
assert inline_query_result_audio.performer == self.performer
assert inline_query_result_audio.audio_duration == self.audio_duration
assert inline_query_result_audio.caption == self.caption
assert inline_query_result_audio.parse_mode == self.parse_mode
assert inline_query_result_audio.caption_entities == self.caption_entities
assert (inline_query_result_audio.input_message_content.to_dict() ==
self.input_message_content.to_dict())
assert inline_query_result_audio.reply_markup.to_dict(
) == self.reply_markup.to_dict()
def test_to_dict(self, inline_query_result_audio):
inline_query_result_audio_dict = inline_query_result_audio.to_dict()
assert isinstance(inline_query_result_audio_dict, dict)
assert inline_query_result_audio_dict[
'type'] == inline_query_result_audio.type
assert inline_query_result_audio_dict[
'id'] == inline_query_result_audio.id
assert inline_query_result_audio_dict[
'audio_url'] == inline_query_result_audio.audio_url
assert inline_query_result_audio_dict[
'title'] == inline_query_result_audio.title
assert inline_query_result_audio_dict[
'performer'] == inline_query_result_audio.performer
assert (inline_query_result_audio_dict['audio_duration'] ==
inline_query_result_audio.audio_duration)
assert inline_query_result_audio_dict[
'caption'] == inline_query_result_audio.caption
assert inline_query_result_audio_dict[
'parse_mode'] == inline_query_result_audio.parse_mode
assert inline_query_result_audio_dict['caption_entities'] == [
ce.to_dict() for ce in inline_query_result_audio.caption_entities
]
assert (inline_query_result_audio_dict['input_message_content'] ==
inline_query_result_audio.input_message_content.to_dict())
assert (inline_query_result_audio_dict['reply_markup'] ==
inline_query_result_audio.reply_markup.to_dict())
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)
class TestInlineQueryResultVenue:
id_ = 'id'
type_ = 'venue'
latitude = 'latitude'
longitude = 'longitude'
title = 'title'
address = 'address'
foursquare_id = 'foursquare id'
foursquare_type = 'foursquare type'
google_place_id = 'google place id'
google_place_type = 'google place type'
thumb_url = 'thumb url'
thumb_width = 10
thumb_height = 15
input_message_content = InputTextMessageContent('input_message_content')
reply_markup = InlineKeyboardMarkup(
[[InlineKeyboardButton('reply_markup')]])
def test_slot_behaviour(self, inline_query_result_venue, mro_slots,
recwarn):
inst = inline_query_result_venue
for attr in inst.__slots__:
assert getattr(inst, attr,
'err') != 'err', f"got extra slot '{attr}'"
assert not inst.__dict__, f"got missing slot(s): {inst.__dict__}"
assert len(mro_slots(inst)) == len(set(
mro_slots(inst))), "duplicate slot"
inst.custom, inst.id = 'should give warning', self.id_
assert len(recwarn) == 1 and 'custom' in str(
recwarn[0].message), recwarn.list
def test_expected_values(self, inline_query_result_venue):
assert inline_query_result_venue.id == self.id_
assert inline_query_result_venue.type == self.type_
assert inline_query_result_venue.latitude == self.latitude
assert inline_query_result_venue.longitude == self.longitude
assert inline_query_result_venue.title == self.title
assert inline_query_result_venue.address == self.address
assert inline_query_result_venue.foursquare_id == self.foursquare_id
assert inline_query_result_venue.foursquare_type == self.foursquare_type
assert inline_query_result_venue.google_place_id == self.google_place_id
assert inline_query_result_venue.google_place_type == self.google_place_type
assert inline_query_result_venue.thumb_url == self.thumb_url
assert inline_query_result_venue.thumb_width == self.thumb_width
assert inline_query_result_venue.thumb_height == self.thumb_height
assert (inline_query_result_venue.input_message_content.to_dict() ==
self.input_message_content.to_dict())
assert inline_query_result_venue.reply_markup.to_dict(
) == self.reply_markup.to_dict()
def test_to_dict(self, inline_query_result_venue):
inline_query_result_venue_dict = inline_query_result_venue.to_dict()
assert isinstance(inline_query_result_venue_dict, dict)
assert inline_query_result_venue_dict[
'id'] == inline_query_result_venue.id
assert inline_query_result_venue_dict[
'type'] == inline_query_result_venue.type
assert inline_query_result_venue_dict[
'latitude'] == inline_query_result_venue.latitude
assert inline_query_result_venue_dict[
'longitude'] == inline_query_result_venue.longitude
assert inline_query_result_venue_dict[
'title'] == inline_query_result_venue.title
assert inline_query_result_venue_dict[
'address'] == inline_query_result_venue.address
assert (inline_query_result_venue_dict['foursquare_id'] ==
inline_query_result_venue.foursquare_id)
assert (inline_query_result_venue_dict['foursquare_type'] ==
inline_query_result_venue.foursquare_type)
assert (inline_query_result_venue_dict['google_place_id'] ==
inline_query_result_venue.google_place_id)
assert (inline_query_result_venue_dict['google_place_type'] ==
inline_query_result_venue.google_place_type)
assert inline_query_result_venue_dict[
'thumb_url'] == inline_query_result_venue.thumb_url
assert (inline_query_result_venue_dict['thumb_width'] ==
inline_query_result_venue.thumb_width)
assert (inline_query_result_venue_dict['thumb_height'] ==
inline_query_result_venue.thumb_height)
assert (inline_query_result_venue_dict['input_message_content'] ==
inline_query_result_venue.input_message_content.to_dict())
assert (inline_query_result_venue_dict['reply_markup'] ==
inline_query_result_venue.reply_markup.to_dict())
def test_equality(self):
a = InlineQueryResultVenue(self.id_, self.longitude, self.latitude,
self.title, self.address)
b = InlineQueryResultVenue(self.id_, self.longitude, self.latitude,
self.title, self.address)
c = InlineQueryResultVenue(self.id_, '', self.latitude, self.title,
self.address)
d = InlineQueryResultVenue('', self.longitude, self.latitude,
self.title, self.address)
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)
class TestInlineQueryResultCachedPhoto:
id_ = 'id'
type_ = 'photo'
photo_file_id = 'photo file id'
title = 'title'
description = 'description'
caption = 'caption'
parse_mode = 'HTML'
input_message_content = InputTextMessageContent('input_message_content')
reply_markup = InlineKeyboardMarkup(
[[InlineKeyboardButton('reply_markup')]])
def test_expected_values(self, inline_query_result_cached_photo):
assert inline_query_result_cached_photo.type == self.type_
assert inline_query_result_cached_photo.id == self.id_
assert inline_query_result_cached_photo.photo_file_id == self.photo_file_id
assert inline_query_result_cached_photo.title == self.title
assert inline_query_result_cached_photo.description == self.description
assert inline_query_result_cached_photo.caption == self.caption
assert inline_query_result_cached_photo.parse_mode == self.parse_mode
assert (inline_query_result_cached_photo.input_message_content.to_dict(
) == self.input_message_content.to_dict())
assert (inline_query_result_cached_photo.reply_markup.to_dict() ==
self.reply_markup.to_dict())
def test_to_dict(self, inline_query_result_cached_photo):
inline_query_result_cached_photo_dict = inline_query_result_cached_photo.to_dict(
)
assert isinstance(inline_query_result_cached_photo_dict, dict)
assert (inline_query_result_cached_photo_dict['type'] ==
inline_query_result_cached_photo.type)
assert inline_query_result_cached_photo_dict[
'id'] == inline_query_result_cached_photo.id
assert (inline_query_result_cached_photo_dict['photo_file_id'] ==
inline_query_result_cached_photo.photo_file_id)
assert (inline_query_result_cached_photo_dict['title'] ==
inline_query_result_cached_photo.title)
assert (inline_query_result_cached_photo_dict['description'] ==
inline_query_result_cached_photo.description)
assert (inline_query_result_cached_photo_dict['caption'] ==
inline_query_result_cached_photo.caption)
assert (inline_query_result_cached_photo_dict['parse_mode'] ==
inline_query_result_cached_photo.parse_mode)
assert (
inline_query_result_cached_photo_dict['input_message_content'] ==
inline_query_result_cached_photo.input_message_content.to_dict())
assert (inline_query_result_cached_photo_dict['reply_markup'] ==
inline_query_result_cached_photo.reply_markup.to_dict())
def test_equality(self):
a = InlineQueryResultCachedPhoto(self.id_, self.photo_file_id)
b = InlineQueryResultCachedPhoto(self.id_, self.photo_file_id)
c = InlineQueryResultCachedPhoto(self.id_, '')
d = InlineQueryResultCachedPhoto('', self.photo_file_id)
e = InlineQueryResultCachedVoice(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)
class TestInlineQueryResultArticle:
id_ = 'id'
type_ = 'article'
title = 'title'
input_message_content = InputTextMessageContent('input_message_content')
reply_markup = InlineKeyboardMarkup([[InlineKeyboardButton('reply_markup')]])
url = 'url'
hide_url = True
description = 'description'
thumb_url = 'thumb url'
thumb_height = 10
thumb_width = 15
def test_slot_behaviour(self, inline_query_result_article, mro_slots, recwarn):
inst = inline_query_result_article
for attr in inst.__slots__:
assert getattr(inst, attr, 'err') != 'err', f"got extra slot '{attr}'"
assert not inst.__dict__, f"got missing slot(s): {inst.__dict__}"
assert len(mro_slots(inst)) == len(set(mro_slots(inst))), "duplicate slot"
inst.custom, inst.id = 'should give warning', self.id_
assert len(recwarn) == 1 and 'custom' in str(recwarn[0].message), recwarn.list
def test_expected_values(self, inline_query_result_article):
assert inline_query_result_article.type == self.type_
assert inline_query_result_article.id == self.id_
assert inline_query_result_article.title == self.title
assert (
inline_query_result_article.input_message_content.to_dict()
== self.input_message_content.to_dict()
)
assert inline_query_result_article.reply_markup.to_dict() == self.reply_markup.to_dict()
assert inline_query_result_article.url == self.url
assert inline_query_result_article.hide_url == self.hide_url
assert inline_query_result_article.description == self.description
assert inline_query_result_article.thumb_url == self.thumb_url
assert inline_query_result_article.thumb_height == self.thumb_height
assert inline_query_result_article.thumb_width == self.thumb_width
def test_to_dict(self, inline_query_result_article):
inline_query_result_article_dict = inline_query_result_article.to_dict()
assert isinstance(inline_query_result_article_dict, dict)
assert inline_query_result_article_dict['type'] == inline_query_result_article.type
assert inline_query_result_article_dict['id'] == inline_query_result_article.id
assert inline_query_result_article_dict['title'] == inline_query_result_article.title
assert (
inline_query_result_article_dict['input_message_content']
== inline_query_result_article.input_message_content.to_dict()
)
assert (
inline_query_result_article_dict['reply_markup']
== inline_query_result_article.reply_markup.to_dict()
)
assert inline_query_result_article_dict['url'] == inline_query_result_article.url
assert inline_query_result_article_dict['hide_url'] == inline_query_result_article.hide_url
assert (
inline_query_result_article_dict['description']
== inline_query_result_article.description
)
assert (
inline_query_result_article_dict['thumb_url'] == inline_query_result_article.thumb_url
)
assert (
inline_query_result_article_dict['thumb_height']
== inline_query_result_article.thumb_height
)
assert (
inline_query_result_article_dict['thumb_width']
== inline_query_result_article.thumb_width
)
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)
class TestInlineQueryResultContact(object):
id = 'id'
type = 'contact'
phone_number = 'phone_number'
first_name = 'first_name'
last_name = 'last_name'
thumb_url = 'thumb url'
thumb_width = 10
thumb_height = 15
input_message_content = InputTextMessageContent('input_message_content')
reply_markup = InlineKeyboardMarkup(
[[InlineKeyboardButton('reply_markup')]])
def test_expected_values(self, inline_query_result_contact):
assert inline_query_result_contact.id == self.id
assert inline_query_result_contact.type == self.type
assert inline_query_result_contact.phone_number == self.phone_number
assert inline_query_result_contact.first_name == self.first_name
assert inline_query_result_contact.last_name == self.last_name
assert inline_query_result_contact.thumb_url == self.thumb_url
assert inline_query_result_contact.thumb_width == self.thumb_width
assert inline_query_result_contact.thumb_height == self.thumb_height
assert inline_query_result_contact.input_message_content.to_dict() == \
self.input_message_content.to_dict()
assert inline_query_result_contact.reply_markup.to_dict(
) == self.reply_markup.to_dict()
def test_to_dict(self, inline_query_result_contact):
inline_query_result_contact_dict = inline_query_result_contact.to_dict(
)
assert isinstance(inline_query_result_contact_dict, dict)
assert inline_query_result_contact_dict[
'id'] == inline_query_result_contact.id
assert inline_query_result_contact_dict[
'type'] == inline_query_result_contact.type
assert inline_query_result_contact_dict['phone_number'] == \
inline_query_result_contact.phone_number
assert inline_query_result_contact_dict['first_name'] == \
inline_query_result_contact.first_name
assert inline_query_result_contact_dict['last_name'] == \
inline_query_result_contact.last_name
assert inline_query_result_contact_dict['thumb_url'] == \
inline_query_result_contact.thumb_url
assert inline_query_result_contact_dict['thumb_width'] == \
inline_query_result_contact.thumb_width
assert inline_query_result_contact_dict['thumb_height'] == \
inline_query_result_contact.thumb_height
assert inline_query_result_contact_dict['input_message_content'] == \
inline_query_result_contact.input_message_content.to_dict()
assert inline_query_result_contact_dict['reply_markup'] == \
inline_query_result_contact.reply_markup.to_dict()
def test_equality(self):
a = InlineQueryResultContact(self.id, self.phone_number,
self.first_name)
b = InlineQueryResultContact(self.id, self.phone_number,
self.first_name)
c = InlineQueryResultContact(self.id, '', self.first_name)
d = InlineQueryResultContact('', self.phone_number, self.first_name)
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 search(update, context):
infos_user = update.effective_user
chat_id = infos_user.id
infos_query = update.inline_query
query_string = infos_query.query
query_id = infos_query.id
if not authorized(chat_id):
return
try:
tongue = infos_user.language_code
except AttributeError:
tongue = "en"
init_user(chat_id, tongue)
if ".chart." == query_string:
search1 = request(api_chart).json()
result = [
InlineQueryResultArticle(
id=a['link'],
title=a['title'],
description=("Artist: {}\nAlbum: {}".format(
a['artist']['name'], a['album']['title'])),
thumb_url=a['album']['cover_big'],
input_message_content=InputTextMessageContent(a['link']))
for a in search1['tracks']['data']
]
result += [
InlineQueryResultArticle(
id="https://www.deezer.com/album/%d" % a['id'],
title="%s (Album)" % a['title'],
description=("Artist: {}\nPosition: {}".format(
a['artist']['name'], a['position'])),
thumb_url=a['cover_big'],
input_message_content=InputTextMessageContent(
"https://www.deezer.com/album/%d" % a['id']))
for a in search1['albums']['data']
]
result += [
InlineQueryResultArticle(
id=a['link'],
title=a['name'],
description="Position: %d" % a['position'],
thumb_url=a['picture_big'],
input_message_content=InputTextMessageContent(a['link']))
for a in search1['artists']['data']
]
result += [
InlineQueryResultArticle(
id=a['link'],
title=a['title'],
description=("N° tracks: {}\nUser: {}".format(
a['nb_tracks'], a['user']['name'])),
thumb_url=a['picture_big'],
input_message_content=InputTextMessageContent(a['link']))
for a in search1['playlists']['data']
]
else:
query_string = query_string.replace("#", "")
search = query_string
method = ""
if "alb:" in query_string or "art:" in query_string or "pla:" in query_string:
search = query_string.split(query_string[:4])[-1]
if "alb:" in query_string:
method = "album"
elif "art:" in query_string:
method = "artist"
elif "pla:" in query_string:
method = "playlist"
search1 = request(api_type1.format(method, search)).json()
try:
if search1['error']:
return
except KeyError:
pass
if "alb:" in query_string:
result = [
InlineQueryResultArticle(
id=a['link'],
title=a['title'],
description=("Artist: {}\nTracks: {}".format(
a['artist']['name'], a['nb_tracks'])),
thumb_url=a['cover_big'],
input_message_content=InputTextMessageContent(
a['link'])) for a in search1['data']
]
elif "art:" in query_string:
result = [
InlineQueryResultArticle(
id=a['link'],
title=a['name'],
description=("Albums: {}\nFollowers: {}".format(
a['nb_album'], a['nb_fan'])),
thumb_url=a['picture_big'],
input_message_content=InputTextMessageContent(
a['link'])) for a in search1['data']
]
elif "pla:" in query_string:
result = [
InlineQueryResultArticle(
id=a['link'],
title=a['title'],
description=("N° tracks: {}\nUser: {}".format(
a['nb_tracks'], a['user']['name'])),
thumb_url=a['picture_big'],
input_message_content=InputTextMessageContent(
a['link'])) for a in search1['data']
]
else:
if "lbl:" in query_string or "trk:" in query_string:
search = query_string.split(query_string[:4])[-1]
if "lbl:" in query_string:
method = "label"
elif "trk:" in query_string:
method = "track"
search1 = request(api_type2.format(method, search)).json()
try:
if search1['error']:
return
except KeyError:
pass
result = [
InlineQueryResultArticle(
id=a['link'],
title=a['title'],
description=("Artist: {}\nAlbum: {}".format(
a['artist']['name'], a['album']['title'])),
thumb_url=a['album']['cover_big'],
input_message_content=InputTextMessageContent(a['link']))
for a in search1['data']
]
already = []
for a in search1['data']:
ids = a['album']['id']
if not ids in already:
result += [
InlineQueryResultArticle(
id=ids,
title="%s (Album)" % a['album']['title'],
description=a['artist']['name'],
thumb_url=a['album']['cover_big'],
input_message_content=InputTextMessageContent(
"https://www.deezer.com/album/%d" %
a['album']['id']))
]
already.append(ids)
try:
bot.answerInlineQuery(query_id, result)
except (error.BadRequest, error.TimedOut):
pass
def inlinequery(update, context):
"""Handles the inline query."""
query = update.inline_query.query
buttons = [[
InlineKeyboardButton(text="Search Again",
switch_inline_query_current_chat="")
]]
if len(query) == 0:
results = [
InlineQueryResultArticle(
id=uuid4(),
title="Search any keyword",
input_message_content=InputTextMessageContent(
f"*Search any torrent\nExample : *`Avengers`\n\n{FOOTER_TEXT}",
parse_mode="Markdown"),
reply_markup=InlineKeyboardMarkup(buttons))
]
context.bot.answer_inline_query(update.inline_query.id,
results=results)
return
print(len(query))
torrent = torrent_search(query)
results = []
if torrent == None:
results.append(
InlineQueryResultArticle(
id=uuid4(),
title="Search any keyword",
input_message_content=InputTextMessageContent(
f"*Search any torrent\nExample🤖🤖 : *`Avengers`\n\n{FOOTER_TEXT}",
parse_mode="Markdown"),
reply_markup=InlineKeyboardMarkup(buttons)))
context.bot.answer_inline_query(update.inline_query.id,
results=results)
return
if len(torrent) == 0:
results.append(
InlineQueryResultArticle(
id=uuid4(),
title="404 Not Found",
input_message_content=InputTextMessageContent(
f"*Sorry there is no results for your query rip⚰️⚰️ {query}*\n\n{FOOTER_TEXT}",
parse_mode="Markdown"),
reply_markup=InlineKeyboardMarkup(buttons)))
context.bot.answer_inline_query(update.inline_query.id,
results=results)
return
for response in torrent[:15]:
name = response.get("name")
age = response.get("age")
leechers = response.get("leecher")
magnet_link = response.get("magnet")
seeders = response.get("seeder")
size = response.get("size")
type_of_file = response.get("type")
site = response.get("site")
torrent_url = response.get("url")
results.append(
InlineQueryResultArticle(
id=uuid4(),
title=name,
input_message_content=InputTextMessageContent(
f"*Name : {name}\nSize : {size}\nAge : {age}\nLeechers : {leechers}\nNo: of seeds : {seeders}\nType of File : {type_of_file}\nTorrent Url : {torrent_url}*\n\n*Magnet Link : *`{magnet_link}`\n\n*Powered by {site} website*\n\n{FOOTER_TEXT}",
parse_mode="Markdown"),
reply_markup=InlineKeyboardMarkup(buttons)))
context.bot.answer_inline_query(update.inline_query.id, results=results)
def inlinequery(bot, update):
query = update.inline_query.query
res = list()
if len(query) < 3:
bot.answerInlineQuery(update.inline_query.id, results=res)
return
print(query)
subreddit = None
try:
subreddit = reddit.get_subreddit(query)
subreddit.fullname
except:
logger.warning('invalid subreddit: %s' % query)
bot.answerInlineQuery(update.inline_query.id, results=res)
return
submissions = subreddit.get_hot(limit=25)
for sub in submissions:
offset = sub.name
link_url = sub.url
try:
if 'imgur' in sub.url:
m = re.search('imgur\.com\/(\w*)', sub.url)
# geen albums (imgur.com/a/)
if len(m.group(1) > 2):
link_url = 'https://i.imgur.com/' + m.group(1) + '.jpg'
except:
# voor het geval dat
pass
message = '<strong>{title}</strong> \n <a href="{url}">link</a> | <a href="https://www.reddit.com/r/{subreddit}">/r/{subreddit}</a> | <a href="{link}">permalink</a>'.format(
title=html.escape(sub.title),
url=html.escape(link_url),
subreddit=sub.subreddit,
link=sub.permalink)
qwe = InlineQueryResultArticle(
id=uuid4(),
title=sub.title,
input_message_content=InputTextMessageContent(
message, parse_mode=ParseMode.HTML))
thumbnail = ''
if hasattr(sub, 'preview'):
thumbnail = sub.preview['images'][0]['source']['url']
try:
if sub.secure_media != None:
thumbnail = sub.secure_media['oembed']['thumbnail_url']
except:
# jammer
pass
qwe.thumb_url = thumbnail
res.append(qwe)
bot.answerInlineQuery(update.inline_query.id,
results=res,
cache_time=CACHE_TIME)
def search(bot, update, session, user):
"""Handle inline queries for sticker search."""
query = update.inline_query.query.strip()
# Also search for closed polls if the `closed_polls` keyword is found
closed = False
if 'closed_polls' in query:
closed = True
query = query.replace('closed_polls', '').strip()
offset = update.inline_query.offset
if offset == '':
offset = 0
else:
offset = int(offset)
if query == '':
# Just display all polls
polls = session.query(Poll) \
.filter(Poll.user == user) \
.filter(Poll.closed.is_(closed)) \
.filter(Poll.created.is_(True)) \
.order_by(Poll.created_at.desc()) \
.limit(10) \
.offset(offset) \
.all()
else:
# Find polls with search parameter in name or description
polls = session.query(Poll) \
.filter(Poll.user == user) \
.filter(Poll.closed.is_(closed)) \
.filter(Poll.created.is_(True)) \
.filter(or_(
Poll.name.ilike(f'%{query}%'),
Poll.description.ilike(f'%{query}%'),
)) \
.order_by(Poll.created_at.desc()) \
.limit(10) \
.offset(offset) \
.all()
# Try to find polls that are shared by external people via uuid
if len(polls) == 0 and len(query) == 36:
try:
poll_uuid = uuid.UUID(query)
polls = session.query(Poll) \
.filter(Poll.uuid == poll_uuid) \
.all()
except ValueError:
pass
if len(polls) == 0:
update.inline_query.answer(
[],
cache_time=0,
is_personal=True,
)
else:
results = []
for poll in polls:
text, keyboard = get_poll_text_and_vote_keyboard(session,
poll,
user=user,
inline_query=True)
keyboard = InlineKeyboardMarkup([[
InlineKeyboardButton('Please ignore this',
callback_data='100:0:0')
]])
content = InputTextMessageContent(
text,
parse_mode='markdown',
disable_web_page_preview=True,
)
description = poll.description[:
100] if poll.description is not None else None
results.append(
InlineQueryResultArticle(
poll.id,
poll.name,
description=description,
input_message_content=content,
reply_markup=keyboard,
))
update.inline_query.answer(
results,
cache_time=0,
is_personal=True,
next_offset=str(offset + 10),
)
class TestInlineQueryResultMpeg4Gif:
id_ = 'id'
type_ = 'mpeg4_gif'
mpeg4_url = 'mpeg4 url'
mpeg4_width = 10
mpeg4_height = 15
mpeg4_duration = 1
thumb_url = 'thumb url'
thumb_mime_type = 'image/jpeg'
title = 'title'
caption = 'caption'
parse_mode = 'Markdown'
caption_entities = [MessageEntity(MessageEntity.ITALIC, 0, 7)]
input_message_content = InputTextMessageContent('input_message_content')
reply_markup = InlineKeyboardMarkup([[InlineKeyboardButton('reply_markup')]])
def test_slot_behaviour(self, inline_query_result_mpeg4_gif, recwarn, mro_slots):
inst = inline_query_result_mpeg4_gif
for attr in inst.__slots__:
assert getattr(inst, attr, 'err') != 'err', f"got extra slot '{attr}'"
assert not inst.__dict__, f"got missing slot(s): {inst.__dict__}"
assert len(mro_slots(inst)) == len(set(mro_slots(inst))), "duplicate slot"
inst.custom, inst.id = 'should give warning', self.id_
assert len(recwarn) == 1 and 'custom' in str(recwarn[0].message), recwarn.list
def test_expected_values(self, inline_query_result_mpeg4_gif):
assert inline_query_result_mpeg4_gif.type == self.type_
assert inline_query_result_mpeg4_gif.id == self.id_
assert inline_query_result_mpeg4_gif.mpeg4_url == self.mpeg4_url
assert inline_query_result_mpeg4_gif.mpeg4_width == self.mpeg4_width
assert inline_query_result_mpeg4_gif.mpeg4_height == self.mpeg4_height
assert inline_query_result_mpeg4_gif.mpeg4_duration == self.mpeg4_duration
assert inline_query_result_mpeg4_gif.thumb_url == self.thumb_url
assert inline_query_result_mpeg4_gif.thumb_mime_type == self.thumb_mime_type
assert inline_query_result_mpeg4_gif.title == self.title
assert inline_query_result_mpeg4_gif.caption == self.caption
assert inline_query_result_mpeg4_gif.parse_mode == self.parse_mode
assert inline_query_result_mpeg4_gif.caption_entities == self.caption_entities
assert (
inline_query_result_mpeg4_gif.input_message_content.to_dict()
== self.input_message_content.to_dict()
)
assert inline_query_result_mpeg4_gif.reply_markup.to_dict() == self.reply_markup.to_dict()
def test_to_dict(self, inline_query_result_mpeg4_gif):
inline_query_result_mpeg4_gif_dict = inline_query_result_mpeg4_gif.to_dict()
assert isinstance(inline_query_result_mpeg4_gif_dict, dict)
assert inline_query_result_mpeg4_gif_dict['type'] == inline_query_result_mpeg4_gif.type
assert inline_query_result_mpeg4_gif_dict['id'] == inline_query_result_mpeg4_gif.id
assert (
inline_query_result_mpeg4_gif_dict['mpeg4_url']
== inline_query_result_mpeg4_gif.mpeg4_url
)
assert (
inline_query_result_mpeg4_gif_dict['mpeg4_width']
== inline_query_result_mpeg4_gif.mpeg4_width
)
assert (
inline_query_result_mpeg4_gif_dict['mpeg4_height']
== inline_query_result_mpeg4_gif.mpeg4_height
)
assert (
inline_query_result_mpeg4_gif_dict['mpeg4_duration']
== inline_query_result_mpeg4_gif.mpeg4_duration
)
assert (
inline_query_result_mpeg4_gif_dict['thumb_url']
== inline_query_result_mpeg4_gif.thumb_url
)
assert (
inline_query_result_mpeg4_gif_dict['thumb_mime_type']
== inline_query_result_mpeg4_gif.thumb_mime_type
)
assert inline_query_result_mpeg4_gif_dict['title'] == inline_query_result_mpeg4_gif.title
assert (
inline_query_result_mpeg4_gif_dict['caption'] == inline_query_result_mpeg4_gif.caption
)
assert (
inline_query_result_mpeg4_gif_dict['parse_mode']
== inline_query_result_mpeg4_gif.parse_mode
)
assert inline_query_result_mpeg4_gif_dict['caption_entities'] == [
ce.to_dict() for ce in inline_query_result_mpeg4_gif.caption_entities
]
assert (
inline_query_result_mpeg4_gif_dict['input_message_content']
== inline_query_result_mpeg4_gif.input_message_content.to_dict()
)
assert (
inline_query_result_mpeg4_gif_dict['reply_markup']
== inline_query_result_mpeg4_gif.reply_markup.to_dict()
)
def test_equality(self):
a = InlineQueryResultMpeg4Gif(self.id_, self.mpeg4_url, self.thumb_url)
b = InlineQueryResultMpeg4Gif(self.id_, self.mpeg4_url, self.thumb_url)
c = InlineQueryResultMpeg4Gif(self.id_, '', self.thumb_url)
d = InlineQueryResultMpeg4Gif('', self.mpeg4_url, self.thumb_url)
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 media_query(query: str, update: Update, context: CallbackContext) -> None:
"""
Handle anime inline query.
"""
results: List = []
try:
results: List = []
r = requests.post('https://graphql.anilist.co',
data=json.dumps({
'query': MEDIA_QUERY,
'variables': {
'search': query
}
}),
headers={
'Content-Type': 'application/json',
'Accept': 'application/json'
})
res = r.json()
data = res['data']['Page']['media']
res = data
for data in res:
title_en = data["title"].get("english") or "N/A"
title_ja = data["title"].get("romaji") or "N/A"
format = data.get("format") or "N/A"
type = data.get("type") or "N/A"
bannerimg = data.get(
"bannerImage"
) or "https://telegra.ph/file/cc83a0b7102ad1d7b1cb3.jpg"
try:
des = data.get("description").replace("<br>",
"").replace("</br>", "")
description = des.replace("<i>", "").replace("</i>",
"") or "N/A"
except AttributeError:
description = data.get("description")
try:
description = html.escape(description)
except AttributeError:
description = description or "N/A"
if len((str(description))) > 700:
description = description[0:700] + "....."
avgsc = data.get("averageScore") or "N/A"
status = data.get("status") or "N/A"
genres = data.get("genres") or "N/A"
genres = ", ".join(genres)
img = f"https://img.anili.st/media/{data['id']}" or "https://telegra.ph/file/cc83a0b7102ad1d7b1cb3.jpg"
aurl = data.get("siteUrl")
kb = InlineKeyboardMarkup([
[
InlineKeyboardButton(
text="Read More",
url=aurl,
),
InlineKeyboardButton(
text="Search again",
switch_inline_query_current_chat=".anilist ",
),
],
])
txt = f"<b>{title_en} | {title_ja}</b>\n"
txt += f"<b>Format</b>: <code>{format}</code>\n"
txt += f"<b>Type</b>: <code>{type}</code>\n"
txt += f"<b>Average Score</b>: <code>{avgsc}</code>\n"
txt += f"<b>Status</b>: <code>{status}</code>\n"
txt += f"<b>Genres</b>: <code>{genres}</code>\n"
txt += f"<b>Description</b>: <code>{description}</code>\n"
txt += f"<a href='{img}'>­</a>"
results.append(
InlineQueryResultArticle(
id=str(uuid4()),
title=f"{title_en} | {title_ja} | {format}",
thumb_url=img,
description=f"{description}",
input_message_content=InputTextMessageContent(
txt,
parse_mode=ParseMode.HTML,
disable_web_page_preview=False),
reply_markup=kb))
except Exception as e:
kb = InlineKeyboardMarkup([
[
InlineKeyboardButton(
text="Report error",
url="t.me/YorktownEagleUnion",
),
InlineKeyboardButton(
text="Search again",
switch_inline_query_current_chat=".anilist ",
),
],
])
results.append(
InlineQueryResultArticle(
id=str(uuid4()),
title=f"Media {query} not found",
input_message_content=InputTextMessageContent(
f"Media {query} not found due to {e}",
parse_mode=ParseMode.MARKDOWN,
disable_web_page_preview=True),
reply_markup=kb))
update.inline_query.answer(results, cache_time=5)
def spb(query: str, update: Update, context: CallbackContext) -> None:
"""Handle the inline query."""
query = update.inline_query.query
user_id = update.effective_user.id
try:
search = query.split(" ", 1)[1]
except IndexError:
search = user_id
if search:
srdata = search
else:
srdata = user_id
url = f"https://api.intellivoid.net/spamprotection/v1/lookup?query={srdata}"
r = requests.get(url)
a = r.json()
response = a["success"]
if response is True:
date = a["results"]["last_updated"]
stats = f"*◢ Intellivoid• SpamProtection Info*:\n"
stats += f' • *Updated on*: `{datetime.fromtimestamp(date).strftime("%Y-%m-%d %I:%M:%S %p")}`\n'
if a["results"]["attributes"]["is_potential_spammer"] is True:
stats += f" • *User*: `USERxSPAM`\n"
elif a["results"]["attributes"]["is_operator"] is True:
stats += f" • *User*: `USERxOPERATOR`\n"
elif a["results"]["attributes"]["is_agent"] is True:
stats += f" • *User*: `USERxAGENT`\n"
elif a["results"]["attributes"]["is_whitelisted"] is True:
stats += f" • *User*: `USERxWHITELISTED`\n"
stats += f' • *Type*: `{a["results"]["entity_type"]}`\n'
stats += (
f' • *Language*: `{a["results"]["language_prediction"]["language"]}`\n'
)
stats += f' • *Language Probability*: `{a["results"]["language_prediction"]["probability"]}`\n'
stats += f"*Spam Prediction*:\n"
stats += f' • *Ham Prediction*: `{a["results"]["spam_prediction"]["ham_prediction"]}`\n'
stats += f' • *Spam Prediction*: `{a["results"]["spam_prediction"]["spam_prediction"]}`\n'
stats += f'*Blacklisted*: `{a["results"]["attributes"]["is_blacklisted"]}`\n'
if a["results"]["attributes"]["is_blacklisted"] is True:
stats += (
f' • *Reason*: `{a["results"]["attributes"]["blacklist_reason"]}`\n'
)
stats += f' • *Flag*: `{a["results"]["attributes"]["blacklist_flag"]}`\n'
stats += f'*PTID*:\n`{a["results"]["private_telegram_id"]}`\n'
else:
stats = "`cannot reach SpamProtection API`"
kb = InlineKeyboardMarkup([
[
InlineKeyboardButton(
text="Report Error",
url=f"https://t.me/YorktownEagleUnion",
),
InlineKeyboardButton(
text="Search again",
switch_inline_query_current_chat=".spb ",
),
],
])
results = [
InlineQueryResultArticle(id=str(uuid4()),
title=f"SpamProtection API info of {srdata}",
input_message_content=InputTextMessageContent(
stats,
parse_mode=ParseMode.MARKDOWN,
disable_web_page_preview=True),
reply_markup=kb),
]
update.inline_query.answer(results, cache_time=5)
class TestInlineQueryResultCachedVideo(object):
id = 'id'
type = 'video'
video_file_id = 'video file id'
title = 'title'
caption = 'caption'
description = 'description'
input_message_content = InputTextMessageContent('input_message_content')
reply_markup = InlineKeyboardMarkup([[InlineKeyboardButton('reply_markup')]])
def test_expected_values(self, inline_query_result_cached_video):
assert inline_query_result_cached_video.type == self.type
assert inline_query_result_cached_video.id == self.id
assert inline_query_result_cached_video.video_file_id == self.video_file_id
assert inline_query_result_cached_video.title == self.title
assert inline_query_result_cached_video.description == self.description
assert inline_query_result_cached_video.caption == self.caption
assert inline_query_result_cached_video.input_message_content.to_dict() == \
self.input_message_content.to_dict()
assert inline_query_result_cached_video.reply_markup.to_dict() == \
self.reply_markup.to_dict()
def test_to_dict(self, inline_query_result_cached_video):
inline_query_result_cached_video_dict = inline_query_result_cached_video.to_dict()
assert isinstance(inline_query_result_cached_video_dict, dict)
assert inline_query_result_cached_video_dict['type'] == \
inline_query_result_cached_video.type
assert inline_query_result_cached_video_dict['id'] == inline_query_result_cached_video.id
assert inline_query_result_cached_video_dict['video_file_id'] == \
inline_query_result_cached_video.video_file_id
assert inline_query_result_cached_video_dict['title'] == \
inline_query_result_cached_video.title
assert inline_query_result_cached_video_dict['description'] == \
inline_query_result_cached_video.description
assert inline_query_result_cached_video_dict['caption'] == \
inline_query_result_cached_video.caption
assert inline_query_result_cached_video_dict['input_message_content'] == \
inline_query_result_cached_video.input_message_content.to_dict()
assert inline_query_result_cached_video_dict['reply_markup'] == \
inline_query_result_cached_video.reply_markup.to_dict()
def test_equality(self):
a = InlineQueryResultCachedVideo(self.id, self.video_file_id, self.title)
b = InlineQueryResultCachedVideo(self.id, self.video_file_id, self.title)
c = InlineQueryResultCachedVideo(self.id, '', self.title)
d = InlineQueryResultCachedVideo('', self.video_file_id, self.title)
e = InlineQueryResultCachedVoice(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):
"""Handle the inline query.
Example of api_results:
>>> results_parsed = [{
>>> "result_id": 0,
>>> "name": "Молоко М Лианозовское ультрапастеризованное 3,2%, 950г",
>>> "img_url": "https://www.utkonos.ru/images/photo/3074/3074902H.jpg"
>>> }]
"""
inline_bot_type = None
results = []
if ':' in update.inline_query.query:
query = update.inline_query.query.split(':')
inline_bot_type = query[0]
if len(query) > 1:
query = query[1].strip()
else:
query = ''
else:
query = update.inline_query.query
if inline_bot_type == 'Каталог':
# api_results = get_product_inline_by_name(query)
api_results = api_request(query)
results = []
for result_ in api_results:
bar_code = 'Арт. %s' % result_['art']
# bar_code = result_['ean'] if result_['ean'] is not None else \
# result_['upc'] if result_['upc'] is not None else str(0)
results.append(
InlineQueryResultArticle(
id=uuid4(),
title=result_['name'],
thumb_url=result_['img_url'],
input_message_content=InputTextMessageContent(
'%s %s' % (bar_code, result_['name'])))
# input_message_content=InputTextMessageContent(result_['name']))
# result_['name']))
# result_['name'])
#
)
results = results + [
InlineQueryResultArticle(
id=uuid4(),
title="Здесь нет моего продукта",
# thumb_url=result_['img_url'],
input_message_content=InputTextMessageContent(
"000 Здесь нет моего продукта"))
]
elif inline_bot_type == 'Упаковки':
api_results = get_all_wrappings()
results = []
for result_ in api_results:
results.append(
InlineQueryResultArticle(
id=uuid4(),
title=result_['name'],
description=result_['description'],
thumb_url=result_['img_url'],
input_message_content=InputTextMessageContent(
'%s. %s' % (result_['id'], result_['name'])))
# result_['name']))
# result_['name'])
#
)
update.inline_query.answer(results)
def inlinequery(bot, update):
"""Handle the inline query."""
#So I type "@Mc125_Bot" followed by a space...
query = update.inline_query.query
#...and these are the things that pop out!
results = [
InlineQueryResultArticle(
id=uuid4(),
title="The Howard Diner",
input_message_content=InputTextMessageContent(
"https://hamilton.cafebonappetit.com/cafe/the-howard-diner/",
parse_mode=ParseMode.MARKDOWN),
description="Diner Food!",
thumb_url=
"https://hamilton.cafebonappetit.com/content/themes/bamco/img/theme/cafe_bamco_logo-new.png"
),
InlineQueryResultArticle(
id=uuid4(),
title="McEwen",
input_message_content=InputTextMessageContent(
"https://hamilton.cafebonappetit.com/cafe/mcewens-green-cafe/",
parse_mode=ParseMode.MARKDOWN),
description="McEwen Food!",
thumb_url=
"https://hamilton.cafebonappetit.com/content/themes/bamco/img/theme/cafe_bamco_logo-new.png"
),
InlineQueryResultArticle(
id=uuid4(),
title="Commons",
input_message_content=InputTextMessageContent(
"https://hamilton.cafebonappetit.com/cafe/soper-commons-cafe/",
parse_mode=ParseMode.MARKDOWN),
description="Commons Food!",
thumb_url=
"https://hamilton.cafebonappetit.com/content/themes/bamco/img/theme/cafe_bamco_logo-new.png"
),
InlineQueryResultArticle(
id=uuid4(),
title="Hill Card Refill",
input_message_content=InputTextMessageContent(
"https://hamilton-sp.blackboard.com/eaccounts/AnonymousHome.aspx",
parse_mode=ParseMode.MARKDOWN),
description=
"It's as if Hamilton hasn't taken enough of our money yet!",
thumb_url=
"https://upload.wikimedia.org/wikipedia/commons/0/00/Hamilton_Continentals_logo.png"
),
InlineQueryResultArticle(
id=uuid4(),
title="Blackboard",
input_message_content=InputTextMessageContent(
"https://blackboard.hamilton.edu/",
parse_mode=ParseMode.MARKDOWN),
description="See your classes and stuff!",
thumb_url=
"https://en.wikipedia.org/wiki/Blackboard_Inc.#/media/File:Blackboard_Inc._logo.png"
)
]
#Once the user clicks enter, the results will pop out!
update.inline_query.answer(results)
def inlinequery_handler(bot, update, chat_data):
query = update.inline_query.query.lower()
# TODO: remove or enhance eventually, this is potentially very spammy
# Statistic.of(update, 'inlinequery', '"{}"'.format(query), Statistic.DETAILED)
user = User.from_update(update)
results_list = list()
input_given = len(query.strip()) > 0
query_too_short = 0 < len(query.strip()) < SEARCH_QUERY_MIN_LENGTH
too_many_results = False
cat_results = []
bot_results = []
if input_given:
# query category results
cat_results = search.search_categories(query)
if not query_too_short:
# query bot results
bot_results = list(search.search_bots(query))
if len(bot_results) > MAX_BOTS:
bot_results = bot_results[:MAX_BOTS]
too_many_results = True
# query for new bots
if query == messages.NEW_BOTS_INLINEQUERY.lower() or query == 'new':
results_list.append(new_bots_article())
bot.answerInlineQuery(update.inline_query.id, results=results_list)
return
if query in CONTRIBUTING_QUERIES:
results_list.append(
InlineQueryResultArticle(
id=uuid4(),
title='Contributing',
input_message_content=InputTextMessageContent(
message_text=messages.CONTRIBUTING, parse_mode="Markdown"),
))
bot.answerInlineQuery(update.inline_query.id,
results=results_list,
cache_time=600)
return
if query in EXAMPLES_QUERIES:
results_list.append(
InlineQueryResultArticle(
id=uuid4(),
title='Examples',
input_message_content=InputTextMessageContent(
message_text=messages.EXAMPLES, parse_mode="Markdown"),
))
bot.answerInlineQuery(update.inline_query.id,
results=results_list,
cache_time=600)
return
if query in (const.DeepLinkingActions.RULES, '#rules'):
results_list.append(
InlineQueryResultArticle(
id=uuid4(),
title='@BotListChat Rules',
input_message_content=InputTextMessageContent(
message_text=messages.BOTLISTCHAT_RULES,
parse_mode="Markdown",
disable_web_page_preview=True),
))
bot.answerInlineQuery(update.inline_query.id,
results=results_list,
cache_time=600)
return
if query == const.DeepLinkingActions.FAVORITES and user.has_favorites:
results_list.append(favorites_article(user))
bot.answerInlineQuery(update.inline_query.id,
results=results_list,
cache_time=0,
is_personal=True)
return
msg, reply_markup, key = botlistchat.get_hint_message_and_markup(query)
if msg is not None:
results_list.append(hint_article(msg, reply_markup, key))
bot.answerInlineQuery(update.inline_query.id,
results=results_list,
cache_time=600)
return
invalid_search_term = query_too_short and not cat_results
if invalid_search_term:
results_list.append(query_too_short_article())
results_available = cat_results or bot_results
if results_available:
if len(bot_results) > 1:
results_list.append(
all_bot_results_article(bot_results, too_many_results))
for c in cat_results:
results_list.append(category_article(c))
for b in bot_results:
results_list.append(bot_article(b))
if len(bot_results) > 0:
bot.answerInlineQuery(
update.inline_query.id,
results=results_list,
switch_pm_text="See all results"
if too_many_results else "Search in private chat",
switch_pm_parameter=util.encode_base64(query),
cache_time=0,
is_personal=True)
else:
bot.answerInlineQuery(update.inline_query.id,
results=results_list,
cache_time=0,
is_personal=True)
else:
if user.has_favorites:
results_list.append(favorites_article(user))
results_list.append(new_bots_article())
categories = Category.select_all()
for c in categories:
results_list.append(category_article(c))
if invalid_search_term or not input_given:
bot.answerInlineQuery(update.inline_query.id,
results=results_list,
cache_time=0,
is_personal=True)
else:
bot.answerInlineQuery(
update.inline_query.id,
results=results_list,
switch_pm_text="No results. Contribute a bot?",
switch_pm_parameter='contributing',
cache_time=0,
is_personal=True)
class TestInlineQueryResultVenue:
id_ = 'id'
type_ = 'venue'
latitude = 'latitude'
longitude = 'longitude'
title = 'title'
address = 'address'
foursquare_id = 'foursquare id'
foursquare_type = 'foursquare type'
google_place_id = 'google place id'
google_place_type = 'google place type'
thumb_url = 'thumb url'
thumb_width = 10
thumb_height = 15
input_message_content = InputTextMessageContent('input_message_content')
reply_markup = InlineKeyboardMarkup(
[[InlineKeyboardButton('reply_markup')]])
def test_expected_values(self, inline_query_result_venue):
assert inline_query_result_venue.id == self.id_
assert inline_query_result_venue.type == self.type_
assert inline_query_result_venue.latitude == self.latitude
assert inline_query_result_venue.longitude == self.longitude
assert inline_query_result_venue.title == self.title
assert inline_query_result_venue.address == self.address
assert inline_query_result_venue.foursquare_id == self.foursquare_id
assert inline_query_result_venue.foursquare_type == self.foursquare_type
assert inline_query_result_venue.google_place_id == self.google_place_id
assert inline_query_result_venue.google_place_type == self.google_place_type
assert inline_query_result_venue.thumb_url == self.thumb_url
assert inline_query_result_venue.thumb_width == self.thumb_width
assert inline_query_result_venue.thumb_height == self.thumb_height
assert (inline_query_result_venue.input_message_content.to_dict() ==
self.input_message_content.to_dict())
assert inline_query_result_venue.reply_markup.to_dict(
) == self.reply_markup.to_dict()
def test_to_dict(self, inline_query_result_venue):
inline_query_result_venue_dict = inline_query_result_venue.to_dict()
assert isinstance(inline_query_result_venue_dict, dict)
assert inline_query_result_venue_dict[
'id'] == inline_query_result_venue.id
assert inline_query_result_venue_dict[
'type'] == inline_query_result_venue.type
assert inline_query_result_venue_dict[
'latitude'] == inline_query_result_venue.latitude
assert inline_query_result_venue_dict[
'longitude'] == inline_query_result_venue.longitude
assert inline_query_result_venue_dict[
'title'] == inline_query_result_venue.title
assert inline_query_result_venue_dict[
'address'] == inline_query_result_venue.address
assert (inline_query_result_venue_dict['foursquare_id'] ==
inline_query_result_venue.foursquare_id)
assert (inline_query_result_venue_dict['foursquare_type'] ==
inline_query_result_venue.foursquare_type)
assert (inline_query_result_venue_dict['google_place_id'] ==
inline_query_result_venue.google_place_id)
assert (inline_query_result_venue_dict['google_place_type'] ==
inline_query_result_venue.google_place_type)
assert inline_query_result_venue_dict[
'thumb_url'] == inline_query_result_venue.thumb_url
assert (inline_query_result_venue_dict['thumb_width'] ==
inline_query_result_venue.thumb_width)
assert (inline_query_result_venue_dict['thumb_height'] ==
inline_query_result_venue.thumb_height)
assert (inline_query_result_venue_dict['input_message_content'] ==
inline_query_result_venue.input_message_content.to_dict())
assert (inline_query_result_venue_dict['reply_markup'] ==
inline_query_result_venue.reply_markup.to_dict())
def test_equality(self):
a = InlineQueryResultVenue(self.id_, self.longitude, self.latitude,
self.title, self.address)
b = InlineQueryResultVenue(self.id_, self.longitude, self.latitude,
self.title, self.address)
c = InlineQueryResultVenue(self.id_, '', self.latitude, self.title,
self.address)
d = InlineQueryResultVenue('', self.longitude, self.latitude,
self.title, self.address)
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 inlinequery(bot, update):
r = requests.get(
'https://github.com/OpenVE/comunidades-en-telegram/blob/master/README.md'
)
soup = BeautifulSoup(r.text, "html.parser")
results = list()
query = update.inline_query.query
communities = soup.find_all('tr')[2:]
if len(query) == 0:
random.shuffle(communities)
for tr in communities[:50]:
td = tr.find_all('td')
results.append(
InlineQueryResultArticle(
id=uuid4(),
title=escape_markdown(td[0].text),
input_message_content=InputTextMessageContent(
"Nombre: {}\nLink: {} \nAdmins: {}".format(
escape_markdown(td[0].text), td[2].text,
td[1].text)),
url=td[2].text,
reply_markup=InlineKeyboardMarkup(
[[
InlineKeyboardButton('▶️ Ir al Grupo ◀️',
url=td[2].text)
],
[
InlineKeyboardButton(
'🔎 Encontrar Grupos',
switch_inline_query_current_chat="")
]])))
elif len(query) > 0:
found = 0
for tr in communities:
tds = tr.find_all('td')
if query.lower() in (tds[0].text).lower():
found += 1
results.append(
InlineQueryResultArticle(
id=uuid4(),
title=tds[0].text,
input_message_content=InputTextMessageContent(
"Nombre: {}\nLink: {} \nAdmins: {}".format(
escape_markdown(tds[0].text), tds[2].text,
tds[1].text)),
url=tds[2].text,
reply_markup=InlineKeyboardMarkup(
[[
InlineKeyboardButton('▶️ Ir al Grupo ◀️',
url=tds[2].text)
],
[
InlineKeyboardButton(
'🔎 Encontrar Grupos',
switch_inline_query_current_chat="")
]])))
if found == 0:
results.append(
InlineQueryResultArticle(
id=uuid4(), title='No existen items con ese termino'))
else:
results.append(
InlineQueryResultArticle(id=uuid4(), title='No existen items'))
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
class TestInlineQueryResultCachedVoice(object):
id = 'id'
type = 'voice'
voice_file_id = 'voice file id'
title = 'title'
caption = 'caption'
parse_mode = 'HTML'
input_message_content = InputTextMessageContent('input_message_content')
reply_markup = InlineKeyboardMarkup([[InlineKeyboardButton('reply_markup')]])
def test_expected_values(self, inline_query_result_cached_voice):
assert inline_query_result_cached_voice.type == self.type
assert inline_query_result_cached_voice.id == self.id
assert inline_query_result_cached_voice.voice_file_id == self.voice_file_id
assert inline_query_result_cached_voice.title == self.title
assert inline_query_result_cached_voice.caption == self.caption
assert inline_query_result_cached_voice.parse_mode == self.parse_mode
assert (inline_query_result_cached_voice.input_message_content.to_dict() ==
self.input_message_content.to_dict())
assert (
inline_query_result_cached_voice.reply_markup.to_dict() == self.reply_markup.to_dict())
@staticmethod
def test_to_dict(inline_query_result_cached_voice):
inline_query_result_cached_voice_dict = inline_query_result_cached_voice.to_dict()
assert isinstance(inline_query_result_cached_voice_dict, dict)
assert (
inline_query_result_cached_voice_dict['type'] == inline_query_result_cached_voice.type)
assert inline_query_result_cached_voice_dict['id'] == inline_query_result_cached_voice.id
assert (inline_query_result_cached_voice_dict['voice_file_id'] ==
inline_query_result_cached_voice.voice_file_id)
assert (inline_query_result_cached_voice_dict['title'] ==
inline_query_result_cached_voice.title)
assert (inline_query_result_cached_voice_dict['caption'] ==
inline_query_result_cached_voice.caption)
assert (inline_query_result_cached_voice_dict['parse_mode'] ==
inline_query_result_cached_voice.parse_mode)
assert (inline_query_result_cached_voice_dict['input_message_content'] ==
inline_query_result_cached_voice.input_message_content.to_dict())
assert (inline_query_result_cached_voice_dict['reply_markup'] ==
inline_query_result_cached_voice.reply_markup.to_dict())
def test_equality(self):
a = InlineQueryResultCachedVoice(self.id, self.voice_file_id, self.title)
b = InlineQueryResultCachedVoice(self.id, self.voice_file_id, self.title)
c = InlineQueryResultCachedVoice(self.id, '', self.title)
d = InlineQueryResultCachedVoice('', self.voice_file_id, self.title)
e = InlineQueryResultCachedAudio(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)
class TestInlineQueryResultCachedVideo:
id_ = "id"
type_ = "video"
video_file_id = "video file id"
title = "title"
caption = "caption"
parse_mode = "Markdown"
caption_entities = [MessageEntity(MessageEntity.ITALIC, 0, 7)]
description = "description"
input_message_content = InputTextMessageContent("input_message_content")
reply_markup = InlineKeyboardMarkup(
[[InlineKeyboardButton("reply_markup")]])
def test_slot_behaviour(self, inline_query_result_cached_video, mro_slots):
inst = inline_query_result_cached_video
for attr in inst.__slots__:
assert getattr(inst, attr,
"err") != "err", f"got extra slot '{attr}'"
assert len(mro_slots(inst)) == len(set(
mro_slots(inst))), "duplicate slot"
def test_expected_values(self, inline_query_result_cached_video):
assert inline_query_result_cached_video.type == self.type_
assert inline_query_result_cached_video.id == self.id_
assert inline_query_result_cached_video.video_file_id == self.video_file_id
assert inline_query_result_cached_video.title == self.title
assert inline_query_result_cached_video.description == self.description
assert inline_query_result_cached_video.caption == self.caption
assert inline_query_result_cached_video.parse_mode == self.parse_mode
assert inline_query_result_cached_video.caption_entities == self.caption_entities
assert (inline_query_result_cached_video.input_message_content.to_dict(
) == self.input_message_content.to_dict())
assert (inline_query_result_cached_video.reply_markup.to_dict() ==
self.reply_markup.to_dict())
def test_to_dict(self, inline_query_result_cached_video):
inline_query_result_cached_video_dict = inline_query_result_cached_video.to_dict(
)
assert isinstance(inline_query_result_cached_video_dict, dict)
assert (inline_query_result_cached_video_dict["type"] ==
inline_query_result_cached_video.type)
assert inline_query_result_cached_video_dict[
"id"] == inline_query_result_cached_video.id
assert (inline_query_result_cached_video_dict["video_file_id"] ==
inline_query_result_cached_video.video_file_id)
assert (inline_query_result_cached_video_dict["title"] ==
inline_query_result_cached_video.title)
assert (inline_query_result_cached_video_dict["description"] ==
inline_query_result_cached_video.description)
assert (inline_query_result_cached_video_dict["caption"] ==
inline_query_result_cached_video.caption)
assert (inline_query_result_cached_video_dict["parse_mode"] ==
inline_query_result_cached_video.parse_mode)
assert inline_query_result_cached_video_dict["caption_entities"] == [
ce.to_dict()
for ce in inline_query_result_cached_video.caption_entities
]
assert (
inline_query_result_cached_video_dict["input_message_content"] ==
inline_query_result_cached_video.input_message_content.to_dict())
assert (inline_query_result_cached_video_dict["reply_markup"] ==
inline_query_result_cached_video.reply_markup.to_dict())
def test_equality(self):
a = InlineQueryResultCachedVideo(self.id_, self.video_file_id,
self.title)
b = InlineQueryResultCachedVideo(self.id_, self.video_file_id,
self.title)
c = InlineQueryResultCachedVideo(self.id_, "", self.title)
d = InlineQueryResultCachedVideo("", self.video_file_id, self.title)
e = InlineQueryResultCachedVoice(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 generate_multi_currency_list(query):
data = requests.get(
'https://api.coinmarketcap.com/v1/ticker/?limit=10000').json()
if query.endswith(","):
query = query[:-1]
currencyList = convert_list_to_names(query)
prices = get_prices(currencyList, data)
marketCaps = get_market_capitalizations(currencyList, data)
percentChanges = get_percent_changes(currencyList, data)
if currencyList:
results = [
InlineQueryResultArticle(
id=uuid4(),
title=('Prices'),
description='Tap to send.',
thumb_url="https://imgur.com/7RCGCoc.png",
input_message_content=InputTextMessageContent(
prices, ParseMode.MARKDOWN)),
InlineQueryResultArticle(
id=uuid4(),
title=('Market Capitalizations'),
description='Tap to send.',
thumb_url="https://i.imgur.com/UMczLVP.png",
input_message_content=InputTextMessageContent(
marketCaps, ParseMode.MARKDOWN)),
InlineQueryResultArticle(
id=uuid4(),
title=('Percent Change Values'),
description='Tap to send.',
thumb_url=("https://imgur.com/iAoXFQc.png"),
input_message_content=InputTextMessageContent(
percentChanges, ParseMode.MARKDOWN)),
]
if len(currencyList) > 10:
length = 10
else:
length = len(currencyList)
for x in range(0, length):
listEntry = Coin(currencyList[x], None, False)
results.append(
InlineQueryResultArticle(
id=uuid4(),
description=("$" + listEntry.price_USD),
thumb_url='https://files.coinmarketcap.com/static/img/coins/' \
+ '200x200/' + listEntry.id + '.png',
title=(listEntry.name),
input_message_content=InputTextMessageContent(listEntry.summary, \
ParseMode.MARKDOWN)),
)
return results
class TestInlineQueryResultCachedPhoto:
id_ = 'id'
type_ = 'photo'
photo_file_id = 'photo file id'
title = 'title'
description = 'description'
caption = 'caption'
parse_mode = 'HTML'
caption_entities = [MessageEntity(MessageEntity.ITALIC, 0, 7)]
input_message_content = InputTextMessageContent('input_message_content')
reply_markup = InlineKeyboardMarkup(
[[InlineKeyboardButton('reply_markup')]])
def test_slot_behaviour(self, inline_query_result_cached_photo, recwarn,
mro_slots):
inst = inline_query_result_cached_photo
for attr in inst.__slots__:
assert getattr(inst, attr,
'err') != 'err', f"got extra slot '{attr}'"
assert not inst.__dict__, f"got missing slot(s): {inst.__dict__}"
assert len(mro_slots(inst)) == len(set(
mro_slots(inst))), "duplicate slot"
inst.custom, inst.id = 'should give warning', self.id_
assert len(recwarn) == 1 and 'custom' in str(
recwarn[0].message), recwarn.list
def test_expected_values(self, inline_query_result_cached_photo):
assert inline_query_result_cached_photo.type == self.type_
assert inline_query_result_cached_photo.id == self.id_
assert inline_query_result_cached_photo.photo_file_id == self.photo_file_id
assert inline_query_result_cached_photo.title == self.title
assert inline_query_result_cached_photo.description == self.description
assert inline_query_result_cached_photo.caption == self.caption
assert inline_query_result_cached_photo.parse_mode == self.parse_mode
assert inline_query_result_cached_photo.caption_entities == self.caption_entities
assert (inline_query_result_cached_photo.input_message_content.to_dict(
) == self.input_message_content.to_dict())
assert (inline_query_result_cached_photo.reply_markup.to_dict() ==
self.reply_markup.to_dict())
def test_to_dict(self, inline_query_result_cached_photo):
inline_query_result_cached_photo_dict = inline_query_result_cached_photo.to_dict(
)
assert isinstance(inline_query_result_cached_photo_dict, dict)
assert (inline_query_result_cached_photo_dict['type'] ==
inline_query_result_cached_photo.type)
assert inline_query_result_cached_photo_dict[
'id'] == inline_query_result_cached_photo.id
assert (inline_query_result_cached_photo_dict['photo_file_id'] ==
inline_query_result_cached_photo.photo_file_id)
assert (inline_query_result_cached_photo_dict['title'] ==
inline_query_result_cached_photo.title)
assert (inline_query_result_cached_photo_dict['description'] ==
inline_query_result_cached_photo.description)
assert (inline_query_result_cached_photo_dict['caption'] ==
inline_query_result_cached_photo.caption)
assert (inline_query_result_cached_photo_dict['parse_mode'] ==
inline_query_result_cached_photo.parse_mode)
assert inline_query_result_cached_photo_dict['caption_entities'] == [
ce.to_dict()
for ce in inline_query_result_cached_photo.caption_entities
]
assert (
inline_query_result_cached_photo_dict['input_message_content'] ==
inline_query_result_cached_photo.input_message_content.to_dict())
assert (inline_query_result_cached_photo_dict['reply_markup'] ==
inline_query_result_cached_photo.reply_markup.to_dict())
def test_equality(self):
a = InlineQueryResultCachedPhoto(self.id_, self.photo_file_id)
b = InlineQueryResultCachedPhoto(self.id_, self.photo_file_id)
c = InlineQueryResultCachedPhoto(self.id_, '')
d = InlineQueryResultCachedPhoto('', self.photo_file_id)
e = InlineQueryResultCachedVoice(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 inline_query(bot, update):
results = list()
results.append(
InlineQueryResultArticle(
'1',
'Alien - Nunca me Faltes',
InputTextMessageContent('Alien - Nunca me Faltes'),
thumb_url='http://i.imgur.com/663CMAj.png'))
results.append(
InlineQueryResultArticle('2',
'El merengue del PP',
InputTextMessageContent('El merengue del PP'),
thumb_url='http://i.imgur.com/brP3eGU.png'))
results.append(
InlineQueryResultArticle(
'3',
'Seinfeld MLG remix (Skrillfeld)',
InputTextMessageContent('Seinfeld MLG remix (Skrillfeld)'),
thumb_url='https://imgur.com/XfgkG2v.png'))
results.append(
InlineQueryResultArticle(
'4',
'Niña, no te modernices (Payo Juan)',
InputTextMessageContent('Niña, no te modernices (Payo Juan)'),
thumb_url='https://imgur.com/x89UIt6.png'))
results.append(
InlineQueryResultArticle(
'5',
'Torres Gemelas (Delfín Quishpe)',
InputTextMessageContent('Torres Gemelas (Delfín Quishpe)'),
thumb_url='https://imgur.com/7ssC7xU.png'))
results.append(
InlineQueryResultArticle('6',
'Titanic en flauta',
InputTextMessageContent('Titanic en flauta'),
thumb_url='https://imgur.com/YAlttL7.png'))
results.append(
InlineQueryResultArticle(
'7',
'Danza Hebrea - Hava Nagila Medley',
InputTextMessageContent('Danza Hebrea - Hava Nagila Medley'),
thumb_url='https://i.imgur.com/zvDpBLk.png'))
results.append(
InlineQueryResultArticle('8',
'Niño predicador',
InputTextMessageContent('Niño predicador'),
thumb_url='https://imgur.com/c7UiQat.png'))
results.append(
InlineQueryResultArticle(
'9',
'HEYYEYAAEYAAAEYAEYAA',
InputTextMessageContent('HEYYEYAAEYAAAEYAEYAA'),
thumb_url='https://imgur.com/OUoza0S.png'))
results.append(
InlineQueryResultArticle(
'10',
'Vitas - 7th Element',
InputTextMessageContent('Vitas - 7th Element'),
thumb_url='https://imgur.com/H66YT9u.png'))
results.append(
InlineQueryResultArticle(
'11',
'GhostBusters Theme Song',
InputTextMessageContent('GhostBusters Theme Song'),
thumb_url='https://imgur.com/Ep75AU6.png'))
results.append(
InlineQueryResultArticle(
'12',
'Jimmy Mi Carcachita',
InputTextMessageContent('Jimmy Mi Carcachita'),
thumb_url='http://imgur.com/sGZ4BVA.png'))
results.append(
InlineQueryResultArticle(
'13',
'Never Gonna Give You Up (Rick Astley)',
InputTextMessageContent('Never Gonna Give You Up (Rick Astley)'),
thumb_url='http://imgur.com/sTwVRvO.png'))
results.append(
InlineQueryResultArticle(
'14',
'Ai se eu te pego (version Salvador Raya)',
InputTextMessageContent(
'Ai se eu te pego (version Salvador Raya)'),
thumb_url='http://imgur.com/i3sJkB1.png'))
results.append(
InlineQueryResultArticle(
'15',
'Minorias (South Park)',
InputTextMessageContent('Minorias (South Park)'),
thumb_url='http://imgur.com/EIw6pob.png'))
results.append(
InlineQueryResultArticle('16',
'Epic sax guy',
InputTextMessageContent('Epic sax guy'),
thumb_url='http://imgur.com/W5YgViI.png'))
results.append(
InlineQueryResultArticle(
'17',
'Shut The F**k Up (Filthy Frank)',
InputTextMessageContent('Shut The F**k Up (Filthy Frank)'),
thumb_url='http://imgur.com/cWx2Mc1.png'))
results.append(
InlineQueryResultArticle('18',
'Darude - Sandstorm',
InputTextMessageContent('Darude - Sandstorm'),
thumb_url='http://imgur.com/T6Ysv4Q.png'))
results.append(
InlineQueryResultArticle(
'19',
'El sonido de silencio de serguio denis en español/the sound of silence',
InputTextMessageContent(
'el sonido de silencio de serguio denis en español/the sound of silence'
),
thumb_url='http://imgur.com/aT35PYZ.png'))
results.append(
InlineQueryResultArticle(
'20',
'Running in The 90s (Initial D)',
InputTextMessageContent('Running in The 90s (Initial D)'),
thumb_url='http://imgur.com/jzy3w40.png'))
results.append(
InlineQueryResultArticle(
'21',
'Salvame La Vida - Mago Rey y Gackty Chan',
InputTextMessageContent(
'Salvame La Vida - Mago Rey y Gackty Chan'),
thumb_url='http://imgur.com/lfjz7JK.png'))
results.append(
InlineQueryResultArticle(
'22',
'Darude - Sandstorm (RENGE FLUTE REMIX)',
InputTextMessageContent('Darude - Sandstorm (RENGE FLUTE REMIX)'),
thumb_url='http://imgur.com/8vXAcr8.png'))
update.inline_query.answer(results)
class TestInlineQueryResultMpeg4Gif(object):
id = 'id'
type = 'mpeg4_gif'
mpeg4_url = 'mpeg4 url'
mpeg4_width = 10
mpeg4_height = 15
mpeg4_duration = 1
thumb_url = 'thumb url'
title = 'title'
caption = 'caption'
parse_mode = 'Markdown'
input_message_content = InputTextMessageContent('input_message_content')
reply_markup = InlineKeyboardMarkup(
[[InlineKeyboardButton('reply_markup')]])
def test_expected_values(self, inline_query_result_mpeg4_gif):
assert inline_query_result_mpeg4_gif.type == self.type
assert inline_query_result_mpeg4_gif.id == self.id
assert inline_query_result_mpeg4_gif.mpeg4_url == self.mpeg4_url
assert inline_query_result_mpeg4_gif.mpeg4_width == self.mpeg4_width
assert inline_query_result_mpeg4_gif.mpeg4_height == self.mpeg4_height
assert inline_query_result_mpeg4_gif.mpeg4_duration == self.mpeg4_duration
assert inline_query_result_mpeg4_gif.thumb_url == self.thumb_url
assert inline_query_result_mpeg4_gif.title == self.title
assert inline_query_result_mpeg4_gif.caption == self.caption
assert inline_query_result_mpeg4_gif.parse_mode == self.parse_mode
assert (inline_query_result_mpeg4_gif.input_message_content.to_dict()
== self.input_message_content.to_dict())
assert inline_query_result_mpeg4_gif.reply_markup.to_dict(
) == self.reply_markup.to_dict()
@staticmethod
def test_to_dict(inline_query_result_mpeg4_gif):
inline_query_result_mpeg4_gif_dict = inline_query_result_mpeg4_gif.to_dict(
)
assert isinstance(inline_query_result_mpeg4_gif_dict, dict)
assert inline_query_result_mpeg4_gif_dict[
'type'] == inline_query_result_mpeg4_gif.type
assert inline_query_result_mpeg4_gif_dict[
'id'] == inline_query_result_mpeg4_gif.id
assert (inline_query_result_mpeg4_gif_dict['mpeg4_url'] ==
inline_query_result_mpeg4_gif.mpeg4_url)
assert (inline_query_result_mpeg4_gif_dict['mpeg4_width'] ==
inline_query_result_mpeg4_gif.mpeg4_width)
assert (inline_query_result_mpeg4_gif_dict['mpeg4_height'] ==
inline_query_result_mpeg4_gif.mpeg4_height)
assert (inline_query_result_mpeg4_gif_dict['mpeg4_duration'] ==
inline_query_result_mpeg4_gif.mpeg4_duration)
assert (inline_query_result_mpeg4_gif_dict['thumb_url'] ==
inline_query_result_mpeg4_gif.thumb_url)
assert inline_query_result_mpeg4_gif_dict[
'title'] == inline_query_result_mpeg4_gif.title
assert (inline_query_result_mpeg4_gif_dict['caption'] ==
inline_query_result_mpeg4_gif.caption)
assert (inline_query_result_mpeg4_gif_dict['parse_mode'] ==
inline_query_result_mpeg4_gif.parse_mode)
assert (inline_query_result_mpeg4_gif_dict['input_message_content'] ==
inline_query_result_mpeg4_gif.input_message_content.to_dict())
assert (inline_query_result_mpeg4_gif_dict['reply_markup'] ==
inline_query_result_mpeg4_gif.reply_markup.to_dict())
def test_equality(self):
a = InlineQueryResultMpeg4Gif(self.id, self.mpeg4_url, self.thumb_url)
b = InlineQueryResultMpeg4Gif(self.id, self.mpeg4_url, self.thumb_url)
c = InlineQueryResultMpeg4Gif(self.id, '', self.thumb_url)
d = InlineQueryResultMpeg4Gif('', self.mpeg4_url, self.thumb_url)
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)
class TestInlineQueryResultVoice:
id_ = "id"
type_ = "voice"
voice_url = "voice url"
title = "title"
voice_duration = "voice_duration"
caption = "caption"
parse_mode = "HTML"
caption_entities = [MessageEntity(MessageEntity.ITALIC, 0, 7)]
input_message_content = InputTextMessageContent("input_message_content")
reply_markup = InlineKeyboardMarkup([[InlineKeyboardButton("reply_markup")]])
def test_slot_behaviour(self, inline_query_result_voice, mro_slots):
inst = inline_query_result_voice
for attr in inst.__slots__:
assert getattr(inst, attr, "err") != "err", f"got extra slot '{attr}'"
assert len(mro_slots(inst)) == len(set(mro_slots(inst))), "duplicate slot"
def test_expected_values(self, inline_query_result_voice):
assert inline_query_result_voice.type == self.type_
assert inline_query_result_voice.id == self.id_
assert inline_query_result_voice.voice_url == self.voice_url
assert inline_query_result_voice.title == self.title
assert inline_query_result_voice.voice_duration == self.voice_duration
assert inline_query_result_voice.caption == self.caption
assert inline_query_result_voice.parse_mode == self.parse_mode
assert inline_query_result_voice.caption_entities == self.caption_entities
assert (
inline_query_result_voice.input_message_content.to_dict()
== self.input_message_content.to_dict()
)
assert inline_query_result_voice.reply_markup.to_dict() == self.reply_markup.to_dict()
def test_to_dict(self, inline_query_result_voice):
inline_query_result_voice_dict = inline_query_result_voice.to_dict()
assert isinstance(inline_query_result_voice_dict, dict)
assert inline_query_result_voice_dict["type"] == inline_query_result_voice.type
assert inline_query_result_voice_dict["id"] == inline_query_result_voice.id
assert inline_query_result_voice_dict["voice_url"] == inline_query_result_voice.voice_url
assert inline_query_result_voice_dict["title"] == inline_query_result_voice.title
assert (
inline_query_result_voice_dict["voice_duration"]
== inline_query_result_voice.voice_duration
)
assert inline_query_result_voice_dict["caption"] == inline_query_result_voice.caption
assert inline_query_result_voice_dict["parse_mode"] == inline_query_result_voice.parse_mode
assert inline_query_result_voice_dict["caption_entities"] == [
ce.to_dict() for ce in inline_query_result_voice.caption_entities
]
assert (
inline_query_result_voice_dict["input_message_content"]
== inline_query_result_voice.input_message_content.to_dict()
)
assert (
inline_query_result_voice_dict["reply_markup"]
== inline_query_result_voice.reply_markup.to_dict()
)
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 callback():
return InlineQueryResultArticle(
id=uuid4(),
title=command,
input_message_content=InputTextMessageContent(response))
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)
