def delegator_beard_gen(beards):
for beard in beards:
if hasattr(beard, "on_callback_query"):
yield include_callback_query_chat_id(pave_event_space())(
per_chat_id(), create_open, beard, timeout=beard._timeout)
else:
yield pave_event_space()(per_chat_id(),
create_open,
beard,
timeout=beard._timeout)
def __init__(self, token, reply_threshold=60, botan_key=None):
super(TeleApp, self).__init__(token, [
pave_event_space()(
per_chat_id(), create_open, TeleChat, timeout=10),
pave_event_space()(
per_inline_from_id(), create_open, TeleInline, timeout=10)
])
self.reply_threshold = reply_threshold
botan.set_key(botan_key)
self._loop = asyncio.get_event_loop()
self.username = self._loop.run_until_complete(self.getMe())['username']
def start(self, token):
self.bot = telepot.aio.DelegatorBot(token, [
include_callback_query_chat_id(
pave_event_space())(
per_chat_id(), create_open, ShoppingUser, timeout=10),
])
self.loop.create_task(MessageLoop(self.bot).run_forever())
self.loop.run_forever()
def main():
bot = telepot.aio.DelegatorBot(TELEGRAM_TOKEN, [
pave_event_space()(
per_chat_id(), create_open, MessageCounter, timeout=10),
])
loop = asyncio.get_event_loop()
loop.create_task(MessageLoop(bot).run_forever())
loop.run_forever()
def main():
# ТУТ БУДЕТ НАШ КОД РАБОТЫ С БАЗОЙ ДАННЫХ
# КОД ДАЛЬНЕЙШИХ ПРИМЕРОВ ВСТАВЛЯТЬ В ЭТО МЕСТО
# Не забываем закрыть соединение с базой данных
TOKEN = sys.argv[1] # get token from command-line
bot = telepot.aio.DelegatorBot(TOKEN, [
pave_event_space()(
per_chat_id(), create_open, AttendanceStarter, timeout=3),
pave_event_space()(
per_callback_query_origin(), create_open, Attendance, timeout=60),
])
loop = asyncio.get_event_loop()
loop.create_task(MessageLoop(bot).run_forever())
print('Listening ...')
loop.run_forever()
def main():
instagram_bot = InstagramAPI(INSTAGRAM_USERNAME, INSTAGRAM_PASSWORD)
instagram_bot.login()
bot = telepot.aio.DelegatorBot(config('TOKEN'), [
include_callback_query_chat_id(pave_event_space())(
per_chat_id(types=['private']), create_open, GeneratePostChatHandler, timeout=10),
])
loop = asyncio.get_event_loop()
loop.create_task(MessageLoop(bot).run_forever())
print('Listening ...')
loop.run_forever()
def __init__(self, configuration):
self._admins_telegram_ids = configuration.admins_telegram_ids
self._delegator_bot = telepot.aio.DelegatorBot(
configuration.token,
[
# If the bot isn't chatting with an admin, skip, so for this
# chat will be used another handler, not AdminHandler.
pave_event_space()(
per_from_id_in(self._admins_telegram_ids),
create_open,
AdminHandler,
timeout=60,
),
# If the bot is chatting with an admin, skip, so for this chat
# will be used another handler, not StrangerHandler.
pave_event_space()(
per_from_id_except(self._admins_telegram_ids),
create_open,
StrangerHandler,
timeout=60,
),
],
)
def main(token):
bot = telepot.aio.DelegatorBot(token, [
include_callback_query_chat_id(pave_event_space())(
per_chat_id(types=['private']),
create_open,
LentaReader,
timeout=10),
])
loop = asyncio.get_event_loop()
loop.create_task(MessageLoop(bot).run_forever())
print('Listening ...')
loop.run_forever()
def run(cls):
token = os.environ['token']
# token = botconfig.token()
bot = telepot.aio.DelegatorBot(token, [
pave_event_space()(
per_chat_id(), create_open, cls, timeout=cls.timeout),
])
loop = asyncio.get_event_loop()
loop.create_task(MessageLoop(bot).run_forever())
print('Listening ...')
loop.run_forever()
def __init__(self, token, owner_id):
self._owner_id = owner_id
self._seen = set()
self._store = UnreadStore()
super(ChatBox, self).__init__(token, [
# Here is a delegate to specially handle owner commands.
pave_event_space()(
per_chat_id_in([owner_id]), create_open, OwnerHandler, self._store, timeout=20),
# Only one MessageSaver is ever spawned for entire application.
(per_application(), create_open(MessageSaver, self._store, exclude=[owner_id])),
# For senders never seen before, send him a welcome message.
(self._is_newcomer, call(self._send_welcome)),
])
def main(args=None):
"""The main routine"""
if args is None:
args = sys.argv[1:]
bot = telepot.aio.DelegatorBot(TOKEN, [
include_callback_query_chat_id(pave_event_space())(
per_chat_id(types=["group"]),
create_open,
DudoHandler,
timeout=300),
])
loop = asyncio.get_event_loop()
loop.create_task(MessageLoop(bot).run_forever())
loop.run_forever()
def __init__(self, token, owner_id):
self._owner_id = owner_id
self._seen = set()
self._store = UnreadStore()
super(ChatBox, self).__init__(token, [
# Here is a delegate to specially handle owner commands.
pave_event_space()(
per_chat_id_in([owner_id]), create_open, OwnerHandler, self._store, timeout=20),
# Only one MessageSaver is ever spawned for entire application.
(per_application(), create_open(MessageSaver, self._store, exclude=[owner_id])),
# For senders never seen before, send him a welcome message.
(self._is_newcomer, call(self._send_welcome)),
])
def __init__(self):
self.token = open(config.TOKEN_FILE).read().strip()
self._seen = set()
super(BotManager, self).__init__(self.token, [
pave_event_space()(
per_from_id_in(config.WHITELIST)
if config.WHITELIST
else per_from_id(),
create_open,
chatbot.ChatBot,
None,
timeout=10 * 60
),
(
per_application(),
create_open(adminmonitor.AdminMonitor, config.ADMINS_LIST)
),
])
packname = msg['text']
try:
await self.sender.sendChatAction('typing')
await bot.addStickerToSet(self.from_id, packname,
'BQADBAADiQIAAlrMkFAokegTxHmJZAI',
self.stickeremoji)
await asyncio.sleep(10.0)
setobj = await bot.getStickerSet(packname)
testid = setobj['stickers'][-1]['file_id']
await bot.deleteStickerFromSet(testid)
self.packname = packname
self.packtitle = False
self.packmade = True
self.editing = True
await self.sender.sendMessage(self.donemsg)
except telepot.exception.TelegramError as e:
await self.sender.sendMessage(
'Sorry you dont appear to be the owner of this pack or it doesnt exist.'
)
print(e)
bot = telepot.aio.DelegatorBot(key['telegram'], [
pave_event_space()(per_chat_id(), create_open, Stickers,
timeout=70 * 1300),
])
loop = asyncio.get_event_loop()
loop.create_task(MessageLoop(bot).run_forever())
print('Started...')
loop.run_forever()
async def on_callback_query(self, msg):
query_id, from_id, query_data = glance(msg, flavor='callback_query')
print(msg)
letter = {
'name': msg['from']['first_name'],
'chid': msg['message']['chat']['id'],
'type': '',
'orgn': msg['message']['text']
}
q = query_data.split('♡')
print(q)
me = key_.adds('me')
mew = key_.adds('mew')
bot = telepot.aio.DelegatorBot(key_.kids('beta'), [
pave_event_space()(per_chat_id(), create_open, Emperor, timeout=3),
pave_event_space()(
per_callback_query_origin(), create_open, Slave, timeout=300),
])
sys.stdout = Unbuffered(sys.stdout)
loop = asyncio.get_event_loop()
loop.create_task(MessageLoop(bot).run_forever())
print('<--- --- Listening ... --- --->')
loop.run_forever()
class MessageCounter(telepot.aio.helper.ChatHandler):
def __init__(self, *args, **kwargs):
super(MessageCounter, self).__init__(*args, **kwargs)
self._count = 0
async def on_chat_message(self, msg):
self._count += 1
await self.sender.sendMessage(self._count)
TOKEN = sys.argv[1]
PORT = int(sys.argv[2])
URL = sys.argv[3]
bot = telepot.aio.DelegatorBot(TOKEN, [pave_event_space()(per_chat_id(), create_open, MessageCounter, timeout=10)])
update_queue = asyncio.Queue() # channel between web app and bot
async def webhook(request):
data = await request.text()
await update_queue.put(data) # pass update to bot
return web.Response(body="OK".encode("utf-8"))
async def init(loop):
app = web.Application(loop=loop)
app.router.add_route("GET", "/abc", webhook)
app.router.add_route("POST", "/abc", webhook)
srv = await loop.create_server(app.make_handler(), "0.0.0.0", PORT)
question = intro[0]['X'] + self.symptom + '?'
kb = ReplyKeyboardMarkup(keyboard=[['Yes', 'No']])
await bot.sendMessage(id,
gesture + question,
reply_markup=kb)
self.previous_msg = 'Yes'
elif (msg['text'] == 'Diagnose'):
diagnose = list(self.prolog.query('diagnose(X)', maxresult=1))
self.diagnose = diagnose[0]['X']
if (self.diagnose == 'no_illness'):
outcome = 'You are perfectly healthy! Do continue to exercise and keep fit!'
else:
outcome = 'Based on the symptom(s), you are likely to have {}. Please visit the nearby clinic to get help.'.format(
self.diagnose)
await bot.sendMessage(id, outcome)
exit()
TOKEN = "1150310497:AAEYmBDdkP21yfCmQR6xd4E2VSPR5p0UNnY"
bot = telepot.aio.DelegatorBot(TOKEN, [
pave_event_space()(
per_chat_id(), create_open, PrologInteractor, timeout=500),
])
loop = asyncio.get_event_loop()
loop.create_task(MessageLoop(bot).run_forever())
print('Listening ...')
loop.run_forever()
self.prolog = Prolog()
self.prolog.consult('Askid.pl')
self.unused_activities = list(self.activities.keys())
self.question = random.choice(list(self.activities.keys()))
self.activity = self.question
self.prolog.assertz('curr({})'.format(self.question))
else:
self.question = random.choice(self.unused_activities)
self.activity = self.question
self.prolog.assertz('curr({})'.format(self.question))
self.prolog.query("assert(asked('{}'))".format(
self.activities[self.question]))
kb = ReplyKeyboardMarkup(keyboard=[['YES', 'NO']])
# await self.sender.sendMessage(self.activities[self.question], reply_markup = kb)
await bot.sendMessage(id, self.activities[self.question], reply_markup=kb)
# get token from command-line
TOKEN = <YOUR TOKEN>
bot = telepot.aio.DelegatorBot(TOKEN, [
pave_event_space()(
per_chat_id(), create_open, PrologReplier, timeout=500),
])
loop = asyncio.get_event_loop()
loop.create_task(MessageLoop(bot).run_forever())
print('Listening ...')
loop.run_forever()
class MessageHandler(telepot.aio.helper.ChatHandler):
def __init__(self, *args, **kwargs):
super(MessageHandler, self).__init__(*args, **kwargs)
async def on_chat_message(self, msg):
if msg["from"]["id"] == SECRETS.CHAT_ID:
await on_chat_Handler(msg, SECRETS.CHAT_ID)
else:
pass
# send telegram message
async def send_telegram_msg(msg):
try:
await bot.sendMessage(SECRETS.CHAT_ID, msg)
except:
pass
# initialize telegram
bot = telepot.aio.DelegatorBot(API_KEY, [
pave_event_space()(per_chat_id(), create_open, MessageHandler, timeout=20),
])
loop = asyncio.get_event_loop()
loop.create_task(MessageLoop(bot).run_forever())
client.run(SECRETS.TOKEN)
print('Listening ...')
loop.run_forever()
if guess != self._answer:
response = requests.get('http://numbersapi.com/' + str(guess),
headers=headers,
params=params)
# give a descriptive hint
hint = self._hint(self._answer, guess)
await self.sender.sendMessage("try something " + hint + "\n" +
response.text)
else:
await self.sender.sendMessage('Correct!')
self.close()
async def on__idle(self, event):
await self.sender.sendMessage(
'Game expired. The answer is %d.\n Please frequent the @VergeZoo \n Calling out @XVGPufferfish, @GorillaChain, @Simple_Dolphin, and @XVGHawk'
% self._answer)
self.close()
TOKEN = sys.argv[1]
bot = telepot.aio.DelegatorBot(TOKEN, [
pave_event_space()(per_chat_id(), create_open, Player, timeout=60),
])
loop = asyncio.get_event_loop()
loop.create_task(MessageLoop(bot).run_forever())
print('Listening ...')
loop.run_forever()
print('data path: ' + data_path)
formatter = logging.Formatter('%(asctime)s | %(levelname)s | %(message)s')
stream_logger = logging.StreamHandler()
stream_logger.setFormatter(formatter)
stream_logger.setLevel(logging.DEBUG)
logging.basicConfig(level=logging.DEBUG, handlers=[stream_logger])
loop = asyncio.get_event_loop()
registry = session.SessionRegistry()
bot = telepot.aio.DelegatorBot(
token,
[pave_event_space()(
per_chat_id(), create_open, session.Session, data_path, loop,
registry, timeout=20 * 60)],
loop
)
loop.create_task(bot.message_loop())
def sigint_handler():
logging.info('SIGINT')
try:
registry.close_all()
except Exception as e:
logging.error(e)
finally:
loop.stop()
loop.add_signal_handler(signal.SIGINT, sigint_handler)
# db = shelve.open("session.db", "c", writeback=True)
atexit.register(lambda: k.saveBrain('brain.sav'))
k = Kernel() # sessionStore=db)
k.learn("startup.xml")
k.respond("load aiml b")
class MessageKiller(telepot.aio.helper.ChatHandler):
def __init__(self, *args, **kwargs):
super(MessageKiller, self).__init__(*args, **kwargs)
async def on_chat_message(self, msg):
print("Message text ", msg["text"])
res = k.respond(msg["text"]).replace(" ", " ").replace(" ", " ")
print("Response ", res)
await self.sender.sendMessage(res)
TOKEN = "here_goes_bot_token"
bot = telepot.aio.DelegatorBot(TOKEN, [
pave_event_space()(per_chat_id(), create_open, MessageKiller, timeout=30),
])
loop = asyncio.get_event_loop()
loop.create_task(MessageLoop(bot).run_forever())
print('Listening ...')
loop.run_forever()
"""
$ python3.5 countera.py <token>
Counts number of messages a user has sent. Starts over if silent for 10 seconds.
Illustrates the basic usage of `DelegateBot` and `ChatHandler`.
"""
class MessageCounter(telepot.aio.helper.ChatHandler):
def __init__(self, *args, **kwargs):
super(MessageCounter, self).__init__(*args, **kwargs)
self._count = 0
async def on_chat_message(self, msg):
self._count += 1
await self.sender.sendMessage(self._count)
TOKEN = sys.argv[1] # get token from command-line
bot = telepot.aio.DelegatorBot(TOKEN, [
pave_event_space()(
per_chat_id(), create_open, MessageCounter, timeout=10),
])
loop = asyncio.get_event_loop()
loop.create_task(bot.message_loop())
print('Listening ...')
loop.run_forever()
chunk_size = len(lst) // chunk_count
return [lst[i:i + chunk_size] for i in range(0, len(lst), chunk_size)]
'''
keyboard = InlineKeyboardMarkup(inline_keyboard=[
[InlineKeyboardButton(text='Press me', callback_data='4')],
])
bot.sendMessage(chat_id, 'Use inline keyboard', reply_markup=keyboard)
'''
TOKEN = sys.argv[1] # get token from command-line
# bot = telepot.aio.Bot(TOKEN)
bot = telepot.aio.DelegatorBot(TOKEN, [
pave_event_space()(
per_chat_id(), create_open, SheluderStarter, timeout=3),
pave_event_space()(
per_callback_query_origin(), create_open, Sheluder, timeout=60),
])
loop = asyncio.get_event_loop()
loop.create_task(MessageLoop(bot).run_forever())
print('Listening ...')
loop.run_forever()
async def on_chat_message(self, msg):
cid = self.chat_id
content_type, chat_type, chat_id = telepot.glance(msg)
if content_type != 'text':
return
text = msg['text']
if not text.startswith(BOT_PREFIX):
return
if msg['text'] != (BOT_PREFIX + 'sub'):
return
SUBSCRIBED_CHAT_ID.add(cid)
await self.sender.sendMessage('Subscribed to updates')
TOKEN = sys.argv[1] # get token from command-line
bot = telepot.aio.DelegatorBot(TOKEN, [
pave_event_space()(per_chat_id(), create_open, Idler, timeout=10),
])
loop = asyncio.get_event_loop()
loop.create_task(MessageLoop(bot).run_forever())
print('Listening ...')
loop.run_forever()
if content_type == 'text':
sent = await bot.sendInvoice(
chat_id, "Nick's Hand Cream", "Keep a man's hand like a woman's",
payload='a-string-identifying-related-payment-messages-tuvwxyz',
provider_token=PAYMENT_PROVIDER_TOKEN,
start_parameter='abc',
currency='HKD', prices=[
LabeledPrice(label='One Case', amount=987),
LabeledPrice(label='Package', amount=12)],
need_shipping_address=True, is_flexible=True) # required for shipping query
print('Invoice sent:')
pprint(sent)
TOKEN = sys.argv[1]
PAYMENT_PROVIDER_TOKEN = sys.argv[2]
bot = telepot.aio.DelegatorBot(TOKEN, [
(per_message(flavors=['chat']), call(send_invoice)),
pave_event_space()(
per_invoice_payload(), create_open, OrderProcessor, timeout=30,
)
])
loop = asyncio.get_event_loop()
loop.create_task(MessageLoop(bot).run_forever())
loop.run_forever()
if not self.prolog.selectable_input_options("sauces"):
await self.__updateCounter()
elif user_input in self.prolog.all_options("topups"):
self.prolog.add_topup(user_input)
if not self.prolog.selectable_input_options("topups"):
await self.__updateCounter()
elif user_input in self.prolog.all_options("sides"):
self.prolog.add_side(user_input)
if not self.prolog.selectable_input_options("sides"):
await self.__updateCounter()
await self.__ask(id, bot, self.question_lists[self.counter])
else:
self.prolog.add_drink(user_input)
await self.__ask(id, bot, None)
bot = telepot.aio.DelegatorBot(TOKEN, [
pave_event_space()(per_chat_id(), create_open, TelegramBot, timeout=500),
])
loop = asyncio.get_event_loop()
loop.create_task(MessageLoop(bot).run_forever())
print('Listening ...')
loop.run_forever()
# 2. Define event-handling function
async def on__alarm(self, event):
print(event) # see what the event object actually looks like
await self.sender.sendMessage('Beep beep, time to wake up!')
async def on_chat_message(self, msg):
try:
delay = float(msg['text'])
# 3. Schedule event
# The second argument is the event spec: a 2-tuple of (flavor, dict).
# Put any custom data in the dict. Retrieve them in the event-handling function.
self.scheduler.event_later(delay, ('_alarm', {'payload': delay}))
await self.sender.sendMessage('Got it. Alarm is set at %.1f seconds from now.' % delay)
except ValueError:
await self.sender.sendMessage('Not a number. No alarm set.')
TOKEN = sys.argv[1]
bot = telepot.aio.DelegatorBot(TOKEN, [
pave_event_space()(
per_chat_id(), create_open, AlarmSetter, timeout=10),
])
loop = asyncio.get_event_loop()
loop.create_task(MessageLoop(bot).run_forever())
print('Listening ...')
loop.run_forever()
def _make_per_chat_handler(handler, **kwargs):
return pave_event_space()(per_chat_id(), create_open, handler, **kwargs)
if query_data != 'start':
self._score[self._answer == int(query_data)] += 1
self._answer = await self._show_next_question()
async def on__idle(self, event):
text = '%d out of %d' % (self._score[True], self._score[True]+self._score[False])
await self.editor.editMessageText(
text + '\n\nThis message will disappear in 5 seconds to test deleteMessage',
reply_markup=None)
await asyncio.sleep(5)
await self.editor.deleteMessage()
self.close()
TOKEN = sys.argv[1]
bot = telepot.aio.DelegatorBot(TOKEN, [
pave_event_space()(
per_chat_id(), create_open, QuizStarter, timeout=3),
pave_event_space()(
per_callback_query_origin(), create_open, Quizzer, timeout=10),
])
loop = asyncio.get_event_loop()
loop.create_task(MessageLoop(bot).run_forever())
print('Listening ...')
loop.run_forever()
parse_mode="Markdown")
self.waiting_reponse = False
#if detect any command from other bot answer with a custom message and return a photo
elif any(word in msg['text']
for word in self.antibot_keywords) and self.warmode:
await self.sender.sendMessage(self.cfg['messages']['antibot'])
await self.sender.sendPhoto(self.request_image())
#This should be improved TODO
with open(sys.argv[1] + "/config.yaml", 'r') as yamlfile:
cfg = yaml.safe_load(yamlfile)
TOKEN = cfg['bot']['token'] #read the telegram bot token from the config file
# create a handler for each telegram chat with a lifespan of "timeout"
# if timeout is reached without any new messages it will be destroyed
bot = telepot.aio.DelegatorBot(TOKEN, [
pave_event_space()(per_chat_id(),
create_open,
OfftopicBotHandler,
timeout=cfg['bot']['timeout']),
])
loop = asyncio.get_event_loop()
loop.create_task(MessageLoop(bot).run_forever())
print('Listening ...')
loop.run_forever()
async def on__idle(self, event):
self.close()
dotenv_path = join(dirname(__file__), '.env')
if (load_dotenv(dotenv_path)):
TOKEN = os.environ.get("TELEGRAM_BOT_TOKEN")
SPEECH_KIT_API_KEY = os.environ.get("SPEECH_KIT_API_KEY")
DEBUG = os.environ.get("DEBUG")
else:
TOKEN = sys.argv[1] # get token from command-line
if ((SPEECH_KIT_API_KEY != '') and (SPEECH_KIT_API_KEY)):
bot = telepot.aio.DelegatorBot(TOKEN, [
include_callback_query_chat_id(pave_event_space())(
per_chat_id(types=['private']),
create_open,
Speech2TextBot,
SPEECH_KIT_API_KEY,
timeout=40),
])
loop = asyncio.get_event_loop()
loop.create_task(bot.message_loop())
print('Listening ...')
loop.run_forever()
else:
print('Please regester your Yandex Speech Kit API Key at \
await self.sender.sendMessage('Time is up:\nYes: %d\nNo: %d\nSilent: %d' % result)
def on_close(self, ex):
global votes
if self._ballot_box is None:
try:
del votes[self.id]
except KeyError:
pass
else:
votes[self.id] = (self._ballot_box, self._keyboard_msg_ident, self._expired_event, self._member_count)
from pprint import pprint
print('%d closing ...' % self.id)
pprint(votes)
TOKEN = sys.argv[1]
bot = telepot.aio.DelegatorBot(TOKEN, [
include_callback_query_chat_id(
pave_event_space())(
per_chat_id(types=['group']), create_open, VoteCounter, timeout=10),
])
loop = asyncio.get_event_loop()
loop.create_task(bot.message_loop())
print('Listening ...')
loop.run_forever()
def compute_answer():
query_id, from_id, query_string = telepot.glance(msg, flavor='inline_query')
print(self.id, ':', 'Inline Query:', query_id, from_id, query_string)
articles = [{'type': 'article',
'id': 'abc', 'title': query_string, 'message_text': query_string}]
return articles
self.answerer.answer(msg, compute_answer)
def on_chosen_inline_result(self, msg):
from pprint import pprint
pprint(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.aio.DelegatorBot(TOKEN, [
pave_event_space()(
per_inline_from_id(), create_open, InlineHandler, timeout=10),
])
loop = asyncio.get_event_loop()
loop.create_task(MessageLoop(bot).run_forever())
print('Listening ...')
loop.run_forever()
for category in highscores_categories:
if char.get(category, None):
highscore_string = highscore_format[category].format(
pronoun2, char[category], char[category + '_rank'])
reply += "\n🏆 {0}".format(highscore_string)
return reply
def on_close(self, ex):
yield from self.sender.sendMessage('Fechou')
class ChatBox(telepot.aio.DelegatorBot):
def __init__(self, token):
super(ChatBox, self).__init__(token, [
pave_event_space()(per_chat_id(), create_open, Tibia, timeout=10),
])
#TOKEN = sys.argv[1] # get token from command-line
TOKEN = '344437874:AAEXStWb9DM3S6FhtWC-jlWULgv-1gyoWLU'
#TOKEN = '283648340:AAE6n-MG0ZEj_5rwBypeR1aN5yp7a7W7NwY'
#bot = ChatBox(TOKEN)
bot = telepot.aio.DelegatorBot(TOKEN, [
pave_event_space()(per_chat_id(), create_open, Tibia, timeout=10),
])
loop = asyncio.get_event_loop()
loop.create_task(bot.message_loop())
print('Listening ...')
loop.run_forever()
return web.Response(body='OK'.encode('utf-8'))
async def init(app, bot):
app.router.add_route('GET', '/webhook', feeder)
app.router.add_route('POST', '/webhook', feeder)
await bot.setWebhook(URL)
TOKEN = sys.argv[1]
PORT = int(sys.argv[2])
URL = sys.argv[3]
loop = asyncio.get_event_loop()
app = web.Application(loop=loop)
bot = telepot.aio.DelegatorBot(TOKEN, [
pave_event_space()(
per_chat_id(), create_open, MessageCounter, timeout=10)],
loop=loop)
webhook = OrderedWebhook(bot)
loop.run_until_complete(init(app, bot))
loop.create_task(webhook.run_forever())
try:
web.run_app(app, port=PORT)
except KeyboardInterrupt:
pass
def __init__(self, token):
super(ChatBox, self).__init__(token, [
pave_event_space()(per_chat_id(), create_open, Tibia, timeout=10),
])
if 'favourite' in query_data:
download_to = query_data.strip('favourite_')
with open(torrents_cfg['t_file_magnet'], 'rb') as hFile:
torrent = pickle.load(hFile)
try:
self.command.torrent_add(torrent['torrent'],
download_dir=favourites[download_to])
await self.bot.sendMessage(from_id,
"Link has been added to the queue",
reply_markup=None)
await self.show_torrents_list(from_id)
except Exception as e:
await self.bot.sendMessage(from_id, e, reply_markup=None)
async def on__idle(self, event):
await asyncio.sleep(1)
self.close()
teletor = telepot.aio.DelegatorBot(telegram_bot['token'], [
pave_event_space()(per_chat_id(), create_open, TorrentBot, timeout=10),
pave_event_space()(
per_callback_query_origin(), create_open, TorrentBot, timeout=10),
])
if __name__ == '__main__':
loop = asyncio.get_event_loop()
loop.create_task(teletor.message_loop())
loop.run_forever()
except ValueError:
await 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)
await self.sender.sendMessage(hint)
else:
await self.sender.sendMessage('Correct!')
self.close()
async def on__idle(self, event):
await self.sender.sendMessage('Game expired. The answer is %d' % self._answer)
self.close()
TOKEN = sys.argv[1]
bot = telepot.aio.DelegatorBot(TOKEN, [
pave_event_space()(
per_chat_id(), create_open, Player, timeout=10),
])
loop = asyncio.get_event_loop()
loop.create_task(MessageLoop(bot).run_forever())
print('Listening ...')
loop.run_forever()
