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)