def __init__(self, token, owner_id): # create folder for audio storage create_directory(self.FILES_DIRECTORY) self._mongo = MongoClientWrapper(MONGO) super(GatherValidateBot, self).__init__( token, [ # Handler for the chat actions pave_event_space()(per_chat_id_except([owner_id]), create_open, GatherValidateChatHandler, self._mongo, timeout=1000000), pave_event_space()(per_chat_id_in([owner_id]), create_open, OwnerHandler, self._mongo, timeout=1000000), # download voice file (self._is_voice, custom_thread(call(self._download_and_store)) ), # announce to all users (self._is_announce, custom_thread(call(self._announce))) ])
def main(loggingfile, TOKEN): logging.basicConfig(filename=loggingfile + '.log', format='%(asctime)-15s %(message)s') bot = telepot.DelegatorBot(TOKEN, [ pave_event_space()( per_inline_from_id(), create_open, InlineHandler, timeout=1), include_callback_query_chat_id(pave_event_space())( per_chat_id(), create_open, MessageHandler, timeout=1) ]) bot.message_loop(run_forever='Listening ...')
def __init__(self,token): self.adminconfig() self.timeconfig() x.loadConfig() config1.read('telebot.ini') idadmin = config1.get('admin','chatid') x.camStart() super(ChatBox, self).__init__(token, [ include_callback_query_chat_id(pave_event_space())(per_chat_id_in([int(idadmin)],types='private'), create_open, SmartRoomChat, timeout=90), pave_event_space()(per_chat_id_except([int(idadmin)],types='private'), create_open, NonAdmin, timeout=10), ])
def run_bot(): parser = ArgumentParser(description='MTG Card Image Fetch Telegram Bot') parser.add_argument('token', type=str, metavar='t', help='The Telegram Bot API Token') parser.add_argument('--level', metavar='l', default='info', choices=[l.lower() for l in logging._nameToLevel]) args = parser.parse_args() logging.basicConfig(level=args.level.upper(), format='%(asctime)s | %(levelname)s: %(message)s', datefmt='%m.%d.%Y %H:%M:%S', handlers=[ logging.StreamHandler(), logging.FileHandler( 'mtgbot_{:%Y_%m_%d_%X}.log'.format( datetime.now())) ]) bot = telepot.DelegatorBot(args.token, [ pave_event_space()( per_inline_from_id(), create_open, InlineHandler, timeout=20), ]) bot.message_loop(run_forever='Listening ...')
def start_bot(config): rasa_section = config['rasa'] telegram_section = config['telegram'] logger.info('Loading model') model = get_model(rasa_section) metadata = Metadata.load(model) logger.info('Loading interpreter') rasa_config = rasa_section['config'] interpreter = Interpreter.load(metadata, RasaNLUConfig(rasa_config)) logger.info('Preparing Bot') token = telegram_section['token'] bot = telepot.DelegatorBot(token, [ pave_event_space()(per_chat_id(), create_open, KiririnHandler, interpreter, config, timeout=20) ]) MessageLoop(bot).run_as_thread() logger.info('Listening') while 1: time.sleep(10)
def main(): parser = ArgumentParser() parser.add_argument('--token', type=str, required=True) parser.add_argument('--smartid-config', type=str, default='bundle_mock_smart_idreader.zip') args = parser.parse_args() # Creating recognition engine smartid_engine = se.RecognitionEngine(args.smartid_config) # Creating bot bot = telepot.DelegatorBot(args.token, [ pave_event_space()(per_chat_id(), create_open, SmartIDReaderBot, smartid_engine, timeout=1000000) ]) # Starting bot MessageLoop(bot).run_as_thread() print('Bot started, listening to messages...') while 1: time.sleep(10)
def main(): TOKEN = os.getenv(TOKEN) assert TOKEN, "You should export 'TOKEN' env variable" bot = telepot.DelegatorBot(TOKEN, [ pave_event_space()(per_chat_id(), create_open, Player, timeout=10), ]) bot.message_loop(run_forever='Listening ...')
def run(): setting_lst = [] setting_lst.append(pave_event_space()(per_chat_id(), create_open, gnomo, timeout=1000)) bot = telepot.DelegatorBot(TOKEN, setting_lst) bot.message_loop(run_forever="listening ...")
def __init__(self, token): super().__init__(token, [ include_callback_query_chat_id(pave_event_space())( per_chat_id(), create_open, TheManager, timeout=10), ]) self.spotify_controller = SpotifyController(self) self.game_controller = LyricGameController(self)
def main(): setup_bot(PLATFORM) bot = DelegatorBot(BOT_TOKEN, [ pave_event_space()( per_application(), create_open, NewsApiTelegramBot, timeout=np.inf) ]) MessageLoop(bot).run_as_thread() while 1: time.sleep(3600)
def main(): bot = DelegatorBot(token, [ pave_event_space()(per_chat_id(types=['group']), create_open, TelegramManager, timeout=300) ]) MessageLoop(bot).run_as_thread() while 1: time.sleep(10)
def main(): bot = telepot.DelegatorBot("API_BOT", [ pave_event_space()( per_chat_id(), create_open, SSHGenerator, timeout=10), ]) MessageLoop(bot).run_as_thread() # Keep the program running. while 1: time.sleep(1) pass
def main_loop(app, queue=None): """Main loop of the bot. :param flask.app.Flask app: Flask app. :param queue: Update queue to be used as the source of updates instead of the Telegram API server. Used in tests. """ bot = DelegatorBot( TELEGRAM_TOKEN, [pave_event_space()(per_chat_id(), create_open, ChoreBot, timeout=TELEGRAM_IDLE_TIMEOUT, flask_app=app)], ) forever = False if queue else "Listening ({})...".format(app.config["ENV"]) bot.message_loop(source=queue, run_forever=forever)
def main(): bot = telepot.DelegatorBot( "1301161841:AAFoG-7rf1IeQbG-gpEagw47pbvMxpcz3qI", [ pave_event_space()( per_chat_id(), create_open, SSHGenerator, timeout=10), ]) MessageLoop(bot).run_as_thread() # Keep the program running. while 1: time.sleep(1) pass
def run2(): setting_lst = [] setting_lst.append(pave_event_space()(per_chat_id(), create_open, gnomo, timeout=100000)) bot = telepot.DelegatorBot(TOKEN, setting_lst) # app.run( port=PORT, debug=True) bot.setWebhook() bot.setWebhook(URL + SECRET) bot.message_loop(source=update_queue)
def main(): os.environ.setdefault("DJANGO_SETTINGS_MODULE", "djing.settings") django.setup() from chatbot.telebot import token, DjingTelebot while True: try: bot = DelegatorBot(token, [ pave_event_space()( per_chat_id(), create_open, DjingTelebot, timeout=300 ), ]) bot.message_loop(run_forever='Listening ...') except BadHTTPResponse as e: print(e)
def main(): global config, bot with open("./config.yml") as f: data = f.read() config = yaml.full_load(data) if config['proxy'] is not None: telepot.api.set_proxy(config['proxy']) bot = telepot.DelegatorBot(config['token'], [ pave_event_space()( per_chat_id(), create_open, WinneAVSearcher, timeout=120) ]) MessageLoop(bot).run_as_thread() print('Listening ...') while 1: time.sleep(20)
def __init__(self, token, members, polls, students): self._polls = polls self._members = members self._students = students super(Congress, self).__init__(token, [ include_callback_query_chat_id(pave_event_space())( per_chat_id(types=['private']), create_open, Member, self._polls, self._members, self._students, timeout=20), ])
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, custom_thread(call(self._send_welcome))), ])
def main(): global bot, authorized_users, verbose, scheduler, owm, owm_api_key, city_list config_filename = 'weatherbot-config.json' try: with open(config_filename, 'r') as config_file: config = json.load(config_file) except FileNotFoundError: print('Error: config file "{}" not found: {}'.format(config_filename)) return except ValueError as e: print('Error: invalid config file "{}": {}'.format(config_filename, e)) return telegram_bot_token = config.get('telegram_bot_token') if not telegram_bot_token: print('Error: config file doesn’t contain a `telegram_bot_token`') return authorized_users = config.get('authorized_users') if type(authorized_users) is not list or len(authorized_users) == 0: print('Error: config file doesn’t contain an `authorized_users` list') return verbose = config.get('verbose', True) owm_api_key = config.get('openweathermap', {}).get('api_key') owm = OpenWeatherMap(owm_api_key) if owm_api_key else None city_list_filename = config.get('openweathermap', {}).get('city_list') city_list = CityList() if city_list_filename: city_list.read( city_list_filename, lambda p: print( '\rLoading city list ... {:d}%'.format(p), end='', flush=True)) print() bot = telepot.DelegatorBot(telegram_bot_token, [ include_callback_query_chat_id(pave_event_space())(per_chat_id_in( authorized_users, types='private'), create_open, ChatUser, timeout=3600) ]) scheduler.start() try: bot.message_loop(run_forever='Bot listening ...') except KeyboardInterrupt: pass if verbose: print('Exiting ...') scheduler.shutdown()
def on_chat_message(self, msg): bot = telepot.DelegatorBot( '333028480:AAG2EAmXyBfGqV4XYyD7iD7EEZnd6zvil78', [ pave_event_space()( per_chat_id(), create_open, MessageCounter, timeout=10), ]) bot.message_loop() # take updates from queue print(msg) chat_id = msg['chat']['id'] if 'text' in msg: if re.search(r'hello', msg['text'], re.MULTILINE): bot.sendMessage(chat_id, 'hello word', reply_to_message_id=msg['message_id'])
def __init__(self, config, on_idle_timeout=None): self.config = config if on_idle_timeout is not None: self.on_idle_timeout = on_idle_timeout else: self.on_idle_timeout = config.ON_IDLE_TIMEOUT super(TwitterBotDelegatorBot, self).__init__( config.TELEGRAM_BOT_TOKEN, [ # Here is a delegate to specially handle owner commands. delegate.pave_event_space()( delegate.per_chat_id_in(config.AUTHORIZED_USERS, types='private'), delegate.create_open, TwitterBotChatHandler, # Add handler arguments here config=config, timeout=self.on_idle_timeout) ])
def __init__(self, token): self._seen = set() self._store = MongoStore() super(ChatBox, self).__init__( token, [ # Here is a delegate to specially handle owner commands. pave_event_space()(per_chat_id_in(self._store.getUsers()), create_open, CommandsBrain, self._store, timeout=100), # Only one MessageSaver is ever spawned for entire application. (per_application(), create_open(MessageSaver, self._store, exclude=[])), # For senders never seen before, send him a welcome message. (self._is_newcomer, print('Welcome mate!')), ])
def run_bot(token, config): files_tree_generators= {} for shared_directories in config.values(): for sd in shared_directories: if sd.path not in files_tree_generators: files_tree_generators[sd.path] = nav.FilesTreeGenerator(sd.path) global global_config global_config = config global global_files_tree_generators global_files_tree_generators = files_tree_generators bot = telepot.DelegatorBot(token, [ include_callback_query_chat_id( pave_event_space())( per_chat_id(types=['private']), create_open, NavigatorBot, timeout=300), ]) MessageLoop(bot).run_as_thread() logging.info("Listening started") print('Listening ...') while 1: time.sleep(10)
def main(): global BOT_USERNAME bot = telepot.DelegatorBot(BOT_TOKEN, [ pave_event_space()( per_chat_id(), create_open, HyvinvointiChat, timeout=BOT_TIMEOUT) ]) BOT_USERNAME = bot.getMe()["username"].lower() flush_messages(bot) MessageLoop(bot).run_as_thread() print('Listening @{} ...'.format(bot.getMe()["username"])) while 1: _, points_last_updated = dbm.get_team_points() t = datetime.datetime.fromtimestamp(time.time()) t_prev = datetime.datetime.fromtimestamp(points_last_updated) #if not is_today(points_last_updated): if t.hour != t_prev.hour and (t.hour % UPDATE_POINTS_INTERVAL_H) == 0: dbm.update_team_points() time.sleep(10)
def main(): if not BOT_TOKEN: print(BOT_TOKEN_NOT_FOUND_MESSAGE) sys.exit(1) try: bootstrap_database() bot = telepot.DelegatorBot(BOT_TOKEN, [ include_callback_query_chat_id(pave_event_space())( per_chat_id(types=['private']), create_open, MessageHandler, timeout=10), ]) urls = UrlsHistory.select().order_by('-created_at') bot.message_loop(run_forever='At your service. ' 'There are {} urls ' 'on the history.'.format(urls.count())) except KeyboardInterrupt: print('Finishing by your request. Bye!\n') sys.exit(0)
if content_type == 'new_chat_member': new_user_hello(msg) if content_type != 'text': print('Not a text message.') return if msg['text'] == '/boobs': print('boobs') sender_photo(chat_id, instagramm.Inst('boobs')) return if re.findall('/#.*', msg['text']): diez = msg['text'][3:] print(diez) sender_photo(chat_id, instagramm.Inst(diez)) # else: # sender_photo(chat_id, 'https://files5.adme.ru/files/comment/part_2036/20357060-1414483493.png') except Exception as e: sender_photo( chat_id, 'https://files5.adme.ru/files/comment/part_2036/20357060-1414483493.png' ) #TOKEN = '307520552:AAHVG_Yi7nshJHUDYOIn-4G6UXEfTY7egGU' TOKEN = '294022389:AAHVf5mAejze3naL9Q-BAXKEFHlR7Tdk7E4' bot = telepot.DelegatorBot(TOKEN, [ include_callback_query_chat_id(pave_event_space())( per_chat_id(types=['group']), create_open, VoteCounter, timeout=10), ]) bot.message_loop(run_forever='Listening ...')
self._show_next_state('Я хожу:') if not (self._stop or self._winner): self._bot_answer() self._show_next_state('Ты ходишь:') else: self._counter += 1 self._show_next_state('Ты слепой? ({}):'.format(self._counter)) def on__idle(self, event): self.editor.editMessageText('Слишком долго думаешь :(\nЯ пошёл 👋', reply_markup=None) time.sleep(5) self.editor.deleteMessage() self.close() if __name__ == "__main__": TOKEN = '705103229:AAF20n1fAtMQn-1Askb9BKwdKEGyylBG51U' bot = telepot.DelegatorBot(TOKEN, [ pave_event_space()(per_chat_id(), create_open, GameStarter, timeout=3), pave_event_space()( per_callback_query_origin(), create_open, Gamer, timeout=10), ]) MessageLoop(bot).run_as_thread() print('Listening ...') while 1: time.sleep(10)
pprint(msg) my_chat_id = msg['chat']['id'] command = msg['text'] self._count += 1 self.sender.sendMessage("count: %d chat id: %s command: %s" % (self._count, my_chat_id, command)) # # register the bot and start it # import config # Il token è contenuto nel file config.py e non è aggiornato su GitHub per evitare utilizzi impropri TOKEN = config.TOKEN bot = telepot.DelegatorBot(os.environ['SSH_BOT_KEY'], [ pave_event_space()(per_chat_id(), create_open, PushButtonBot, timeout=1000), ]) bot.message_loop(run_forever=False, timeout=2) print "Message loop started" button = BotButton('PC17', bot) while True: time.sleep(100000)
self.sender.sendMessage(text="لطفا بعد از فرستادن پیام های خود گزینه ارسال را فشار دهید", reply_markup=contact_us_keyboard) self.question += msg["text"] + "\n" print(self.question) elif self.situation // 10 == 16: self.presentation_rate = int(msg["text"]) elif self.situation // 100 == 16: self.context_rate = int(msg["text"]) else: pass # invalid msg # TODO handle: not sending responses to messages sent when bot was down ... # bot = telepot.Bot(TOKEN) # print(bot.getMe()) bot = telepot.DelegatorBot('797548891:AAHTRcDFwAVb1V7ru2XhszTLZKq9TF8GzJs', [ pave_event_space()( per_chat_id(), create_open, StateHandler, timeout=2 * 24 * 60 * 60), # timeout = 2 days? ]) start_time_ms = datetime.datetime MessageLoop(bot).run_forever() # OR THIS METHOD: # MessageLoop(bot).run_as_thread() # while 1: # time.sleep(5) # print('Listening ...')
if now == last_reminder: return while last_reminder != now: send_reminder(bot, '{:02}:{:02}'.format(*last_reminder)) last_reminder[1] += 1 if last_reminder[1] >= 60: last_reminder[0] += 1 last_reminder[1] -= 60 if last_reminder[0] >= 24: last_reminder[0] -= 24 try: with open(config.TELEGRAM_STATE, 'w') as f: f.write('{:02}:{:02}'.format(*last_reminder)) except IOError as e: logging.warn('Could not write state file: %s', e) if __name__ == '__main__': logging.basicConfig(level=logging.WARNING, format='%(asctime)s %(message)s', datefmt='%H:%M:%S') database.connect() bot = telepot.DelegatorBot(config.TELEGRAM_TOKEN, [ pave_event_space()( per_chat_id(types=['private']), create_open, Player, timeout=10), ]) MessageLoop(bot).run_as_thread() while 1: send_reminders(bot) time.sleep(10)
## Journal. try: print("\033[33m>>>\033[0m %s\n\033[33mBot\033[0m: Closed an delegator with @\033[34m%s\033[0m by calling on_close()."%(self._now, self._username)) except: print("\033[33m>>>\033[0m %s\n\033[33mBot\033[0m: Closed an delegator by calling on_close()."%(self._now)) print("--------------------------------------------") ### Now it starts run. print("Getting bot information...") ### Generate a bot object. bot = telepot.DelegatorBot( TOKEN, [ pave_event_space()( per_from_id(), create_open, TeleBot, timeout=30 ) ] ) ### Now it prints your bot information. try: info = bot.getMe() except KeyboardInterrupt: exit() except: conf_rewrite = False print("\033[46m\033[31mERROR\033[0m: Your token is invaild.") print("Please check what your config file \"%s\" contains."%(config_file)) print("It should contain your token string in the token line.")
result = self._count_votes() self._close_ballot() 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) from pprint import pprint pprint(votes) TOKEN = sys.argv[1] bot = telepot.DelegatorBot(TOKEN, [ include_callback_query_chat_id( pave_event_space())( per_chat_id(types=['group']), create_open, VoteCounter, timeout=10), ]) MessageLoop(bot).run_as_thread() print('Listening ...') while 1: time.sleep(10)
self._count += 1 text = '%d. %s' % (self._count, query_string) articles = [InlineQueryResultArticle( id='abc', title=text, input_message_content=InputTextMessageContent( message_text=text ) )] return articles self.answerer.answer(msg, compute) 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] # get token from command-line bot = telepot.DelegatorBot(TOKEN, [ pave_event_space()( per_inline_from_id(), create_open, QueryCounter, timeout=10), ]) MessageLoop(bot).run_as_thread() while 1: time.sleep(10)
# 2. Define event-handling function def on__alarm(self, event): print(event) # see what the event object actually looks like self.sender.sendMessage('Beep beep, time to wake up!') 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})) self.sender.sendMessage('Got it. Alarm is set at %.1f seconds from now.' % delay) except ValueError: self.sender.sendMessage('Not a number. No alarm set.') TOKEN = sys.argv[1] bot = telepot.DelegatorBot(TOKEN, [ pave_event_space()( per_chat_id(), create_open, AlarmSetter, timeout=10), ]) MessageLoop(bot).run_as_thread() print('Listening ...') while 1: time.sleep(10)
BOT_HOOK_URL = os.environ.get('BOT_HOOK_URL', '/bot/hook') BOT_HOST = os.environ.get('BOT_HOST', '') # bot related class Planner(telepot.helper.ChatHandler): def __init__(self, *args, **kwargs): super(Planner, self).__init__(*args, **kwargs) def on_chat_message(self, msg): self.sender.sendMessage('gigla') bot = telepot.DelegatorBot(BOT_API_TOKEN, [ pot_delegate.pave_event_space()( pot_delegate.per_chat_id(), pot_delegate.create_open, Planner, timeout=15 ) ]) webhook = pot_loop.OrderedWebhook(bot) # server related app = flask.Flask(__name__) @app.route('/') def index(): return 'planner bot' @app.route(BOT_HOOK_URL, methods=['GET', 'POST']) def on_event():
self.sender.sendMessage('Give me a number, please.') return try: guess = int(msg['text']) except ValueError: 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) self.sender.sendMessage(hint) else: self.sender.sendMessage('Correct!') self.close() def on__idle(self, event): self.sender.sendMessage('Game expired. The answer is %d' % self._answer) self.close() TOKEN = sys.argv[1] bot = telepot.DelegatorBot(TOKEN, [ pave_event_space()( per_chat_id(), create_open, Player, timeout=10), ]) bot.message_loop(run_forever='Listening ...')
def __init__(self, *args, **kwargs): super(MessageCounter, self).__init__(*args, **kwargs) self._count = 0 def on_chat_message(self, msg): self._count += 1 self.sender.sendMessage(self._count) TOKEN = sys.argv[1] PORT = int(sys.argv[2]) URL = sys.argv[3] app = Flask(__name__) update_queue = Queue() # channel between `app` and `bot` bot = telepot.DelegatorBot(TOKEN, [ pave_event_space()( per_chat_id(), create_open, MessageCounter, timeout=10), ]) bot.message_loop(source=update_queue) # take updates from queue @app.route('/abc', methods=['GET', 'POST']) def pass_update(): update_queue.put(request.data) # pass update to bot return 'OK' if __name__ == '__main__': bot.setWebhook(URL) app.run(port=PORT, debug=True)
inline_keyboard=[list(map(lambda c: InlineKeyboardButton(text=str(c), callback_data=str(c)), choices))] ), ) return answer def on_callback_query(self, msg): query_id, from_id, query_data = telepot.glance(msg, flavor="callback_query") if query_data != "start": self._score[self._answer == int(query_data)] += 1 self._answer = self._show_next_question() def on__idle(self, event): text = "%d out of %d" % (self._score[True], self._score[True] + self._score[False]) self.editor.editMessageText(text, reply_markup=None) self.close() TOKEN = sys.argv[1] bot = telepot.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), ], ) bot.message_loop(run_forever="Listening ...")
class InlineHandler(telepot.helper.InlineUserHandler, telepot.helper.AnswererMixin): def __init__(self, *args, **kwargs): super(InlineHandler, self).__init__(*args, **kwargs) def on_inline_query(self, msg): 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.DelegatorBot(TOKEN, [ pave_event_space()( per_inline_from_id(), create_open, InlineHandler, timeout=10), ]) bot.message_loop(run_forever='Listening ...')
import sys import telepot from telepot.delegate import pave_event_space, per_chat_id, create_open class MessageCounter(telepot.helper.ChatHandler): def __init__(self, *args, **kwargs): super(MessageCounter, self).__init__(*args, **kwargs) self._count = 0 def on_chat_message(self, msg): self._count += 1 self.sender.sendMessage(self._count) TOKEN = sys.argv[1] # get token from command-line bot = telepot.DelegatorBot(TOKEN, [pave_event_space()(per_chat_id(), create_open, MessageCounter, timeout=10)]) bot.message_loop(run_forever="Listening ...")
if content_type == 'text': sent = 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.DelegatorBot(TOKEN, [ (per_message(flavors=['chat']), call(send_invoice)), pave_event_space()( per_invoice_payload(), create_open, OrderProcessor, timeout=30, ) ]) MessageLoop(bot).run_as_thread() while 1: time.sleep(10)
if 'cb_message' in self.context and self.context['cb_message'] != self.context.get('last_message'): stage.base_message( 'Finish', update_msg=self.context['cb_message'], with_keyboard= 'last_message' not in self.context ) if 'last_message' in self.context: self.user_config.data['last_message'] = self.context['last_message'] self.user_config.context = dict() self.user_config.save() if __name__ == '__main__': conn = get_connect() params = list(model.GlobalConfig.objects.timeout(True)) bot = telepot.DelegatorBot(config.BOT_TOKEN, [ pave_event_space()( [per_chat_id(('private',)), per_callback_query_chat_id(('private',))], create_open, EatSession, include_callback_query=True, timeout=300), ]) MessageLoop(bot).run_as_thread() print('Listening ...') while 1: time.sleep(10)
to_buy_list.append(msg['text']) self.sender.sendMessage(text=u'仲有冇?如果冇,就用 /done 完結。', reply_markup={'hide_keyboard': True}) else: self.sender.sendMessage(text=u'我唔明呀。\n' + u'你試多次啦。或者用 /help 我就教你用。') else: self.sender.sendMessage(text=u'你邊位呀?') else: raise telepot.exception.BadFlavor(msg) print(u'to buy list: ' + self.genBuyList()) TOKEN = sys.argv[1] # get token from command-line with open(file=file_name, mode='r') as f: lines = f.read().splitlines() f.close() to_buy_list = lines # bot = telepot.DelegatorBot(TOKEN, [ # (per_chat_id(), create_open(AngryJinny, timeout=120)),]) bot = telepot.DelegatorBot(TOKEN, [ pave_event_space()( per_chat_id(), create_open, AngryJinny, timeout=120), ]) # print('Listening ...') # bot.notifyOnMessage(run_forever=True) bot.message_loop(run_forever='Listening ...')