def inlinequery(self, bot, update):
results = [
InlineQueryResultCachedVoice(id=uuid4(),
voice_file_id=Handlers.AUDIO_DADADA,
title='Dadadadadadadadadada'),
InlineQueryResultCachedVoice(id=uuid4(),
voice_file_id=Handlers.AUDIO_AAAAAA,
title='AAAAAAAAAAAAAAAAAAAA'),
]
update.inline_query.answer(results)
def inline_query_result_cached_voice():
return InlineQueryResultCachedVoice(TestInlineQueryResultCachedVoice.id,
TestInlineQueryResultCachedVoice.voice_file_id,
TestInlineQueryResultCachedVoice.title,
caption=TestInlineQueryResultCachedVoice.caption,
input_message_content=TestInlineQueryResultCachedVoice.input_message_content,
reply_markup=TestInlineQueryResultCachedVoice.reply_markup)
def inlinequery(_, update):
global large_results
inl_q = update.inline_query
query = inl_q.query
offset = int(inl_q.offset) if inl_q.offset else 0
if offset == 0 or query not in large_results:
if query:
memes = meme_storage.find(query)
else:
memes = meme_storage.get_most_popular()
if len(memes) > PAGE_SIZE:
large_results = save_result(large_results, query, memes)
else:
memes = get_result(large_results, query)
large_results = filter_old_results(large_results)
have_next_page = bool(len(memes) - offset > PAGE_SIZE)
next_offset = str(offset + PAGE_SIZE) if have_next_page else ''
logger.info(
'Query: %s, items: %s, offset: %d, has next page: %d, next offset: %s',
query, len(memes), offset, have_next_page, next_offset)
results = [
InlineQueryResultCachedVoice(meme.id, meme.file_id, title=meme.name)
for meme in memes[offset:offset + PAGE_SIZE]
]
update.inline_query.answer(results, cache_time=0, next_offset=next_offset)
def create_voice_inline_result(doc: Document) -> InlineQueryResultCachedVoice:
content = doc.content
return InlineQueryResultCachedVoice(
id=doc.internal_id,
voice_file_id=content['file_id'],
title=doc.keywords,
caption=content.get('caption'),
)
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)
def on_inline_query(update: Update, context: CallbackContext):
query: InlineQuery = update.inline_query
results = [
InlineQueryResultCachedVoice(id=id,
voice_file_id=file_id,
title=text,
reply_markup=InlineKeyboardMarkup([[
InlineKeyboardButton(text='text',
callback_data=id)
]]))
for file_id, text, id in get_voices(query.query)
]
context.bot.answer_inline_query(query.id, results)
def test_equality(self):
a = InlineQueryResultCachedSticker(self.id_, self.sticker_file_id)
b = InlineQueryResultCachedSticker(self.id_, self.sticker_file_id)
c = InlineQueryResultCachedSticker(self.id_, "")
d = InlineQueryResultCachedSticker("", self.sticker_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 test_equality(self):
a = InlineQueryResultCachedGif(self.id_, self.gif_file_id)
b = InlineQueryResultCachedGif(self.id_, self.gif_file_id)
c = InlineQueryResultCachedGif(self.id_, '')
d = InlineQueryResultCachedGif('', self.gif_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 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 search(self, update, context):
query = update.inline_query.query
# search_string = update.message.text
results = []
if (query != '' or query != None):
result = self.sess.query(self.Voice).filter(
or_(self.Voice.tags.ilike(u'%' + query + u'%'),
self.Voice.voice_name.like(u'%' + query +
u'%'))).limit(15).all()
for res in result:
results.append(
InlineQueryResultCachedVoice(id=res.voice_id,
voice_file_id=res.file_id,
title=res.voice_name))
# results = [
# InlineQueryResultCachedVoice(id='0',voice_file_id='AwADBAADVgMAAmWq-FJkfcXcHoZodwI',title='کس لیسی میلاد')
# ]
update.inline_query.answer(results)
def test_equality(self):
a = InlineQueryResultCachedDocument(self.id, self.title, self.document_file_id)
b = InlineQueryResultCachedDocument(self.id, self.title, self.document_file_id)
c = InlineQueryResultCachedDocument(self.id, self.title, '')
d = InlineQueryResultCachedDocument('', self.title, self.document_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 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)
