def inline_rate(bot, update):
query = update.inline_query.query
query_list = query.split(" ")
results = list()
parser_classes = utils.get_parser_classes()
parsers = [parser(cache=default_cache) for parser in parser_classes]
for parser in parsers:
# Best exchange rate in inline mode
# TODO: write wrapper function to handle inputs like this one
if len(query_list) == 2 and "best" in query_list:
# TODO: this feature is experimental and
# not-optimized at all, it is SLOW
# Mutating original list is not a great ideas
temp_list = query_list[:]
temp_list.remove("best")
currency = temp_list[0]
if currency.upper() not in parser.allowed_currencies:
continue
best = utils.get_best_currencies(currency)
buy_msg = _("Buy {}: <b>{}</b> - {}")
buy_msg = buy_msg.format(best["buy"][1].iso, best["buy"][0],
best["buy"][1].buy)
# TODO: add allignment
sell_msg = _("Sell {}: <b>{}</b> - {}")
sell_msg = sell_msg.format(best["sell"][1].iso, best["sell"][0],
best["sell"][1].sell)
msg = "\n".join([buy_msg, sell_msg])
res = telegram.InputTextMessageContent(
msg, parse_mode=telegram.ParseMode.HTML)
result = telegram.InlineQueryResultArticle(
id=uuid.uuid4(),
title=_("Best rate"),
input_message_content=res)
bot.answerInlineQuery(update.inline_query.id, [result])
return
if query.upper() not in parser.allowed_currencies:
continue
cur_value = cache_proxy.get_currency(parser, query.upper())
bank_name = parser.name
text = "{}\n<b>{}</b>: {}".format(bank_name, query.upper(),
cur_value.sell)
mes_content = telegram.InputTextMessageContent(
text, parse_mode=telegram.ParseMode.HTML)
result = telegram.InlineQueryResultArticle(
id=uuid.uuid4(),
title=parser.name,
input_message_content=mes_content)
results.append(result)
bot.answerInlineQuery(update.inline_query.id, results)
def handle_inline(self, bot, context: Context):
query = context.query
if context.update.inline_query.offset != "":
offset = int(context.update.inline_query.offset)
else:
offset = 0
try:
res: octobot.Catalog = self.function(query, offset, 50, bot,
context)
except CatalogCantGoDeeper:
return
if res is None:
return
inline_res = []
for item in res:
if item.photo is not None:
if item.parse_mode is None or item.parse_mode.lower(
) != "html":
item.parse_mode = 'html'
item.text = html.escape(item.text)
text = add_photo_to_text(item.text, item.photo)
res_kwargs = dict(id=item.item_id,
photo_url=item.photo[0].url,
photo_width=item.photo[0].width,
photo_height=item.photo[0].height,
thumb_url=item.photo[-1].url,
title=item.title,
description=item.description,
reply_markup=item.reply_markup)
if res.photo_primary:
res_kwargs['caption'] = text
res_kwargs['parse_mode'] = item.parse_mode
else:
res_kwargs[
'input_message_content'] = telegram.InputTextMessageContent(
text, parse_mode=item.parse_mode)
if isinstance(item, octobot.CatalogKeyPhoto):
inline_res.append(
telegram.InlineQueryResultPhoto(**res_kwargs))
else:
inline_res.append(
telegram.InlineQueryResultArticle(**res_kwargs))
else:
inline_res.append(
telegram.InlineQueryResultArticle(
item.item_id,
title=item.title,
description=item.description,
input_message_content=telegram.InputTextMessageContent(
item.text, parse_mode=item.parse_mode)))
context.update.inline_query.answer(
inline_res,
cache_time=(360 if Settings.production else 0),
next_offset=res.next_offset)
def handle_inline_spoiler(update: tg.Update, context: tg_ext.CallbackContext):
query = update.inline_query.query
if (len(query) < 1):
return
quotes = [
"That's not a prediction. That's a Spoiler...",
"Spoiler, we die in the end...",
"Is it a Spoiler? I don't know... Im not a car guy.",
"How do I Spoil?", "Random quote? Nope - just a Spoiler.",
"Experience is a gread Spoiler of pleasures.",
"You see, but you do not observe. The Spoiler is clear.",
"Chewbacca dies, but the real Spoiler is below.",
"Spoiler ahead, everyone aboard!", "Spoiler warning"
]
results = [
tg.InlineQueryResultArticle(
id=uuid.uuid4(),
title="Send",
input_message_content=tg.InputTextMessageContent(
message_text=random.choice(quotes)),
reply_markup=tg.InlineKeyboardMarkup(inline_keyboard=[[
tg.InlineKeyboardButton(text='Show me', callback_data=query)
]]))
]
update.inline_query.answer(results=results)
def test_equality(self):
a = telegram.InlineQueryResultVenue(self._id, self.longitude,
self.latitude, self.title,
self._address)
b = telegram.InlineQueryResultVenue(self._id, self.longitude,
self.latitude, self.title,
self._address)
c = telegram.InlineQueryResultVenue(self._id, "", self.latitude,
self.title, self._address)
d = telegram.InlineQueryResultVenue("", self.longitude, self.latitude,
self.title, self._address)
e = telegram.InlineQueryResultArticle(self._id, "", "")
self.assertEqual(a, b)
self.assertEqual(hash(a), hash(b))
self.assertIsNot(a, b)
self.assertEqual(a, c)
self.assertEqual(hash(a), hash(c))
self.assertNotEqual(a, d)
self.assertNotEqual(hash(a), hash(d))
self.assertNotEqual(a, e)
self.assertNotEqual(hash(a), hash(e))
def makeres(gt): gameid = str(uuid.uuid4().hex)[:8] butts = telegram.InlineKeyboardMarkup([[telegram.InlineKeyboardButton(text = "Join", switch_inline_query_current_chat = "join " + gameid)]]) return telegram.InlineQueryResultArticle(id= str(gt) + "_" + str(gameid), title= "Create new *" + str(gt) + "*", reply_markup = butts, input_message_content = telegram.InputTextMessageContent(message_text="Play a game of *" + gt + "* with me!", parse_mode="Markdown"))
def to_result(self):
return t.InlineQueryResultArticle(
id=uuid4(),
title=self.title,
input_message_content=t.InputTextMessageContent(
self.text, 'HTML'
),
)
def strikethrough():
text = strike_text(query)
desc = text
results.append(
tg.InlineQueryResultArticle(
id=uuid4(),
title='Strikethrough',
description=desc,
input_message_content=tg.InputTextMessageContent(
text, parse_mode=tg.ParseMode.MARKDOWN)))
def add_inline_result(self):
result = telegram.InlineQueryResultArticle(
id=uuid4(),
title=self.inline_title,
input_message_content=telegram.InputTextMessageContent(
self.message),
reply_markup=telegram.InlineKeyboardMarkup(self.keyboard),
url="",
description="")
self.inline_results.append(result)
def vaporwave():
text = ''
for i in list(query):
text += chr(0xFEE0 + ord(i))
desc = text
results.append(
tg.InlineQueryResultArticle(
id=uuid4(),
# seriously, if this is overused, it should be removed # IGNORE THIS LINE
title='Vaporwave',
description=desc,
input_message_content=tg.InputTextMessageContent(text)))
def markdown_prev():
text = query
desc = text
results.append(
tg.InlineQueryResultArticle(
id=uuid4(),
title='Markdown (Preview)',
description=desc,
input_message_content=tg.InputTextMessageContent(
text,
parse_mode=tg.ParseMode.MARKDOWN,
disable_web_page_preview=False)))
def inlineR(update, context):
query = update.inline_query.query
results = []
try:
images = subredditImg(query, count=40)
except Exception:
results.append(
tg.InlineQueryResultArticle(0, "No",
tg.InputTextMessageContent("No!")))
else:
if len(images) == 0:
results.append(tg.InlineQueryResultArticle(
0,
"No",
"No!",
))
else:
for img in images:
results.append(tg.InlineQueryResultPhoto(img, img, img))
finally:
update.inline_query.answer(results)
def subs():
subs_used = sub_all.findall(query) # list of subs used in query
text = query
desc = ', '.join(subs_used)
for sub in subs_used:
text = subs_re[sub].sub(subs_dict[sub], text, count=1)
if subs_used:
results.append(
tg.InlineQueryResultArticle(
id=uuid4(),
title='xxSubs',
# desc is all instances that were substituted
description=desc,
input_message_content=tg.InputTextMessageContent(text)))
else:
results.append(
tg.InlineQueryResultArticle(
id=uuid4(),
title='/subs',
# desc is all instances that were substituted
description='Gives a list of substitutions.',
input_message_content=tg.InputTextMessageContent('/subs')))
def vortaro():
nonlocal query
nonlocal results
if query:
if query.startswith('v: '):
query = query[3:]
matches = search_espdic(query)
if 'matches' in locals():
exact, fuzzy = matches
matches = exact + fuzzy
matches = matches[:tg.constants.MAX_INLINE_QUERY_RESULTS]
# reset results to only show dictionary entries
results = list()
for match in matches:
results.append(
tg.InlineQueryResultArticle(
id=uuid4(),
title=match['eo'],
description=match['en'],
input_message_content=tg.InputTextMessageContent(
'*{}*: _{}_'.format(match['eo'], match['en']),
parse_mode=tg.ParseMode.MARKDOWN)))
if not 'matches' in locals() or not matches:
usage = [
'Por serĉi la Esperanto-angla vortaro: `v: <vorto>`',
'To search the Esperanto-English dictionary: `v: <vorto>`',
'Iksa sistemo uzeblas. / X-system is usable.',
]
results.append(
tg.InlineQueryResultArticle(
id=uuid4(),
title='Vortaro / Dictionary',
description='v: <vorto | word>',
input_message_content=tg.InputTextMessageContent(
'\n'.join(usage), parse_mode=tg.ParseMode.MARKDOWN)))
def test_equality(self):
a = telegram.InlineQueryResultArticle(self._id, self.title,
self.input_message_content)
b = telegram.InlineQueryResultArticle(self._id, self.title,
self.input_message_content)
c = telegram.InlineQueryResultArticle(self._id, "",
self.input_message_content)
d = telegram.InlineQueryResultArticle("", self.title,
self.input_message_content)
e = telegram.InlineQueryResultAudio(self._id, "", "")
self.assertEqual(a, b)
self.assertEqual(hash(a), hash(b))
self.assertIsNot(a, b)
self.assertEqual(a, c)
self.assertEqual(hash(a), hash(c))
self.assertNotEqual(a, d)
self.assertNotEqual(hash(a), hash(d))
self.assertNotEqual(a, e)
self.assertNotEqual(hash(a), hash(e))
def generate_inline_answer(self, text):
"Generates inline 'buttons' via so-called article buttons."
ret = []
# generated text - everything for the two variants
msgs = (self.convert(text), self.convert_no_spaces(text))
for t, d, m, i in zip(self.titles, self.descs, msgs, self.imgs):
# first we indicate we use markdown in message that will be sent
r = telegram.InputTextMessageContent(m, parse_mode="Markdown")
# then we generate result with that message and strings set above
result = telegram.InlineQueryResultArticle(id=t,
title=t,
description=d,
input_message_content=r,
thumb_url=i)
ret.append(result)
return ret
def get_inline_query_definition_result(
definition: complete_definition.CompleteDefinition
) -> telegram.InlineQueryResultArticle:
reply_markup = telegram.InlineKeyboardMarkup(
definition.inline_keyboard_buttons)
return telegram.InlineQueryResultArticle(
id=str(uuid.uuid4()),
title=definition.title,
thumb_url=constants.DEX_THUMBNAIL_URL,
url=definition.url,
hide_url=True,
reply_markup=reply_markup,
input_message_content=telegram.InputTextMessageContent(
message_text=definition.html,
parse_mode=telegram.ParseMode.HTML,
disable_web_page_preview=True))
def handle_inline_query(update: tg.Update, context: tg_ext.CallbackContext):
from bot.inline import CallbackCommands
query = update.inline_query.query
results = [
tg.InlineQueryResultArticle(
id=uuid.uuid4(),
title="Send",
input_message_content=tg.InputTextMessageContent(
message_text='Spoiler'),
reply_markup=tg.InlineKeyboardMarkup(inline_keyboard=[[
tg.InlineKeyboardButton(
text='Show',
callback_data=json.dumps(
[CallbackCommands.DISPLAY_SPOILER, query]))
]]))
]
update.inline_query.answer(results=results)
def inline_query_handler(bot, update):
query = update.inline_query.query
inline_query_id = update.inline_query.id
if len(query) < 3:
bot.answerInlineQuery(inline_query_id, [])
return
query_result = table.scan(
FilterExpression=Attr('first_name').contains(query.upper())
| Attr('last_name').contains(query.upper()))['Items']
query_articles = list(
map(
lambda x: telegram.InlineQueryResultArticle(
x['username'], '%s %s' %
(x['first_name'] or '', x['last_name'] or ''),
telegram.InputTextMessageContent('%s %s' % (x['first_name'], x[
'last_name']))), query_result))
bot.answerInlineQuery(inline_query_id, query_articles)
def test_equality(self):
a = telegram.InlineQueryResultAudio(self._id, self.audio_url,
self.title)
b = telegram.InlineQueryResultAudio(self._id, self.title, self.title)
c = telegram.InlineQueryResultAudio(self._id, "", self.title)
d = telegram.InlineQueryResultAudio("", self.audio_url, self.title)
e = telegram.InlineQueryResultArticle(self._id, "", "")
self.assertEqual(a, b)
self.assertEqual(hash(a), hash(b))
self.assertIsNot(a, b)
self.assertEqual(a, c)
self.assertEqual(hash(a), hash(c))
self.assertNotEqual(a, d)
self.assertNotEqual(hash(a), hash(d))
self.assertNotEqual(a, e)
self.assertNotEqual(hash(a), hash(e))
def inlineQuery(update):
projectId = update.inline_query.query
print(projectId)
response = requests.get("https://chamranteam.ir/api/project_name/{}".format(projectId))
if response.status_code == 200:
projectInfo = response.json()
if projectInfo['creator_photo'] is not "None":
projectInfo['creator_photo'] = "https://chamranteam.ir" + projectInfo['creator_photo']
query = update.inline_query.query
results = [
telegram.InlineQueryResultArticle(
id=uuid4(),
title=projectInfo['creator'],
description=projectInfo['project_name'],
thumb_url=projectInfo['creator_photo'],
input_message_content=telegram.InputTextMessageContent(
projectInfo['project_name'])),]
update.inline_query.answer(results, cache_time=15)
else:
print(response.json())
return
def test_equality(self):
a = telegram.InlineQueryResultGif(self._id, self.gif_url,
self.thumb_url)
b = telegram.InlineQueryResultGif(self._id, self.gif_url,
self.thumb_url)
c = telegram.InlineQueryResultGif(self._id, "", self.thumb_url)
d = telegram.InlineQueryResultGif("", self.gif_url, self.thumb_url)
e = telegram.InlineQueryResultArticle(self._id, "", "")
self.assertEqual(a, b)
self.assertEqual(hash(a), hash(b))
self.assertIsNot(a, b)
self.assertEqual(a, c)
self.assertEqual(hash(a), hash(c))
self.assertNotEqual(a, d)
self.assertNotEqual(hash(a), hash(d))
self.assertNotEqual(a, e)
self.assertNotEqual(hash(a), hash(e))
def test_equality(self):
a = telegram.InlineQueryResultContact(self._id, self.phone_number,
self.first_name)
b = telegram.InlineQueryResultContact(self._id, self.phone_number,
self.first_name)
c = telegram.InlineQueryResultContact(self._id, "", self.first_name)
d = telegram.InlineQueryResultContact("", self.phone_number,
self.first_name)
e = telegram.InlineQueryResultArticle(self._id, "", "")
self.assertEqual(a, b)
self.assertEqual(hash(a), hash(b))
self.assertIsNot(a, b)
self.assertEqual(a, c)
self.assertEqual(hash(a), hash(c))
self.assertNotEqual(a, d)
self.assertNotEqual(hash(a), hash(d))
self.assertNotEqual(a, e)
self.assertNotEqual(hash(a), hash(e))
def conv_search(in_state, query_text, bot, update, send_message=True):
""" For conversations: Search message handler.
"""
if query_text == None:
query_text = update.message.text
logger.info("User %s: %s", update.effective_user.username, query_text)
message_back, definition = query_jisho(query_text)
if in_state == RECORDING:
recording = chat_recordings.get(update.effective_user.username)
if recording == None:
update.message.reply_text(
"Warning: your recording got reset, probably because idle time was too long."
)
recording = []
chat_recordings[update.effective_user.username] = recording
if definition != None:
recording.append(definition)
message_back += '\nRecorded ' + str(len(recording)) + ' items.'
# TODO(philhu): Use our own models.
answer = None
if definition != None:
answer = telegram.InlineQueryResultArticle(
input_message_content=telegram.InputTextMessageContent(
message_text=message_back,
parse_mode=telegram.ParseMode.MARKDOWN,
disable_web_page_preview=True),
id=uuid4(),
title=render_word(definition) + ' (' + render_reading(definition) +
')')
if send_message:
bot.send_message(chat_id=update.message.chat_id,
text=message_back,
parse_mode=telegram.ParseMode.MARKDOWN,
disable_web_page_preview=True)
return answer
def chInQuery(bot, update):
print("--> Inline query received\n")
query = update.inline_query.query
fEx = 0
results = list()
if ("/" in query):
results.append(
tg.InlineQueryResultArticle(
id=uuid4(),
title="help",
input_message_content=tg.InputTextMessageContent("/help"),
description="Prints out help message"))
results.append(
tg.InlineQueryResultArticle(
id=uuid4(),
title="start",
input_message_content=tg.InputTextMessageContent("/start"),
description="Start the security monitoring"))
results.append(
tg.InlineQueryResultArticle(
id=uuid4(),
title="stop",
input_message_content=tg.InputTextMessageContent("/stop"),
description="Stop the security monitoring"))
results.append(
tg.InlineQueryResultArticle(
id=uuid4(),
title="log",
input_message_content=tg.InputTextMessageContent("/log"),
description="Print out last 10 events"))
results.append(
tg.InlineQueryResultArticle(
id=uuid4(),
title="list",
input_message_content=tg.InputTextMessageContent("/list"),
description="List triggered sensors within 5 mins"))
results.append(
tg.InlineQueryResultArticle(
id=uuid4(),
title="test",
input_message_content=tg.InputTextMessageContent("/test"),
description="Dummy command for comm debug"))
if (query in cmdString):
fEx = 1
else:
results.append(
tg.InlineQueryResultArticle(
id=uuid4(),
title="ERROR!",
input_message_content=tg.InputTextMessageContent(query),
description="Command unknown"))
fEx = 0
if (fEx == 1):
globals()['b' + query.replace('/', '')](bot, update)
else:
pass
bot.answerInlineQuery(update.inline_query.id, results=results)
def handle_inline_query(self, update):
m = self.parse_cmd_comment(update.inline_query.query)
if m:
reviewed_user_id, comment = m
userinfo = Userinfo(reviewed_user_id)
update.inline_query.answer(results=[
telegram.InlineQueryResultArticle(
id='comment',
title='向{}留言'.format(userinfo.full_name),
description='{}，留言內容為「{}」'.format(
userinfo.format_full_raw(), comment),
input_message_content=telegram.InputTextMessageContent(
message_text=update.inline_query.query, ))
])
return
reviewed_user_id = self.parse_cmd_reanswer(update.inline_query.query)
if reviewed_user_id:
userinfo = Userinfo(reviewed_user_id)
update.inline_query.answer(results=[
telegram.InlineQueryResultArticle(
id='reanswer',
title='要求{}重新作答'.format(userinfo.full_name),
description='{}'.format(userinfo.format_full_raw()),
input_message_content=telegram.InputTextMessageContent(
message_text=update.inline_query.query, ))
])
return
reviewed_user_id = self.parse_cmd_approve(update.inline_query.query)
if reviewed_user_id:
userinfo = Userinfo(reviewed_user_id)
update.inline_query.answer(results=[
telegram.InlineQueryResultArticle(
id='approve',
title='批准{}的申請'.format(userinfo.full_name),
description='{}'.format(userinfo.format_full_raw()),
input_message_content=telegram.InputTextMessageContent(
message_text=update.inline_query.query, ))
])
return
reviewed_user_id = self.parse_cmd_reject(update.inline_query.query)
if reviewed_user_id:
userinfo = Userinfo(reviewed_user_id)
update.inline_query.answer(results=[
telegram.InlineQueryResultArticle(
id='reject',
title='拒絕{}的申請'.format(userinfo.full_name),
description='{}'.format(userinfo.format_full_raw()),
input_message_content=telegram.InputTextMessageContent(
message_text=update.inline_query.query, ))
])
return
if update.inline_query.query:
update.inline_query.answer(results=[
telegram.InlineQueryResultArticle(
id='unknown',
title=update.inline_query.query,
input_message_content=telegram.InputTextMessageContent(
message_text=update.inline_query.query, ))
])
return
def reply(self,
text,
photo_url=None,
reply_to_previous=False,
reply_markup=None,
parse_mode=None,
no_preview=False,
title=None,
to_pm=False,
failed=False,
editable=True,
inline_description=None,
photo_primary=False):
"""
Replies to a message/shows a popup in inline keyboard/sends out inline query result
:param text: Text to send
:type text: :class:`str`
:param photo_url: Photo URLs, with best quality descending to worst
:type photo_url: :class:`list`, optional
:param reply_to_previous: If bot should reply to reply of trigger message, defaults to False. *We need to go deeper*
:type reply_to_previous: :class:`bool`, optional
:param reply_markup: Telegram reply markup
:type reply_markup: :class:`telegram.ReplyMarkup`, optional
:param parse_mode: Parse mode of messages. Become 'html' if photo_url is passed. Available values are `markdown`, `html` and None
:type parse_mode: :class:`str`, optional
:param no_preview: Should the webpage preview be disabled. Defaults to `False`, becomes `False` if `photo_url` is passed
:type no_preview: :class:`bool`, optional
:param title: Title of message for inline mode, defaults to first line of `text`
:type title: :class:`str`, optional
:param to_pm: If message should be sent into user PM
:type to_pm: :class:`bool`
:param failed: Pass :obj:`True` if command failed to execute. defaults to :obj:`False`
:type failed: :class:`bool`, optional
:param editable: Pass :obj:`False` if you want your command NOT to be editable, defaults to :obj:`True`
:type editable: :class:`bool`, optional
:param inline_description: Description for inline mode, optional, defaults to first 400 symbols of `text`
:type inline_description: :class:`str`
"""
reply_markup, kbd_id = rebuild_inline_markup(reply_markup, self)
if photo_url and not photo_primary:
if parse_mode is None or parse_mode.lower() != "html":
parse_mode = "html"
text = html.escape(text)
text = add_photo_to_text(text, photo_url)
if title is None:
title = self.text[:20]
if self.update_type == UpdateType.message or to_pm:
if reply_to_previous and (self.update.message.reply_to_message
is not None):
target_msg: telegram.Message = self.update.message.reply_to_message
else:
target_msg: telegram.Message = self.update.message
kwargs = dict(chat_id=target_msg.chat_id,
parse_mode=parse_mode,
reply_markup=reply_markup,
disable_web_page_preview=no_preview,
reply_to_message_id=target_msg.message_id)
if to_pm:
kwargs["chat_id"] = self.user.id
del kwargs["reply_to_message_id"]
if photo_url and photo_primary:
try:
message = self.bot.send_photo(caption=text,
photo=photo_url[0],
**kwargs)
except telegram.error.TelegramError:
if parse_mode.lower() != 'html':
text = html.escape(text)
text = f'<b><a href="{photo_url[0]}">Link to image</a></b>\n\n' + text
message = self.bot.send_photo(caption=text,
photo=Settings.no_image,
**kwargs)
else:
message = self.bot.send_message(text=text, **kwargs)
if octobot.Database.redis is not None and editable:
octobot.Database.redis.set(
octobot.utils.generate_edit_id(self.update.message),
message.message_id)
octobot.Database.redis.expire(
octobot.utils.generate_edit_id(self.update.message), 30)
self.edit_tgt = message.message_id
return message
elif self.update_type == UpdateType.edited_message and octobot.Database.redis is not None:
return self.edit(text=text,
photo_url=photo_url,
reply_markup=reply_markup,
parse_mode=parse_mode)
elif self.update_type == UpdateType.inline_query:
inline_content = telegram.InputTextMessageContent(
text,
parse_mode=parse_mode,
disable_web_page_preview=no_preview)
result = telegram.InlineQueryResultArticle(
self.update.inline_query.query,
title=title,
description=cleanhtml(text)[:500]
if inline_description is None else inline_description,
input_message_content=inline_content,
reply_markup=reply_markup,
thumb_url=photo_url)
self.update.inline_query.answer(
[result], cache_time=(360 if Settings.production else 0))
elif self.update_type == UpdateType.button_press:
self.update.callback_query.answer(text)
def parseInlineQuery(bot, update):
q = update.inline_query.query
# actual inline query results to present to the user
results = []
if q.lower() == 'gen':
# if it's simply 'gen', we fill our results with a generated SIGARETTO
restext = gen.generate()
results.append(
telegram.InlineQueryResultArticle(
type='article',
id=uuid.uuid4(),
thumb_url=utils.thumbnail(),
thumb_width=AVATAR_SIZE,
thumb_height=AVATAR_SIZE,
title='SIGARETTO #GENERATED',
description=restext[:200],
input_message_content=telegram.InputTextMessageContent(
message_text=restext, parse_mode=None)))
else:
# we have to search
# search results:
res = []
# try to detect if user asked for a SIGA id or a regex search (starting with "-r ")
asked_siga = parseSigaNumber(q)
if asked_siga:
# yes, pick it
res = [getS(sl, asked_siga)]
elif q.startswith('-r '):
# no, but a regex search is invoked
q = q[3:]
res = regexSearch(q, sl)
else:
# neither special case is required, normal search
res = normalSearch(q, sl)
# search completed, we now have all matching results in res, which may or may not be empty
if not res:
# empty, send bogus SIGA
restext = random.choice(notfound.notfound)
if "%s" in restext:
restext = restext % q
results.append(
telegram.InlineQueryResultArticle(
type='article',
id=uuid.uuid4(),
thumb_url=utils.thumbnail(),
thumb_width=AVATAR_SIZE,
thumb_height=AVATAR_SIZE,
title='SIGARETTO #NOT_FOUND',
description=restext[:200],
input_message_content=telegram.InputTextMessageContent(
message_text=restext, parse_mode=None)))
else:
# non-empty, build list of actual results
for i in res:
restext = i['text']
sid = i['id']
authorid = i['authorid']
# if sid in img_cache:
# results.append(telegram.InlineQueryResultPhoto(
# type='photo',
# id=sid,
# photo_url=img_url(sid),
# thumb_url=utils.thumbnail(authorid),
# title='SIGARETTO #%d' % sid,
# description=restext[:200],
# caption=restext[:200],
# photo_file_id=img_cache[sid],
# ))
# elif sid in audio_cache:
# results.append(telegram.InlineQueryResultAudio(
# type='audio',
# id=sid,
# audio_url=audio_url(sid),
# title='SIGARETTO #%d' % sid,
# caption=restext[:200]
# # to be completed with other parameters
# ))
fulltext = restext
if sid in videos:
fulltext = restext + "\n\n" + videos[sid]
results.append(
telegram.InlineQueryResultArticle(
type='article',
id=sid,
thumb_url=utils.thumbnail(authorid),
thumb_width=AVATAR_SIZE,
thumb_height=AVATAR_SIZE,
title='SIGARETTO #%d' % sid,
description=restext[:200],
input_message_content=telegram.InputTextMessageContent(
message_text=fulltext, parse_mode=None)))
# all cases examined, we now have a results array and can answer the query
bot.answerInlineQuery(update.inline_query.id, results, cache_time=0)
logger.info(update)
def inline_query(bot, update):
query = update.inline_query.query
results = []
user_id = str(update.inline_query.from_user.id)
first_name = update.inline_query.from_user.first_name
if not query:
results.append(
telegram.InlineQueryResultArticle(
id="commands",
title="Commands",
input_message_content=telegram.InputTextMessageContent((
"Type @hkobservatory_bot + one of the following:\n"
"topics;\ntellme + topic;\nsubscribe + topic;\nunsubscribe + topic;\nenglish;\n繁體中文;\n简体中文;"
)),
description="List of available commands"))
else:
if query.lower() in "topics":
results.append(
telegram.InlineQueryResultArticle(
id="topics",
title="Topics",
input_message_content=telegram.InputTextMessageContent(
get_topics()),
description="List of available topics"))
if query.lower() in "tellme current":
results.append(
telegram.InlineQueryResultArticle(
id="tellme_current",
title="Current Weather",
input_message_content=telegram.InputTextMessageContent(
get_feed_message(user_id, "current")),
description="Current weather from the HK Observatory"))
if query.lower() in "tellme warning":
results.append(
telegram.InlineQueryResultArticle(
id="tellme_warning",
title="Warning",
input_message_content=telegram.InputTextMessageContent(
get_feed_message(user_id, "warning")),
description="Warnings in force"))
if query.lower() in "subscribe current":
results.append(
telegram.InlineQueryResultArticle(
id="sub_current",
title="Subscribe Current",
input_message_content=telegram.InputTextMessageContent(
first_name + " has subscribed to: Current"),
description="Subscribe to current to receive updates"))
if query.lower() in "subscribe warning":
results.append(
telegram.InlineQueryResultArticle(
id="sub_warning",
title="Subscribe Warning",
input_message_content=telegram.InputTextMessageContent(
first_name + " has subscribed to: Warning"),
description="Subscribe to warning to receive updates"))
if query.lower() in "unsubscribe current":
results.append(
telegram.InlineQueryResultArticle(
id="unsub_current",
title="Unsubscribe Current",
input_message_content=telegram.InputTextMessageContent(
first_name + " has unsubscribed from: Current"),
description=
"Unsubscribe from current to stop receiving updates"))
if query.lower() in "unsubscribe warning":
results.append(
telegram.InlineQueryResultArticle(
id="unsub_warning",
title="Unsubscribe Warning",
input_message_content=telegram.InputTextMessageContent(
first_name + " has unsubscribed from: Warning"),
description=
"Unsubscribe from warning to stop receiving updates"))
if query.lower() in "english":
results.append(
telegram.InlineQueryResultArticle(
id="lang_english",
title="English",
input_message_content=telegram.InputTextMessageContent(
first_name + "\'s language changed to English"),
description="Select English as topic information language")
)
if query in "繁體中文":
results.append(
telegram.InlineQueryResultArticle(
id="lang_traditional",
title="繁體中文",
input_message_content=telegram.InputTextMessageContent(
first_name + "\'s language changed to 繁體中文"),
description="Select 繁體中文 as topic information language"))
if query in "简体中文":
results.append(
telegram.InlineQueryResultArticle(
id="lang_simplified",
title="简体中文",
input_message_content=telegram.InputTextMessageContent(
first_name + "\'s language changed to 简体中文"),
description="Select 简体中文 as topic information language"))
bot.answerInlineQuery(update.inline_query.id, results, cache_time=0)
def handle_old(bot):
global update_id
# Request updates after the last update_id
for update in bot.getUpdates(offset=update_id, timeout=10):
# chat_id is required to reply to any message
update_id = update.update_id + 1
#print(update.message)
print(update)
if update.message: # your bot can receive updates without messages
chat_id = update.message.chat_id
player_info[chat_id] = update.message.from_user
# Reply to the message
if update.message.text.startswith("/start") and len(update.message.text.split()) == 1:
bot.send_message(chat_id = chat_id,parse_mode="Markdown", text = "Welcome!\n`/create [GAMETYPE]`\t\t-create a game\n`/join [GAMEID]`\t-join a game\n`/leave`\t\t-leave game\n\n*Available game types:*\nresistance\nticktacktoe\nrockpaperscissors")
elif update.message.text.startswith("/join") or update.message.text.startswith("/start join"):
if update.message.text.startswith("/start join"):
ss = ["/join", update.message.text[len("/start join_"):]]
else:
ss = update.message.text.split()
if len(ss) < 2:
bot.send_message(chat_id = chat_id, text = "Use\n/join [GAMEID]\n to join a game")
else:
if chat_id in player_gameids:
bot.send_message(chat_id = chat_id, text = "You are already in a game!")
continue
try:
gameid = ss[1]
if gameid not in games:
bot.send_message(chat_id = chat_id, text = "That game doesn't exist")
else:
join_game(chat_id, gameid)
except ValueError:
bot.send_message(chat_id = chat_id, text = "Id not valid")
elif update.message.text.startswith("/create"):
if chat_id in player_gameids:
bot.send_message(chat_id = chat_id, text = "You are already in a game!")
continue
ss = update.message.text.split()
if len(ss) < 2:
gt = my_games.game_types[my_games.DEFAULT_GAME]
else:
if ss[1].lower() not in my_games.game_types:
bot.send_message(chat_id = chat_id, text = "Game type doesn't exist.")
else:
gt = my_games.game_types[ss[1].lower()]
gg = gt(update_view, leave_foo, creator=chat_id, player_info=player_info)
games[gg.id] = gg
bot.send_message(chat_id = chat_id, text = "Created game {gameid}".format(gameid = gg.id))
buttons = telegram.InlineKeyboardMarkup([[telegram.InlineKeyboardButton(text = "Share", switch_inline_query = "")]])
bot.send_message(chat_id = chat_id, text = "/join {gameid}".format(gameid = gg.id), reply_markup=buttons)
join_game(chat_id, gg.id)
elif update.message.text.startswith("/leave"):
if chat_id not in player_gameids:
bot.send_message(chat_id = chat_id, text = "You are not in a game!")
else:
gid = player_gameids[chat_id]
games[gid].cancel()
del games[gid]
pass
elif update.callback_query:
#from_id = update.callback_query.from_user.id
from_id = update.callback_query.message.chat.id
data = update.callback_query.data
notif = None
if from_id in player_gameids:
notif = games[player_gameids[from_id]].handle_action(from_id, data)
bot.answer_callback_query(callback_query_id=update.callback_query.id, text = notif)
elif update.inline_query:
q = update.inline_query.query
qid = update.inline_query.id
fid = update.inline_query.from_user.id
if q.startswith("join"):
qs = "_".join(q.split())
bot.answer_inline_query(inline_query_id = qid, results=[], switch_pm_text="Join game", switch_pm_parameter=qs, cache_time = 0, is_personal = True)
elif fid not in player_info:
bot.answer_inline_query(inline_query_id = qid, results=[], switch_pm_text="Start bot", switch_pm_parameter="start", cache_time = 0, is_personal = True)
elif fid in player_gameids:
gameid = player_gameids[fid]
gt = games[gameid].type
butts = telegram.InlineKeyboardMarkup([[telegram.InlineKeyboardButton(text = "Join", switch_inline_query_current_chat = "join " + gameid)]])
results = [telegram.InlineQueryResultArticle(id=hex(getrandbits(64))[2:],
title= "*" + str(gt) + "* " + str(gameid),
reply_markup=butts,
input_message_content = telegram.InputTextMessageContent(message_text="Play a game of *" + gt + "* with me!",
parse_mode="Markdown"))]
bot.answer_inline_query(inline_query_id = qid, results=results, cache_time = 0, is_personal = True)
else:
def makeres(gt):
gameid = str(uuid.uuid4().hex)[:8]
butts = telegram.InlineKeyboardMarkup([[telegram.InlineKeyboardButton(text = "Join", switch_inline_query_current_chat = "join " + gameid)]])
return telegram.InlineQueryResultArticle(id= str(gt) + "_" + str(gameid),
title= "Create new *" + str(gt) + "*",
reply_markup = butts,
input_message_content = telegram.InputTextMessageContent(message_text="Play a game of *" + gt + "* with me!",
parse_mode="Markdown"))
results = [makeres(gt) for gt in my_games.game_types.keys()]
bot.answer_inline_query(inline_query_id = qid, results=results, cache_time = 0, is_personal = True)
elif update.chosen_inline_result:
rid = update.chosen_inline_result.result_id
if "_" not in rid:
continue
chat_id = update.chosen_inline_result.from_user.id
gt, gameid = rid.split("_")
gg = my_games.game_types[gt](update_view, leave_foo, creator=chat_id, player_info=player_info)
gg.id = gameid
games[gg.id] = gg
bot.send_message(chat_id = chat_id, text = "Created game {gameid}".format(gameid = gg.id))
buttons = telegram.InlineKeyboardMarkup([[telegram.InlineKeyboardButton(text = "Share", switch_inline_query = "")]])
bot.send_message(chat_id = chat_id, text = "/join {gameid}".format(gameid = gg.id), reply_markup=buttons)
join_game(chat_id, gg.id)
