def create_bot(token, translator):
""" Create a new bot instance
"""
return telepot.async.DelegatorBot(token, [
(per_inline_from_id(), create_open(
BabelegramHandler, timeout=60, translator=translator)),
])
def create_bot(token, translator_engine):
""" Create a new bot instance
"""
return telepot. async .DelegatorBot(token, [
(per_inline_from_id(),
create_open(BabelegramHandler,
timeout=60,
translator_engine=translator_engine)),
])
# Display message counts separated by flavors
print(self.id, ':',
flavor, '+1', ':',
', '.join([str(self._counts[f]) for f in ['normal', 'inline_query', 'chosen_inline_result']]))
# Have to answer inline query to receive chosen result
if flavor == 'inline_query':
def compute_answer():
query_id, from_id, query_string = telepot.glance(msg, flavor=flavor)
articles = [{'type': 'article',
'id': 'abc', 'title': query_string, 'message_text': query_string}]
return articles
self._answerer.answer(msg, compute_answer)
TOKEN = sys.argv[1]
bot = telepot.async.DelegatorBot(TOKEN, [
(per_from_id(), create_open(UserTracker, timeout=20)),
])
loop = asyncio.get_event_loop()
loop.create_task(bot.messageLoop())
print('Listening ...')
loop.run_forever()
def on_message(self, msg):
self._count += 1
flavor = telepot.flavor(msg)
print('%s %d: %d: %s: %s' % (type(self).__name__, self.id, self._count, flavor, telepot.glance(msg, flavor=flavor)))
# Do some simple stuff for every message, to be paired with per_message()
def simple_function(seed_tuple):
bot, msg, id = seed_tuple
print('Simply print:', msg)
TOKEN = sys.argv[1]
bot = telepot.async.DelegatorBot(TOKEN, [
(per_chat_id(), create_open(ChatHandlerSubclass, timeout=10)),
(per_from_id(), create_open(UserHandlerSubclass, timeout=20)),
(per_inline_from_id(), create_open(UserHandlerSubclassInlineOnly, timeout=10)),
(per_application(), create_open(OnlyOneInstance)),
(per_message(), call(simple_function)),
])
loop = asyncio.get_event_loop()
loop.create_task(bot.messageLoop())
print('Listening ...')
def on_message(self, msg):
self._count += 1
flavor = telepot.flavor(msg)
print('%s %d: %d: %s: %s' % (type(self).__name__, self.id, self._count, flavor, telepot.glance(msg, flavor=flavor)))
# Do some simple stuff for every message, to be paired with per_message()
def simple_function(seed_tuple):
bot, msg, id = seed_tuple
print('Simply print:', msg)
TOKEN = sys.argv[1]
bot = telepot.async.DelegatorBot(TOKEN, [
(per_chat_id(), create_open(ChatHandlerSubclass, timeout=10)),
(per_from_id(), create_open(UserHandlerSubclass, timeout=20)),
(per_inline_from_id(), create_open(InlineUserHandlerSubclass, timeout=10)),
(per_application(), create_open(OneInstanceOnly)),
(per_message(), call(simple_function)),
])
loop = asyncio.get_event_loop()
loop.create_task(bot.message_loop())
print('Listening ...')
@asyncio.coroutine
def on_message(self, msg):
flavor = telepot.flavor(msg)
if flavor == 'inline_query':
query_id, from_id, query_string = telepot.glance2(msg, flavor=flavor)
print(self.id, ':', 'Inline Query:', query_id, from_id, query_string)
articles = [{'type': 'article',
'id': 'abc', 'title': 'ABC', 'message_text': 'Good morning'}]
yield from self.bot.answerInlineQuery(query_id, articles)
print(self.id, ':', 'Answers sent.')
elif flavor == 'chosen_inline_result':
result_id, from_id, query_string = telepot.glance2(msg, flavor=flavor)
print(self.id, ':', 'Chosen Inline Result:', result_id, from_id, query_string)
TOKEN = sys.argv[1]
bot = telepot.async.DelegatorBot(TOKEN, [
(per_inline_from_id(), create_open(InlineHandler, timeout=10)),
])
loop = asyncio.get_event_loop()
loop.create_task(bot.messageLoop())
print('Listening ...')
loop.run_forever()
@asyncio.coroutine
def on_callback_query(self, msg):
query_id, from_id, query_data = telepot.glance(msg, flavor='callback_query')
print ('Callback Query:', query_id, from_id, query_data)
if query_data == 'dailyupdates':
yield from self.sender.sendMessage("Got it! \U0001f60d"
"\nLet\'s start with the current headlines!")
items = news_source.get_top_news(3)
for item in items:
print("Got an item")
yield from self.sender.sendMessage("*{}*\n{}".format(item.title, item.description), parse_mode='Markdown')
elif query_data == 'noupdates':
yield from self.sender.sendMessage("Ok, I\'ll keep my mouth shut untill you ask me! \U0001f64a")
news_source = NewsDataSource.NewsDataSource('http://s.nos.nl/extern/nieuws.json')
TOKEN = sys.argv[1] # get token from command-line
bot = telepot.async.DelegatorBot(TOKEN, [
(per_chat_id(), create_open(NosBot, timeout=10)),
])
loop = asyncio.get_event_loop()
loop.create_task(bot.message_loop())
print('Listening ...')
loop.run_forever()
flavors=['inline_query', 'chosen_inline_result'])
self._count = 0
def on_message(self, msg):
self._count += 1
flavor = telepot.flavor(msg)
print('%s %d: %d: %s: %s' %
(type(self).__name__, self.id, self._count, flavor,
telepot.glance(msg, flavor=flavor)))
def on_close(self, exception):
print('%s %d: closed' % (type(self).__name__, self.id))
TOKEN = sys.argv[1]
bot = telepot. async .DelegatorBot(TOKEN, [
(per_chat_id(), create_open(ChatHandlerSubclass, timeout=10)),
(per_from_id(), create_open(UserHandlerSubclass, timeout=20)),
(per_inline_from_id(),
create_open(UserHandlerSubclassInlineOnly, timeout=10)),
])
loop = asyncio.get_event_loop()
loop.create_task(bot.messageLoop())
print('Listening ...')
loop.run_forever()
print(self.id, ':', 'Inline Query:', query_id, from_id, query_string)
articles = [{
'type': 'article',
'id': 'abc',
'title': 'ABC',
'message_text': 'Good morning'
}]
yield from self.bot.answerInlineQuery(query_id, articles)
print(self.id, ':', 'Answers sent.')
def on_chosen_inline_result(self, msg):
result_id, from_id, query_string = telepot.glance(
msg, flavor='chosen_inline_result')
print(self.id, ':', 'Chosen Inline Result:', result_id, from_id,
query_string)
TOKEN = sys.argv[1]
bot = telepot. async .DelegatorBot(TOKEN, [
(per_inline_from_id(), create_open(InlineHandler, timeout=10)),
])
loop = asyncio.get_event_loop()
loop.create_task(bot.messageLoop())
print('Listening ...')
loop.run_forever()
from telepot. async .delegate import create_open
"""
$ python3.4 countera.py <token>
Count number of messages. Start over if silent for 10 seconds.
"""
class MessageCounter(telepot.helper.ChatHandler):
def __init__(self, seed_tuple, timeout):
super(MessageCounter, self).__init__(seed_tuple, timeout)
self._count = 0
@asyncio.coroutine
def on_message(self, msg):
self._count += 1
yield from self.sender.sendMessage(self._count)
TOKEN = sys.argv[1] # get token from command-line
bot = telepot. async .DelegatorBot(TOKEN, [
(per_chat_id(), create_open(MessageCounter, timeout=10)),
])
loop = asyncio.get_event_loop()
loop.create_task(bot.messageLoop())
print('Listening ...')
loop.run_forever()
#!/usr/bin/env python3
import asyncio
import yaml
import telepot
from telepot. async .delegate import create_open
from telepot.delegate import per_chat_id
from tomatotimertgbot import Tomato
if __name__ == "__main__":
config = yaml.load(open("config.yml", "r"))
bot = telepot. async .DelegatorBot(config["telegram_bot_id"], [
(per_chat_id(), create_open(Tomato, timeout=72 * 3600)),
])
loop = asyncio.get_event_loop()
loop.create_task(bot.messageLoop())
loop.run_forever()
#!/usr/bin/env python3
import asyncio
import yaml
import telepot
from telepot.async.delegate import create_open
from telepot.delegate import per_chat_id
from tomatotimertgbot import Tomato
if __name__ == "__main__":
config = yaml.load(open("config.yml", "r"))
bot = telepot.async.DelegatorBot(
config["telegram_bot_id"],
[
(per_chat_id(), create_open(
Tomato, timeout=72*3600)),
])
loop = asyncio.get_event_loop()
loop.create_task(bot.messageLoop())
loop.run_forever()
import telepot
from telepot.delegate import per_chat_id
from telepot.async.delegate import create_open
from web import pingforward_web_init
from botdata import get_config_item
from conversationhandler import ConversationHandler
from apipull.apipull import check_api_loop
from autogroup.groupmaster import group_loop
TOKEN = "154397353:AAEChVXNz7BXxenwjNokfryfZqUgiwZLN6A"
class LoggedDelegatorBot(telepot.async.DelegatorBot):
def __init__(self, token, delegation_patterns, loop=None):
super(LoggedDelegatorBot, self).__init__(token, delegation_patterns, loop)
async def sendMessage(self, chat_id, text, parse_mode=None, disable_web_page_preview=None, reply_to_message_id=None, reply_markup=None):
print("[REPLY TO: "+str(chat_id)+"]:\n"+str(text))
await super(LoggedDelegatorBot, self).sendMessage(chat_id, text, parse_mode, disable_web_page_preview, reply_to_message_id, reply_markup)
bot = LoggedDelegatorBot(get_config_item("TELEPOT_TOKEN", TOKEN), [
(per_chat_id(), create_open(ConversationHandler, timeout=get_config_item("TELEPOT_CONVO_TIMEOUT", 60*10))),
])
loop = asyncio.get_event_loop()
loop.create_task(bot.messageLoop())
loop.create_task(check_api_loop(bot, loop))
loop.create_task(group_loop(bot, loop))
loop.create_task(pingforward_web_init(bot,loop))
loop.run_forever()
return articles
self._answerer.answer(msg, compute_answer)
# override default on_chosen_inline_result
def on_chosen_inline_result(self, msg):
pass
# override default logger error in on_close, otherwise logs become messy
def on_close(self, exception):
pass
# fix a bug with UserHandler expecting on_chat_message to be implemented
def on_chat_message(self, msg):
pass
ACCESS_TOKEN = os.getenv('TELEGRAM_API_KEY')
bot = telepot.async.DelegatorBot(ACCESS_TOKEN, [
(per_message(), create_open(YesBot, timeout=0)),
])
loop = asyncio.get_event_loop()
loop.create_task(bot.message_loop())
print('Started!')
loop.run_forever()
def __init__(self, seed_tuple, timeout):
super(UserHandlerSubclassInlineOnly, self).__init__(seed_tuple, timeout, flavors=['inline_query', 'chosen_inline_result'])
self._count = 0
def on_message(self, msg):
self._count += 1
flavor = telepot.flavor(msg)
print('%s %d: %d: %s: %s' % (type(self).__name__, self.id, self._count, flavor, telepot.glance2(msg, flavor=flavor)))
def on_close(self, exception):
print('%s %d: closed' % (type(self).__name__, self.id))
TOKEN = sys.argv[1]
bot = telepot.async.DelegatorBot(TOKEN, [
(per_chat_id(), create_open(ChatHandlerSubclass, timeout=10)),
(per_from_id(), create_open(UserHandlerSubclass, timeout=20)),
(per_inline_from_id(), create_open(UserHandlerSubclassInlineOnly, timeout=10)),
])
loop = asyncio.get_event_loop()
loop.create_task(bot.messageLoop())
print('Listening ...')
loop.run_forever()
guess = int(msg['text'])
except ValueError:
yield from self.sender.sendMessage('Give me a number, please.')
return
# check the guess against the answer ...
if guess != self._answer:
# give a descriptive hint
hint = self._hint(self._answer, guess)
yield from self.sender.sendMessage(hint)
else:
yield from self.sender.sendMessage('Correct!')
self.close()
@asyncio.coroutine
def on_close(self, exception):
if isinstance(exception, telepot.helper.WaitTooLong):
yield from self.sender.sendMessage(
'Game expired. The answer is %d' % self._answer)
bot = telepot. async .DelegatorBot(BOTKEY, [
(per_chat_id(), create_open(Player, timeout=10)),
])
loop = asyncio.get_event_loop()
loop.create_task(bot.messageLoop())
print('Listening ...')
loop.run_forever()
yield from self.sender.sendMessage('Done')
response = yield from bot.sendPhoto(chat_id, f)
# Let admin know :)
#pprint(response)
if (chat_id != admin_chat_id):
yield from bot.sendPhoto(admin_chat_id, response['photo'][-1]['file_id'])
self._count = 0
# Do some simple stuff for every message, to be paired with per_message()
def simple_function(seed_tuple):
bot, msg, id = seed_tuple
content_type, chat_type, chat_id = telepot.glance(msg)
if (chat_id != admin_chat_id):
yield from bot.sendMessage(admin_chat_id,'Request from @'+msg['from']['username'])
yield from bot.forwardMessage(admin_chat_id,chat_id, msg['message_id'])
TOKEN = sys.argv[1] # get token from command-line
bot = telepot.async.DelegatorBot(TOKEN, [
(per_chat_id(), create_open(MessageCounter, timeout=10)),
(per_message(), call(simple_function)),
])
loop = asyncio.get_event_loop()
loop.create_task(bot.message_loop())
print('Listening ...')
loop.run_forever()
except ValueError:
yield from self.sender.sendMessage('Give me a number, please.')
return
# check the guess against the answer ...
if guess != self._answer:
# give a descriptive hint
hint = self._hint(self._answer, guess)
yield from self.sender.sendMessage(hint)
else:
yield from self.sender.sendMessage('Correct!')
self.close()
@asyncio.coroutine
def on_close(self, exception):
if isinstance(exception, telepot.helper.WaitTooLong):
yield from self.sender.sendMessage('Game expired. The answer is %d' % self._answer)
TOKEN = sys.argv[1]
bot = telepot.async.DelegatorBot(TOKEN, [
(per_chat_id(), create_open(Player, timeout=10)),
])
loop = asyncio.get_event_loop()
loop.create_task(bot.messageLoop())
print('Listening ...')
loop.run_forever()
# Display message counts separated by flavors
print(self.id, ':',
flavor, '+1', ':',
', '.join([str(self._counts[f]) for f in ['chat', 'inline_query', 'chosen_inline_result']]))
# Have to answer inline query to receive chosen result
if flavor == 'inline_query':
def compute_answer():
query_id, from_id, query_string = telepot.glance(msg, flavor=flavor)
articles = [{'type': 'article',
'id': 'abc', 'title': query_string, 'message_text': query_string}]
return articles
self._answerer.answer(msg, compute_answer)
TOKEN = sys.argv[1]
bot = telepot.async.DelegatorBot(TOKEN, [
(per_from_id(), create_open(UserTracker, timeout=20)),
])
loop = asyncio.get_event_loop()
loop.create_task(bot.message_loop())
print('Listening ...')
loop.run_forever()
class InlineOnlyHandler(telepot.helper.UserHandler):
def __init__(self, seed_tuple, timeout):
super(InlineOnlyHandler, self).__init__(seed_tuple, timeout, flavors=['inline_query'])
self._count = 0
def on_message(self, msg):
self._count += 1
print('%s %d: %d: %s' % (type(self).__name__, self.id, self._count, telepot.glance2(msg, flavor='inline_query')))
def on_close(self, exception):
print('%s %d: closed' % (type(self).__name__, self.id))
TOKEN = sys.argv[1]
bot = telepot.async.DelegatorBot(TOKEN, [
(per_chat_id(), create_open(MessageOnlyHandler, timeout=10)),
(per_from_id(), create_open(MessageAndInlineHandler, timeout=20)),
(per_inline_from_id(), create_open(InlineOnlyHandler, timeout=10)),
])
loop = asyncio.get_event_loop()
loop.create_task(bot.messageLoop())
print('Listening ...')
loop.run_forever()
