Python telegram.Updater类代码示例

def main():
    # Create the EventHandler and pass it your bot's token.
    updater = Updater(token)

    # Get the dispatcher to register handlers
    dp = updater.dispatcher

    # on different commands - answer in Telegram
    dp.addTelegramCommandHandler("help", home)
    dp.addTelegramCommandHandler("start", home)
    dp.addTelegramCommandHandler("home", home)

    dp.addTelegramCommandHandler("botinfo", botinfo)

    dp.addTelegramCommandHandler("mensa", mensa)
    dp.addTelegramCommandHandler("aulastudio", aulastudio)
    dp.addTelegramCommandHandler("biblioteca", biblioteca)

    for command in commands:
        dp.addTelegramCommandHandler(command, replier)

    dp.addTelegramMessageHandler(position)

    dp.addErrorHandler(error)
    updater.start_polling()
    updater.idle()

def main():
    global logger
    # load the logging configuration
    real_path = os.path.dirname(os.path.realpath(__file__))
    logging.config.fileConfig(real_path + '/logging.ini')
    logger = logging.getLogger(__name__)

    # Get the dispatcher to register handlers
    updater = Updater(token="TOKEN")
    dp = updater.dispatcher

    # on different commands - answer in Telegram
    dp.addTelegramCommandHandler("start", start)
    dp.addTelegramCommandHandler("roll", Dice.roll)

    # log all errors
    dp.addErrorHandler(error)

    logger.info('Starting new bot')
    roll()
    # Start the Bot
    updater.start_polling()

    # Block until the you presses Ctrl-C or the process receives SIGINT,
    # SIGTERM or SIGABRT. This should be used most of the time, since
    # start_polling() is non-blocking and will stop the bot gracefully.
    updater.idle()

def main():
    # Create the EventHandler and pass it your bot's token.
    updater = Updater(private_conf.tokenid)

    # Get the dispatcher to register handlers
    dp = updater.dispatcher

    # on different commands - answer in Telegram
    dp.addTelegramCommandHandler("start", start)
    dp.addTelegramCommandHandler("subscribe_op", subscribe_op)
    dp.addTelegramCommandHandler("help", help)
    dp.addTelegramCommandHandler("leeop",leeop)

    #run One Piece manga checker
    run_op(updater.bot)

    # on noncommand i.e message - echo the message on Telegram
    dp.addTelegramMessageHandler(echo)

    # log all errors
    dp.addErrorHandler(error)

    # Start the Bot
    updater.start_polling()

    # Run the bot until the you presses Ctrl-C or the process receives SIGINT,
    # SIGTERM or SIGABRT. This should be used most of the time, since
    # start_polling() is non-blocking and will stop the bot gracefully.
    updater.idle()

def main():
	random.seed(None)
	updater = Updater(token='<YOUR_TOKEN>')
	dispatcher = updater.dispatcher
	dispatcher.addTelegramMessageHandler(echo)
	dispatcher.addTelegramCommandHandler('boobs', echo)
	updater.start_polling()

def main():
    # Create the EventHandler and pass it your bot's token.
    updater = Updater(token)

    # Get the dispatcher to register handlers
    dp = updater.dispatcher

    # on different commands - answer in Telegram
    dp.addTelegramCommandHandler("help", help)
    dp.addTelegramCommandHandler("start", home)
    dp.addTelegramCommandHandler("home", home)
    dp.addTelegramCommandHandler("price", price)
    dp.addTelegramCommandHandler("register", register)
    dp.addTelegramCommandHandler("balances", balances)
    dp.addTelegramCommandHandler("transactions", transactions)
    dp.addTelegramCommandHandler("trades", trades)
    dp.addTelegramCommandHandler("tickers", tickers)
    dp.addTelegramCommandHandler("discounts", discounts)
    dp.addTelegramCommandHandler("delete_keys", deleteKeys)
    dp.addTelegramCommandHandler("bitcoin_data", bitcoinData)
    dp.addTelegramCommandHandler("orders", orders)
    for fund in FUNDS:
        dp.addTelegramCommandHandler(('tr_' + fund), fundTrades)
        dp.addTelegramCommandHandler(('tick_' + fund), ticker)
        dp.addTelegramCommandHandler(('ord_'+fund), fundOrders)
    for currency in CURRENCIES:
        dp.addTelegramCommandHandler(('disc_' + currency), currDiscount)
    dp.addTelegramMessageHandler(signup)

    dp.addErrorHandler(error)
    updater.start_polling()
    updater.idle()

class IngressoRapidoBot(object):

    # Mapa de comandos -> funções de tratamento
    commands = {
        'start': start_handler,
	'eventosnodia': events_on_handler,
        'eventosem': events_at_handler,
        'eventosdotipo': events_type_handler,
        'busca': search_handler,
	'eventosnoperiodo': events_between_handler,
        'mais': more_handler,
        'shows': shows_handler,
        'festas': parties_handler,
        'cinema': cinema_handler,
        'esportes': sports_handler,
        'teatro': theater_handler
    }

    def __init__(self, token):
        self.updater = Updater(token=token)
        dispatcher = self.updater.dispatcher

        for cmd, cmd_handler in self.commands.iteritems():
            dispatcher.addTelegramCommandHandler(cmd, cmd_handler)

    def run(self):
        self.updater.start_polling()
        self.updater.idle()

def main():
    """Main program"""
    # Create the EventHandler and pass it your bot's token.
    updater = Updater(token='KEY')

    # Get the dispatcher to register handlers
    dispatcher = updater.dispatcher

    # on different commands - answer in Telegram
    dispatcher.addTelegramCommandHandler('start', start)
    dispatcher.addTelegramCommandHandler('nuevavotacion', newpoll)
    dispatcher.addTelegramCommandHandler('respuesta', response)
    dispatcher.addTelegramCommandHandler('iniciovotacion', initpoll)
    dispatcher.addTelegramCommandHandler('finvotacion', endpoll)
    dispatcher.addUnknownTelegramCommandHandler(unknown)

    # on noncommand i.e message
    dispatcher.addTelegramMessageHandler(receiver)

    # Start the Bot
    updater.start_polling()

    # Run the bot until the you presses Ctrl-C or the process receives SIGINT,
    # SIGTERM or SIGABRT. This should be used most of the time, since
    # start_polling() is non-blocking and will stop the bot gracefully.
    updater.idle()

def main():
    # Create the EventHandler and pass it your bot's token.
    updater = Updater(settings.TG_API_KEY)

    # Get the dispatcher to register handlers
    dp = updater.dispatcher

    # on different commands - answer in Telegram
    dp.addTelegramCommandHandler("start", start)
    dp.addTelegramCommandHandler("help", help)
    dp.addTelegramCommandHandler("on", cmd_on)
    dp.addTelegramCommandHandler("off", cmd_off)
    dp.addTelegramCommandHandler("check", cmd_check)

    # on noncommand i.e message - echo the message on Telegram
    dp.addTelegramMessageHandler(echo)

    # log all errors
    dp.addErrorHandler(error)

    # Start the Bot
    updater.start_polling()

    # Run the bot until the you presses Ctrl-C or the process receives SIGINT,
    # SIGTERM or SIGABRT. This should be used most of the time, since
    # start_polling() is non-blocking and will stop the bot gracefully.
    updater.idle()

def main():
    # Create the EventHandler and pass it your bot's token.
    token = os.environ["TOKEN"]
    updater = Updater(token, workers=10)

    # Get the dispatcher to register handlers
    dp = updater.dispatcher

    dp.addTelegramCommandHandler("start", start)
    dp.addTelegramCommandHandler("blue", blue)

    dp.addStringCommandHandler("reply", cli_reply)
    dp.addUnknownStringCommandHandler(unknown_cli_command)
    dp.addStringRegexHandler("[^/].*", cli_noncommand)

    dp.addErrorHandler(error)

    # Start the Bot and store the update Queue, so we can insert updates
    update_queue = updater.start_polling(poll_interval=0.1, timeout=20)

    # Start CLI-Loop
    while True:
        try:
            text = raw_input()
        except NameError:
            text = input()

        # Gracefully stop the event handler
        if text == "stop":
            updater.stop()
            break

        # else, put the text into the update queue
        elif len(text) > 0:
            update_queue.put(text)  # Put command into queue

def main():
    updater = Updater(man.settings["authkey"])
    dp = updater.dispatcher

    dp.addTelegramCommandHandler("reactio", reactio)
    dp.addTelegramCommandHandler("kuva", kuva)
    #dp.addTelegramCommandHandler("kiusua", insult)
    #dp.addTelegramCommandHandler("new_insult", new_insult)
    dp.addTelegramMessageHandler(jutku)

    dp.addErrorHandler(error)
    update_queue = updater.start_polling(poll_interval=0.1, timeout=10)

    while True:
        try:
            text = input()
        except NameError:
            text = input()

        # Gracefully stop the event handler
        if text == 'stop':
            updater.stop()
            break

        # else, put the text into the update queue to be handled by our handlers
        elif len(text) > 0:
            update_queue.put(text)

def main():
    ### Updater será vinculado ao token informado,
    ### no caso, o token do grupo Brail Linux se não
    ### for mais release candidate
    if RELEASE_CANDIDATE:
        TOKEN2USE = TOKEN['rc']
    else:
        TOKEN2USE = TOKEN['released']
    updater = Updater(TOKEN2USE , workers=10)

    # Get the dispatcher to register handlers (funcoes...)
    dp = updater.dispatcher
    
    ### Adiciona comandos ao handler...
    ### Loop pela lista com todos comandos
    for lc in ALL_COMMANDS:
        add_handler(dp, lc, isADM=False)
        
    ### Adiciona comandos adm ao handler
    ### É preciso por o flag isADM como true...
    for lca in ALL_COMMANDS_ADMS:
        add_handler(dp, lca, isADM=True)
    
    ### aqui tratamos comandos não reconhecidos.
    ### Tipicamente comandos procedidos por "/" que é o caracter
    ### default para comandos telegram
    dp.addUnknownTelegramCommandHandler(showUnknowncommand)
    
    ### Loga todas mensagens para o terminal
    ### Pode ser util para funcoes anti-flood
    dp.addTelegramMessageHandler(message)

    ### Aqui logamos todos erros que possam vir a acontecer...
    dp.addErrorHandler(errosHandler)

    # Start the Bot and store the update Queue, so we can insert updates
    update_queue = updater.start_polling(poll_interval=0.1, timeout=10)
    
    ### Aqui lemos o dicionarios de usuarios do disco
    ##- global USERS
    ##- USERS = 
    logging.info('Quantia de users no DB: {udb}.'.format(udb=len(USERS)))
    for u in USERS:
        logging.info('User {un}, id: {uid}'.format(un=USERS[u]['username'],uid=u))

    # Start CLI-Loop and heartbeat
    while True:
        try:
            text = raw_input()
        except NameError:
            text = input()

        # Gracefully stop the event handler
        if text == 'stop':
            updater.stop()
            break

        # else, put the text into the update queue to be handled by our handlers
        elif len(text) > 0:
            update_queue.put(text)

def main():
    """Defining the main function"""

    global JOB_QUEUE

    news.create_news_json()
    utils.load_subscribers_json()

    config = utils.get_configuration()
    token = config.get('API-KEYS', 'TelegramBot')
    debug = config.getboolean('UTILS', 'Debug')
    logger = utils.get_logger(debug)

    updater = Updater(token)
    JOB_QUEUE = updater.job_queue
    notify_news(updater.bot)
    dispatcher = updater.dispatcher

    dispatcher.addTelegramCommandHandler("start", start_command)
    dispatcher.addTelegramCommandHandler("help", help_command)
    dispatcher.addTelegramCommandHandler("news", news.news_command)
    dispatcher.addTelegramCommandHandler("newson", newson_command)
    dispatcher.addTelegramCommandHandler("newsoff", newsoff_command)
    dispatcher.addTelegramCommandHandler("prof", other_commands.prof_command)
    dispatcher.addTelegramCommandHandler("segreteria", other_commands.student_office_command)
    dispatcher.addTelegramCommandHandler("mensa", other_commands.canteen_command)
    dispatcher.addTelegramCommandHandler("adsu", other_commands.adsu_command)

    # For Testing only
    dispatcher.addTelegramCommandHandler("commands_keyboard", commands_keyboard)

    logger.info('Bot started')

    updater.start_polling()
    updater.idle()

def main():
    # Create the EventHandler and pass it your bot's token.
    updater = Updater("166865409:AAGSAEVXHyP1NlQaDOj65z4F9OgX5sarpGg")

    # Get the dispatcher to register handlers
    dp = updater.dispatcher

    # on different commands - answer in Telegram
    dp.addTelegramCommandHandler("boz", startHandler)
    dp.addTelegramCommandHandler("muto", stopHandler)
    dp.addTelegramCommandHandler("help", helpHandler)

    # on noncommand i.e message - send a proper message on Telegram
    dp.addTelegramMessageHandler(messageHandler)

    # log all errors
    dp.addErrorHandler(errorHandler)

    # Start the Bot
    updater.start_polling()

    # Run the bot until the you presses Ctrl-C or the process receives SIGINT,
    # SIGTERM or SIGABRT. This should be used most of the time, since
    # start_polling() is non-blocking and will stop the bot gracefully.
    updater.idle()

def main():
    # Create the EventHandler and pass it your bot's token.
    updater = Updater("135342801:AAFaninNSzDkYU8UzonHeOhcu5fVaPlCC7Y")

    # Get the dispatcher to register handlers
    dp = updater.dispatcher

    # on different commands - answer in Telegram
    dp.addTelegramCommandHandler("start", start)
    dp.addTelegramCommandHandler("help", help)

    # on noncommand i.e message - echo the message on Telegram
    dp.addTelegramMessageHandler(echo)

    # log all errors
    dp.addErrorHandler(error)

    # Start the Bot
    updater.start_polling()

    runloop()
    # Run the bot until the you presses Ctrl-C or the process receives SIGINT,
    # SIGTERM or SIGABRT. This should be used most of the time, since
    # start_polling() is non-blocking and will stop the bot gracefully.
    updater.idle()

def main():
    config = configparser.ConfigParser()
    config.read('info.ini')

    token = config.get("Connection","Token")
    updater = Updater(token, workers=10)

    dp = updater.dispatcher

    dp.addUnknownTelegramCommandHandler(unknown_command)
    dp.addTelegramMessageHandler(message)
    dp.addTelegramRegexHandler('.*', any_message)

    dp.addStringCommandHandler('reply', cli_reply)
    dp.addUnknownStringCommandHandler(unknown_cli_command)
    dp.addStringRegexHandler('[^/].*', cli_noncommand)

    dp.addErrorHandler(error)

    update_queue = updater.start_polling(poll_interval=0.1, timeout=10)

    # Start CLI-Loop
    while True:
        try:
            text = raw_input()
        except NameError:
            text = input()

        if text == 'stop':
            fileids.close()
            updater.stop()
            break

        elif len(text) > 0:
            update_queue.put(text)