def create_dp(bot):
# Dispatcher is heavy to init (due to many threads and such) so we have a single session
# scoped one here, but before each test, reset it (dp fixture below)
dispatcher = Dispatcher(bot, Queue(), job_queue=JobQueue(bot), workers=2)
thr = Thread(target=dispatcher.start)
thr.start()
sleep(2)
yield dispatcher
sleep(1)
if dispatcher.running:
dispatcher.stop()
thr.join()
def __init__(self, token=None, base_url=None, workers=4, bot=None):
if (token is None) and (bot is None):
raise ValueError('`token` or `bot` must be passed')
if (token is not None) and (bot is not None):
raise ValueError('`token` and `bot` are mutually exclusive')
if bot is not None:
self.bot = bot
else:
# we need a connection pool the size of:
# * for each of the workers
# * 1 for Dispatcher
# * 1 for polling Updater (even if webhook is used, we can spare a connection)
# * 1 for JobQueue
# * 1 for main thread
self._request = Request(con_pool_size=workers + 4)
self.bot = Bot(token, base_url, request=self._request)
self.update_queue = Queue()
self.job_queue = JobQueue(self.bot)
self.__exception_event = Event()
self.dispatcher = Dispatcher(
self.bot,
self.update_queue,
job_queue=self.job_queue,
workers=workers,
exception_event=self.__exception_event)
self.last_update_id = 0
self.logger = logging.getLogger(__name__)
self.running = False
self.is_idle = False
self.httpd = None
self.__lock = Lock()
self.__threads = []
""":type: list[Thread]"""
def __init__(self,
token=None,
base_url=None,
workers=4,
bot=None,
job_queue_tick_interval=1.0):
if (token is None) and (bot is None):
raise ValueError('`token` or `bot` must be passed')
if (token is not None) and (bot is not None):
raise ValueError('`token` and `bot` are mutually exclusive')
if bot is not None:
self.bot = bot
else:
self.bot = Bot(token, base_url)
self.update_queue = Queue()
self.job_queue = JobQueue(self.bot, job_queue_tick_interval)
self.__exception_event = Event()
self.dispatcher = Dispatcher(self.bot, self.update_queue, workers, self.__exception_event)
self.last_update_id = 0
self.logger = logging.getLogger(__name__)
self.running = False
self.is_idle = False
self.httpd = None
self.__lock = Lock()
self.__threads = []
""":type: list[Thread]"""
def dp(_dp):
# Reset the dispatcher first
while not _dp.update_queue.empty():
_dp.update_queue.get(False)
_dp.chat_data = defaultdict(dict)
_dp.user_data = defaultdict(dict)
_dp.handlers = {}
_dp.groups = []
_dp.error_handlers = []
_dp.__stop_event = Event()
_dp.__exception_event = Event()
_dp.__async_queue = Queue()
_dp.__async_threads = set()
if _dp._Dispatcher__singleton_semaphore.acquire(blocking=0):
Dispatcher._set_singleton(_dp)
yield _dp
Dispatcher._Dispatcher__singleton_semaphore.release()
def __init__(self,
token=None,
base_url=None,
workers=4,
bot=None,
user_sig_handler=None,
request_kwargs=None):
if (token is None) and (bot is None):
raise ValueError('`token` or `bot` must be passed')
if (token is not None) and (bot is not None):
raise ValueError('`token` and `bot` are mutually exclusive')
self.logger = logging.getLogger(__name__)
con_pool_size = workers + 4
if bot is not None:
self.bot = bot
if bot.request.con_pool_size < con_pool_size:
self.logger.warning(
'Connection pool of Request object is smaller than optimal value (%s)',
con_pool_size)
else:
# we need a connection pool the size of:
# * for each of the workers
# * 1 for Dispatcher
# * 1 for polling Updater (even if webhook is used, we can spare a connection)
# * 1 for JobQueue
# * 1 for main thread
if request_kwargs is None:
request_kwargs = {}
if 'con_pool_size' not in request_kwargs:
request_kwargs['con_pool_size'] = con_pool_size
self._request = Request(**request_kwargs)
self.bot = Bot(token, base_url, request=self._request)
self.user_sig_handler = user_sig_handler
self.update_queue = Queue()
self.job_queue = JobQueue(self.bot)
self.__exception_event = Event()
self.dispatcher = Dispatcher(
self.bot,
self.update_queue,
job_queue=self.job_queue,
workers=workers,
exception_event=self.__exception_event)
self.last_update_id = 0
self.running = False
self.is_idle = False
self.httpd = None
self.__lock = Lock()
self.__threads = []
def run(message):
bot = Bot(config.bot_token)
dp = Dispatcher(bot, None, workers=0)
# on different commands - answer in Telegram
dp.add_handler(CommandHandler("ranking", ranking, pass_args=True))
dp.add_handler(CommandHandler("players", players, pass_args=True))
dp.add_handler(CommandHandler("player", player, pass_args=True))
dp.add_handler(CommandHandler("matchday", matchday, pass_args=True))
dp.add_handler(CommandHandler("scorers", scorers))
dp.add_handler(CommandHandler("help", help))
dp.add_handler(
CommandHandler('info', info,
filters=Filters.user(username='******')))
# on noncommand i.e message - echo the message on Telegram
dp.add_handler(MessageHandler(Filters.text, echo))
# log all errors
dp.add_error_handler(error)
# inline
inline_handler = InlineQueryHandler(inline)
dp.add_handler(inline_handler)
# decode update and try to process it
update = Update.de_json(message, bot)
dp.process_update(update)
def init(dispatcher: Dispatcher):
"""Provide handlers initialization."""
dispatcher.add_handler(CommandHandler('start', start))
dispatcher.add_handler(MessageHandler(Filters.location, location))
def add_handler(dp:Dispatcher):
hunt_handler = CommandHandler('PDLeaderboards', lb)
dp.add_handler(hunt_handler)
def add_handler(dp: Dispatcher):
punish_handler = CommandHandler('punish', punish)
dp.add_handler(punish_handler)
and to give prompt, reliable and official information 24 hours a day, worldwide.
Social media and news channels are the primary outlets through which people get to know about the virus.
However, it is often difficult to find answers to specific doubts that may persist within a context applicable to them.
Moreover, people tend to mass-forward messages they receive without verifying the contents, often leading to false or incorrect information being spread.
Thus it also provide us Reality Check of the news.This will also serve government decision-makers by providing the latest numbers and situation reports.
"""
bot.send_message(chat_id=update.message.chat_id, text=msg)
bot = Bot(TOKEN)
try:
bot.set_webhook("XXXXXXXXXXX/" + TOKEN)
except Exception as e:
print(e)
dp = Dispatcher(bot, None)
dp.add_handler(CommandHandler("about", about))
dp.add_handler(CommandHandler("start", start))
dp.add_handler(CommandHandler("helpline", _help)) #
dp.add_handler(CommandHandler("help", need_help)) #
dp.add_handler(CommandHandler("selectstate", statewise))
dp.add_handler(CommandHandler("selectcity", SelectCity))
dp.add_handler(CommandHandler("faq", FAQ))
dp.add_handler(CommandHandler("latestnews", getnews)) #
dp.add_handler(CommandHandler("hindifakenewscheck", hindifakenews)) #
dp.add_handler(CommandHandler("englishfakenewscheck", englishfakenews)) #
dp.add_handler(MessageHandler(Filters.text, reply_text))
dp.add_handler(MessageHandler(Filters.photo, pic))
dp.add_handler(MessageHandler(Filters.sticker, echo_sticker))
dp.add_handler(MessageHandler(Filters.contact, contact_callback))
#dp.add_handler(MessageHandler(Filters.location, location_callback))
def add_dispather_city(dp: Dispatcher):
dp.add_handler(CommandHandler(["start", "help"], start_city))
return [BotCommand('help', '获取帮助')]
def init(dispatcher: Dispatcher):
"""Provide handlers initialization."""
dispatcher.add_handler(MessageHandler(Filters.status_update.new_chat_members, add_group))
def start_bot(bot):
create_tables()
dp = Dispatcher(bot, None, workers=0, use_context=True)
dp.add_handler(CommandHandler('start', help_start))
dp.add_handler(CommandHandler('help', help_start))
dp.add_handler(
MessageHandler(Filters.text & Filters.regex('ℹ️ О сервисе'),
help_info))
dp.add_handler(
MessageHandler(
Filters.text & Filters.regex('🚀 Увеличить лимит запросов'),
help_no_limits))
dp.add_handler(
MessageHandler(Filters.text & Filters.regex('🚀 Снять ограничение'),
help_no_limits))
dp.add_handler(
CallbackQueryHandler(help_analyse_category,
pattern='keyboard_analyse_category'))
dp.add_handler(
CallbackQueryHandler(help_catalog_link,
pattern='keyboard_help_catalog_link'))
dp.add_handler(
CallbackQueryHandler(help_feedback,
pattern='keyboard_help_info_feedback'))
dp.add_handler(
CallbackQueryHandler(help_no_limits,
pattern='keyboard_help_no_limits'))
dp.add_handler(
MessageHandler(
Filters.text & Filters.regex(
r'(ozon\.ru|beru\.ru|goods\.ru|tmall\.ru|lamoda\.ru)/'),
help_marketplace_not_supported))
dp.add_handler(
MessageHandler(
Filters.text
& Filters.regex(r'www\.wildberries\.ru/catalog/.*/detail\.aspx'),
help_command_not_found))
dp.add_handler(
MessageHandler(
Filters.text & Filters.regex(r'www\.wildberries\.ru/catalog/'),
wb_catalog))
dp.add_handler(
MessageHandler(
Filters.text & Filters.regex(r'www\.wildberries\.ru/brands/'),
wb_catalog))
dp.add_handler(
MessageHandler(
Filters.text & Filters.regex(r'www\.wildberries\.ru/promotions/'),
wb_catalog))
dp.add_handler(
MessageHandler(
Filters.text
& Filters.regex(r'www\.wildberries\.ru/search\?text='),
wb_catalog))
dp.add_handler(MessageHandler(Filters.all, help_command_not_found))
return dp
def __init__(
self,
token: str = None,
base_url: str = None,
workers: int = 4,
bot: Bot = None,
private_key: bytes = None,
private_key_password: bytes = None,
user_sig_handler: Callable = None,
request_kwargs: Dict[str, Any] = None,
persistence: 'BasePersistence' = None,
defaults: 'Defaults' = None,
use_context: bool = True,
dispatcher: Dispatcher = None,
base_file_url: str = None,
):
if defaults and bot:
warnings.warn(
'Passing defaults to an Updater has no effect when a Bot is passed '
'as well. Pass them to the Bot instead.',
TelegramDeprecationWarning,
stacklevel=2,
)
if dispatcher is None:
if (token is None) and (bot is None):
raise ValueError('`token` or `bot` must be passed')
if (token is not None) and (bot is not None):
raise ValueError('`token` and `bot` are mutually exclusive')
if (private_key is not None) and (bot is not None):
raise ValueError(
'`bot` and `private_key` are mutually exclusive')
else:
if bot is not None:
raise ValueError(
'`dispatcher` and `bot` are mutually exclusive')
if persistence is not None:
raise ValueError(
'`dispatcher` and `persistence` are mutually exclusive')
if workers is not None:
raise ValueError(
'`dispatcher` and `workers` are mutually exclusive')
if use_context != dispatcher.use_context:
raise ValueError(
'`dispatcher` and `use_context` are mutually exclusive')
self.logger = logging.getLogger(__name__)
if dispatcher is None:
con_pool_size = workers + 4
if bot is not None:
self.bot = bot
if bot.request.con_pool_size < con_pool_size:
self.logger.warning(
'Connection pool of Request object is smaller than optimal value (%s)',
con_pool_size,
)
else:
# we need a connection pool the size of:
# * for each of the workers
# * 1 for Dispatcher
# * 1 for polling Updater (even if webhook is used, we can spare a connection)
# * 1 for JobQueue
# * 1 for main thread
if request_kwargs is None:
request_kwargs = {}
if 'con_pool_size' not in request_kwargs:
request_kwargs['con_pool_size'] = con_pool_size
self._request = Request(**request_kwargs)
self.bot = Bot(
token, # type: ignore[arg-type]
base_url,
base_file_url=base_file_url,
request=self._request,
private_key=private_key,
private_key_password=private_key_password,
defaults=defaults,
)
self.update_queue: Queue = Queue()
self.job_queue = JobQueue()
self.__exception_event = Event()
self.persistence = persistence
self.dispatcher = Dispatcher(
self.bot,
self.update_queue,
job_queue=self.job_queue,
workers=workers,
exception_event=self.__exception_event,
persistence=persistence,
use_context=use_context,
)
self.job_queue.set_dispatcher(self.dispatcher)
else:
con_pool_size = dispatcher.workers + 4
self.bot = dispatcher.bot
if self.bot.request.con_pool_size < con_pool_size:
self.logger.warning(
'Connection pool of Request object is smaller than optimal value (%s)',
con_pool_size,
)
self.update_queue = dispatcher.update_queue
self.__exception_event = dispatcher.exception_event
self.persistence = dispatcher.persistence
self.job_queue = dispatcher.job_queue
self.dispatcher = dispatcher
self.user_sig_handler = user_sig_handler
self.last_update_id = 0
self.running = False
self.is_idle = False
self.httpd = None
self.__lock = Lock()
self.__threads: List[Thread] = []
def __init__(self,
token=None,
base_url=None,
workers=4,
bot=None,
private_key=None,
private_key_password=None,
user_sig_handler=None,
request_kwargs=None,
persistence=None,
use_context=False):
if (token is None) and (bot is None):
raise ValueError('`token` or `bot` must be passed')
if (token is not None) and (bot is not None):
raise ValueError('`token` and `bot` are mutually exclusive')
if (private_key is not None) and (bot is not None):
raise ValueError('`bot` and `private_key` are mutually exclusive')
self.logger = logging.getLogger(__name__)
con_pool_size = workers + 4
if bot is not None:
self.bot = bot
if bot.request.con_pool_size < con_pool_size:
self.logger.warning(
'Connection pool of Request object is smaller than optimal value (%s)',
con_pool_size)
else:
# we need a connection pool the size of:
# * for each of the workers
# * 1 for Dispatcher
# * 1 for polling Updater (even if webhook is used, we can spare a connection)
# * 1 for JobQueue
# * 1 for main thread
if request_kwargs is None:
request_kwargs = {}
if 'con_pool_size' not in request_kwargs:
request_kwargs['con_pool_size'] = con_pool_size
self._request = Request(**request_kwargs)
self.bot = Bot(token, base_url, request=self._request, private_key=private_key,
private_key_password=private_key_password)
self.user_sig_handler = user_sig_handler
self.update_queue = Queue()
self.job_queue = JobQueue()
self.__exception_event = Event()
self.persistence = persistence
self.dispatcher = Dispatcher(
self.bot,
self.update_queue,
job_queue=self.job_queue,
workers=workers,
exception_event=self.__exception_event,
persistence=persistence,
use_context=use_context)
self.job_queue.set_dispatcher(self.dispatcher)
self.last_update_id = 0
self.running = False
self.is_idle = False
self.httpd = None
self.__lock = Lock()
self.__threads = []
return len(set(phrase.lower().split()) & words) >= threshold
def photo(update: Update, context: CallbackContext) -> None:
photo_file = update.message.photo[-1].get_file()
buffer = photo_file.download_as_bytearray()
image = vision.Image(content=bytes(buffer))
response = vision_client.text_detection(image=image)
text = " ".join([a.description for a in response.text_annotations])
found = words_matcher(text, keywords)
if found:
meme = random.choice(memes)
with open(meme, "rb") as f:
update.message.reply_photo(photo=f)
bot = Bot(token=os.environ["TOKEN"])
dispatcher = Dispatcher(bot=bot, update_queue=None, workers=0)
dispatcher.add_handler(MessageHandler(Filters.photo, photo))
@app.route("/", methods=["POST"])
def index() -> Response:
dispatcher.process_update(Update.de_json(request.get_json(force=True),
bot))
return "", http.HTTPStatus.NO_CONTENT
def setup(webhook_url=None):
"""If webhook_url is not passed, run with long-polling."""
logging.basicConfig(level=logging.WARNING)
if webhook_url:
bot = Bot(TOKEN)
update_queue = Queue()
dp = Dispatcher(bot, update_queue)
else:
updater = Updater(TOKEN) # Create the EventHandler and pass it your bot's token.
bot = updater.bot
dp = updater.dispatcher # Get the dispatcher to register handlers
dp.add_handler(CommandHandler("start", start)) # on /start command answer in Telegram
dp.add_handler(CommandHandler("help", help)) # on /help command answer in Telegram
"""dp.add_handler(CommandHandler("dolintenge", dolintenge))"""
dp.add_handler(CallbackQueryHandler(button))
# on noncommand i.e message - echo the message on Telegram
"""dp.add_handler(MessageHandler(Filters.text, echo))"""
dp.add_handler(MessageHandler(Filters.text, ar))
# log all errors
dp.add_error_handler(error)
# Add your handlers here
if webhook_url:
bot.set_webhook(webhook_url=webhook_url)
thread = Thread(target=dp.start, name='dispatcher')
thread.start()
return update_queue, bot
else:
bot.set_webhook() # Delete webhook
updater.start_polling() # Start the Bot
"""Run the bot until you press 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()
bot.send_message(chat_id=update.message.chat_id,
text=article['link'])
else:
bot.send_message(chat_id=update.message.chat_id, text=reply)
def echo_sticker(bot, update):
bot.send_sticker(chat_id=update.message.chat_id,
sticker=update.message.sticker.file_id)
def error(bot, update):
logger.error("some error has occured")
bot = Bot(TOKEN)
try:
bot.set_webhook("https://hydro-crown-70854.herokuapp.com/" + TOKEN)
except Exception as e:
print(e)
dp = Dispatcher(bot, None)
dp.add_handler(CommandHandler("start", start))
dp.add_handler(CommandHandler("help", _help))
dp.add_handler(CommandHandler("news", news))
dp.add_handler(MessageHandler(Filters.text, reply_text))
dp.add_handler(MessageHandler(Filters.sticker, echo_sticker))
dp.add_error_handler(error)
if __name__ == "__main__":
app.run(port=8443)
def add_handler(dp: Dispatcher):
solve_handler = CommandHandler('PDSolve', solving)
dp.add_handler(solve_handler)
def add_dispatcher(dp: Dispatcher):
dp.add_handler(CommandHandler(["admin"], admin_cmd))
dp.add_handler(
CallbackQueryHandler(admin_cmd_callback,
pattern="^admin:[A-Za-z0-9_]*"))
class Updater:
"""
This class, which employs the :class:`telegram.ext.Dispatcher`, provides a frontend to
:class:`telegram.Bot` to the programmer, so they can focus on coding the bot. Its purpose is to
receive the updates from Telegram and to deliver them to said dispatcher. It also runs in a
separate thread, so the user can interact with the bot, for example on the command line. The
dispatcher supports handlers for different kinds of data: Updates from Telegram, basic text
commands and even arbitrary types. The updater can be started as a polling service or, for
production, use a webhook to receive updates. This is achieved using the WebhookServer and
WebhookHandler classes.
Attributes:
bot (:class:`telegram.Bot`): The bot used with this Updater.
user_sig_handler (:obj:`function`): Optional. Function to be called when a signal is
received.
update_queue (:obj:`Queue`): Queue for the updates.
job_queue (:class:`telegram.ext.JobQueue`): Jobqueue for the updater.
dispatcher (:class:`telegram.ext.Dispatcher`): Dispatcher that handles the updates and
dispatches them to the handlers.
running (:obj:`bool`): Indicates if the updater is running.
persistence (:class:`telegram.ext.BasePersistence`): Optional. The persistence class to
store data that should be persistent over restarts.
use_context (:obj:`bool`): Optional. :obj:`True` if using context based callbacks.
Args:
token (:obj:`str`, optional): The bot's token given by the @BotFather.
base_url (:obj:`str`, optional): Base_url for the bot.
base_file_url (:obj:`str`, optional): Base_file_url for the bot.
workers (:obj:`int`, optional): Amount of threads in the thread pool for functions
decorated with ``@run_async`` (ignored if `dispatcher` argument is used).
bot (:class:`telegram.Bot`, optional): A pre-initialized bot instance (ignored if
`dispatcher` argument is used). If a pre-initialized bot is used, it is the user's
responsibility to create it using a `Request` instance with a large enough connection
pool.
dispatcher (:class:`telegram.ext.Dispatcher`, optional): A pre-initialized dispatcher
instance. If a pre-initialized dispatcher is used, it is the user's responsibility to
create it with proper arguments.
private_key (:obj:`bytes`, optional): Private key for decryption of telegram passport data.
private_key_password (:obj:`bytes`, optional): Password for above private key.
user_sig_handler (:obj:`function`, optional): Takes ``signum, frame`` as positional
arguments. This will be called when a signal is received, defaults are (SIGINT,
SIGTERM, SIGABRT) settable with :attr:`idle`.
request_kwargs (:obj:`dict`, optional): Keyword args to control the creation of a
`telegram.utils.request.Request` object (ignored if `bot` or `dispatcher` argument is
used). The request_kwargs are very useful for the advanced users who would like to
control the default timeouts and/or control the proxy used for http communication.
use_context (:obj:`bool`, optional): If set to :obj:`True` uses the context based callback
API (ignored if `dispatcher` argument is used). Defaults to :obj:`True`.
**New users**: set this to :obj:`True`.
persistence (:class:`telegram.ext.BasePersistence`, optional): The persistence class to
store data that should be persistent over restarts (ignored if `dispatcher` argument is
used).
defaults (:class:`telegram.ext.Defaults`, optional): An object containing default values to
be used if not set explicitly in the bot methods.
Note:
* You must supply either a :attr:`bot` or a :attr:`token` argument.
* If you supply a :attr:`bot`, you will need to pass :attr:`defaults` to *both* the bot and
the :class:`telegram.ext.Updater`.
Raises:
ValueError: If both :attr:`token` and :attr:`bot` are passed or none of them.
"""
_request = None
def __init__(
self,
token: str = None,
base_url: str = None,
workers: int = 4,
bot: Bot = None,
private_key: bytes = None,
private_key_password: bytes = None,
user_sig_handler: Callable = None,
request_kwargs: Dict[str, Any] = None,
persistence: 'BasePersistence' = None,
defaults: 'Defaults' = None,
use_context: bool = True,
dispatcher: Dispatcher = None,
base_file_url: str = None,
):
if defaults and bot:
warnings.warn(
'Passing defaults to an Updater has no effect when a Bot is passed '
'as well. Pass them to the Bot instead.',
TelegramDeprecationWarning,
stacklevel=2,
)
if dispatcher is None:
if (token is None) and (bot is None):
raise ValueError('`token` or `bot` must be passed')
if (token is not None) and (bot is not None):
raise ValueError('`token` and `bot` are mutually exclusive')
if (private_key is not None) and (bot is not None):
raise ValueError(
'`bot` and `private_key` are mutually exclusive')
else:
if bot is not None:
raise ValueError(
'`dispatcher` and `bot` are mutually exclusive')
if persistence is not None:
raise ValueError(
'`dispatcher` and `persistence` are mutually exclusive')
if workers is not None:
raise ValueError(
'`dispatcher` and `workers` are mutually exclusive')
if use_context != dispatcher.use_context:
raise ValueError(
'`dispatcher` and `use_context` are mutually exclusive')
self.logger = logging.getLogger(__name__)
if dispatcher is None:
con_pool_size = workers + 4
if bot is not None:
self.bot = bot
if bot.request.con_pool_size < con_pool_size:
self.logger.warning(
'Connection pool of Request object is smaller than optimal value (%s)',
con_pool_size,
)
else:
# we need a connection pool the size of:
# * for each of the workers
# * 1 for Dispatcher
# * 1 for polling Updater (even if webhook is used, we can spare a connection)
# * 1 for JobQueue
# * 1 for main thread
if request_kwargs is None:
request_kwargs = {}
if 'con_pool_size' not in request_kwargs:
request_kwargs['con_pool_size'] = con_pool_size
self._request = Request(**request_kwargs)
self.bot = Bot(
token, # type: ignore[arg-type]
base_url,
base_file_url=base_file_url,
request=self._request,
private_key=private_key,
private_key_password=private_key_password,
defaults=defaults,
)
self.update_queue: Queue = Queue()
self.job_queue = JobQueue()
self.__exception_event = Event()
self.persistence = persistence
self.dispatcher = Dispatcher(
self.bot,
self.update_queue,
job_queue=self.job_queue,
workers=workers,
exception_event=self.__exception_event,
persistence=persistence,
use_context=use_context,
)
self.job_queue.set_dispatcher(self.dispatcher)
else:
con_pool_size = dispatcher.workers + 4
self.bot = dispatcher.bot
if self.bot.request.con_pool_size < con_pool_size:
self.logger.warning(
'Connection pool of Request object is smaller than optimal value (%s)',
con_pool_size,
)
self.update_queue = dispatcher.update_queue
self.__exception_event = dispatcher.exception_event
self.persistence = dispatcher.persistence
self.job_queue = dispatcher.job_queue
self.dispatcher = dispatcher
self.user_sig_handler = user_sig_handler
self.last_update_id = 0
self.running = False
self.is_idle = False
self.httpd = None
self.__lock = Lock()
self.__threads: List[Thread] = []
def _init_thread(self, target: Callable, name: str, *args: Any,
**kwargs: Any) -> None:
thr = Thread(
target=self._thread_wrapper,
name="Bot:{}:{}".format(self.bot.id, name),
args=(target, ) + args,
kwargs=kwargs,
)
thr.start()
self.__threads.append(thr)
def _thread_wrapper(self, target: Callable, *args: Any,
**kwargs: Any) -> None:
thr_name = current_thread().name
self.logger.debug('{} - started'.format(thr_name))
try:
target(*args, **kwargs)
except Exception:
self.__exception_event.set()
self.logger.exception('unhandled exception in %s', thr_name)
raise
self.logger.debug('{} - ended'.format(thr_name))
def start_polling(
self,
poll_interval: float = 0.0,
timeout: float = 10,
clean: bool = False,
bootstrap_retries: int = -1,
read_latency: float = 2.0,
allowed_updates: List[str] = None,
) -> Optional[Queue]:
"""Starts polling updates from Telegram.
Args:
poll_interval (:obj:`float`, optional): Time to wait between polling updates from
Telegram in seconds. Default is 0.0.
timeout (:obj:`float`, optional): Passed to :attr:`telegram.Bot.get_updates`.
clean (:obj:`bool`, optional): Whether to clean any pending updates on Telegram servers
before actually starting to poll. Default is :obj:`False`.
bootstrap_retries (:obj:`int`, optional): Whether the bootstrapping phase of the
`Updater` will retry on failures on the Telegram server.
* < 0 - retry indefinitely (default)
* 0 - no retries
* > 0 - retry up to X times
allowed_updates (List[:obj:`str`], optional): Passed to
:attr:`telegram.Bot.get_updates`.
read_latency (:obj:`float` | :obj:`int`, optional): Grace time in seconds for receiving
the reply from server. Will be added to the `timeout` value and used as the read
timeout from server (Default: 2).
Returns:
:obj:`Queue`: The update queue that can be filled from the main thread.
"""
with self.__lock:
if not self.running:
self.running = True
# Create & start threads
self.job_queue.start()
dispatcher_ready = Event()
polling_ready = Event()
self._init_thread(self.dispatcher.start,
"dispatcher",
ready=dispatcher_ready)
self._init_thread(
self._start_polling,
"updater",
poll_interval,
timeout,
read_latency,
bootstrap_retries,
clean,
allowed_updates,
ready=polling_ready,
)
self.logger.debug(
'Waiting for Dispatcher and polling to start')
dispatcher_ready.wait()
polling_ready.wait()
# Return the update queue so the main thread can insert updates
return self.update_queue
return None
def start_webhook(
self,
listen: str = '127.0.0.1',
port: int = 80,
url_path: str = '',
cert: str = None,
key: str = None,
clean: bool = False,
bootstrap_retries: int = 0,
webhook_url: str = None,
allowed_updates: List[str] = None,
force_event_loop: bool = False,
) -> Optional[Queue]:
"""
Starts a small http server to listen for updates via webhook. If cert
and key are not provided, the webhook will be started directly on
http://listen:port/url_path, so SSL can be handled by another
application. Else, the webhook will be started on
https://listen:port/url_path
Note:
Due to an incompatibility of the Tornado library PTB uses for the webhook with Python
3.8+ on Windows machines, PTB will attempt to set the event loop to
:attr:`asyncio.SelectorEventLoop` and raise an exception, if an incompatible event loop
has already been specified. See this `thread`_ for more details. To suppress the
exception, set :attr:`force_event_loop` to :obj:`True`.
.. _thread: https://github.com/tornadoweb/tornado/issues/2608
Args:
listen (:obj:`str`, optional): IP-Address to listen on. Default ``127.0.0.1``.
port (:obj:`int`, optional): Port the bot should be listening on. Default ``80``.
url_path (:obj:`str`, optional): Path inside url.
cert (:obj:`str`, optional): Path to the SSL certificate file.
key (:obj:`str`, optional): Path to the SSL key file.
clean (:obj:`bool`, optional): Whether to clean any pending updates on Telegram servers
before actually starting the webhook. Default is :obj:`False`.
bootstrap_retries (:obj:`int`, optional): Whether the bootstrapping phase of the
`Updater` will retry on failures on the Telegram server.
* < 0 - retry indefinitely (default)
* 0 - no retries
* > 0 - retry up to X times
webhook_url (:obj:`str`, optional): Explicitly specify the webhook url. Useful behind
NAT, reverse proxy, etc. Default is derived from `listen`, `port` & `url_path`.
allowed_updates (List[:obj:`str`], optional): Passed to
:attr:`telegram.Bot.set_webhook`.
force_event_loop (:obj:`bool`, optional): Force using the current event loop. See above
note for details. Defaults to :obj:`False`
Returns:
:obj:`Queue`: The update queue that can be filled from the main thread.
"""
with self.__lock:
if not self.running:
self.running = True
# Create & start threads
webhook_ready = Event()
dispatcher_ready = Event()
self.job_queue.start()
self._init_thread(self.dispatcher.start, "dispatcher",
dispatcher_ready)
self._init_thread(
self._start_webhook,
"updater",
listen,
port,
url_path,
cert,
key,
bootstrap_retries,
clean,
webhook_url,
allowed_updates,
ready=webhook_ready,
force_event_loop=force_event_loop,
)
self.logger.debug(
'Waiting for Dispatcher and Webhook to start')
webhook_ready.wait()
dispatcher_ready.wait()
# Return the update queue so the main thread can insert updates
return self.update_queue
return None
@no_type_check
def _start_polling(
self,
poll_interval,
timeout,
read_latency,
bootstrap_retries,
clean,
allowed_updates,
ready=None,
): # pragma: no cover
# Thread target of thread 'updater'. Runs in background, pulls
# updates from Telegram and inserts them in the update queue of the
# Dispatcher.
self.logger.debug('Updater thread started (polling)')
self._bootstrap(bootstrap_retries,
clean=clean,
webhook_url='',
allowed_updates=None)
self.logger.debug('Bootstrap done')
def polling_action_cb():
updates = self.bot.get_updates(
self.last_update_id,
timeout=timeout,
read_latency=read_latency,
allowed_updates=allowed_updates,
)
if updates:
if not self.running:
self.logger.debug(
'Updates ignored and will be pulled again on restart')
else:
for update in updates:
self.update_queue.put(update)
self.last_update_id = updates[-1].update_id + 1
return True
def polling_onerr_cb(exc):
# Put the error into the update queue and let the Dispatcher
# broadcast it
self.update_queue.put(exc)
if ready is not None:
ready.set()
self._network_loop_retry(polling_action_cb, polling_onerr_cb,
'getting Updates', poll_interval)
@no_type_check
def _network_loop_retry(self, action_cb, onerr_cb, description, interval):
"""Perform a loop calling `action_cb`, retrying after network errors.
Stop condition for loop: `self.running` evaluates :obj:`False` or return value of
`action_cb` evaluates :obj:`False`.
Args:
action_cb (:obj:`callable`): Network oriented callback function to call.
onerr_cb (:obj:`callable`): Callback to call when TelegramError is caught. Receives the
exception object as a parameter.
description (:obj:`str`): Description text to use for logs and exception raised.
interval (:obj:`float` | :obj:`int`): Interval to sleep between each call to
`action_cb`.
"""
self.logger.debug('Start network loop retry %s', description)
cur_interval = interval
while self.running:
try:
if not action_cb():
break
except RetryAfter as e:
self.logger.info('%s', e)
cur_interval = 0.5 + e.retry_after
except TimedOut as toe:
self.logger.debug('Timed out %s: %s', description, toe)
# If failure is due to timeout, we should retry asap.
cur_interval = 0
except InvalidToken as pex:
self.logger.error('Invalid token; aborting')
raise pex
except TelegramError as te:
self.logger.error('Error while %s: %s', description, te)
onerr_cb(te)
cur_interval = self._increase_poll_interval(cur_interval)
else:
cur_interval = interval
if cur_interval:
sleep(cur_interval)
@staticmethod
def _increase_poll_interval(current_interval: float) -> float:
# increase waiting times on subsequent errors up to 30secs
if current_interval == 0:
current_interval = 1
elif current_interval < 30:
current_interval += current_interval / 2
elif current_interval > 30:
current_interval = 30
return current_interval
@no_type_check
def _start_webhook(
self,
listen,
port,
url_path,
cert,
key,
bootstrap_retries,
clean,
webhook_url,
allowed_updates,
ready=None,
force_event_loop=False,
):
self.logger.debug('Updater thread started (webhook)')
use_ssl = cert is not None and key is not None
if not url_path.startswith('/'):
url_path = '/{}'.format(url_path)
# Create Tornado app instance
app = WebhookAppClass(url_path, self.bot, self.update_queue)
# Form SSL Context
# An SSLError is raised if the private key does not match with the certificate
if use_ssl:
try:
ssl_ctx = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
ssl_ctx.load_cert_chain(cert, key)
except ssl.SSLError:
raise TelegramError('Invalid SSL Certificate')
else:
ssl_ctx = None
# Create and start server
self.httpd = WebhookServer(listen, port, app, ssl_ctx)
if use_ssl:
# DO NOT CHANGE: Only set webhook if SSL is handled by library
if not webhook_url:
webhook_url = self._gen_webhook_url(listen, port, url_path)
self._bootstrap(
max_retries=bootstrap_retries,
clean=clean,
webhook_url=webhook_url,
cert=open(cert, 'rb'),
allowed_updates=allowed_updates,
)
elif clean:
self.logger.warning("cleaning updates is not supported if "
"SSL-termination happens elsewhere; skipping")
self.httpd.serve_forever(force_event_loop=force_event_loop,
ready=ready)
@staticmethod
def _gen_webhook_url(listen: str, port: int, url_path: str) -> str:
return 'https://{listen}:{port}{path}'.format(listen=listen,
port=port,
path=url_path)
@no_type_check
def _bootstrap(self,
max_retries,
clean,
webhook_url,
allowed_updates,
cert=None,
bootstrap_interval=5):
retries = [0]
def bootstrap_del_webhook():
self.bot.delete_webhook()
return False
def bootstrap_clean_updates():
self.logger.debug('Cleaning updates from Telegram server')
updates = self.bot.get_updates()
while updates:
updates = self.bot.get_updates(updates[-1].update_id + 1)
return False
def bootstrap_set_webhook():
self.bot.set_webhook(url=webhook_url,
certificate=cert,
allowed_updates=allowed_updates)
return False
def bootstrap_onerr_cb(exc):
if not isinstance(exc, Unauthorized) and (
max_retries < 0 or retries[0] < max_retries):
retries[0] += 1
self.logger.warning(
'Failed bootstrap phase; try=%s max_retries=%s',
retries[0], max_retries)
else:
self.logger.error(
'Failed bootstrap phase after %s retries (%s)', retries[0],
exc)
raise exc
# Cleaning pending messages is done by polling for them - so we need to delete webhook if
# one is configured.
# We also take this chance to delete pre-configured webhook if this is a polling Updater.
# NOTE: We don't know ahead if a webhook is configured, so we just delete.
if clean or not webhook_url:
self._network_loop_retry(
bootstrap_del_webhook,
bootstrap_onerr_cb,
'bootstrap del webhook',
bootstrap_interval,
)
retries[0] = 0
# Clean pending messages, if requested.
if clean:
self._network_loop_retry(
bootstrap_clean_updates,
bootstrap_onerr_cb,
'bootstrap clean updates',
bootstrap_interval,
)
retries[0] = 0
sleep(1)
# Restore/set webhook settings, if needed. Again, we don't know ahead if a webhook is set,
# so we set it anyhow.
if webhook_url:
self._network_loop_retry(
bootstrap_set_webhook,
bootstrap_onerr_cb,
'bootstrap set webhook',
bootstrap_interval,
)
def stop(self) -> None:
"""Stops the polling/webhook thread, the dispatcher and the job queue."""
self.job_queue.stop()
with self.__lock:
if self.running or self.dispatcher.has_running_threads:
self.logger.debug('Stopping Updater and Dispatcher...')
self.running = False
self._stop_httpd()
self._stop_dispatcher()
self._join_threads()
# Stop the Request instance only if it was created by the Updater
if self._request:
self._request.stop()
@no_type_check
def _stop_httpd(self) -> None:
if self.httpd:
self.logger.debug(
'Waiting for current webhook connection to be '
'closed... Send a Telegram message to the bot to exit '
'immediately.')
self.httpd.shutdown()
self.httpd = None
@no_type_check
def _stop_dispatcher(self) -> None:
self.logger.debug('Requesting Dispatcher to stop...')
self.dispatcher.stop()
@no_type_check
def _join_threads(self) -> None:
for thr in self.__threads:
self.logger.debug('Waiting for {} thread to end'.format(thr.name))
thr.join()
self.logger.debug('{} thread has ended'.format(thr.name))
self.__threads = []
@no_type_check
def signal_handler(self, signum, frame) -> None:
self.is_idle = False
if self.running:
self.logger.info('Received signal {} ({}), stopping...'.format(
signum, get_signal_name(signum)))
if self.persistence:
# Update user_data, chat_data and bot_data before flushing
self.dispatcher.update_persistence()
self.persistence.flush()
self.stop()
if self.user_sig_handler:
self.user_sig_handler(signum, frame)
else:
self.logger.warning('Exiting immediately!')
import os
os._exit(1)
def idle(
self, stop_signals: Union[List, Tuple] = (SIGINT, SIGTERM, SIGABRT)
) -> None:
"""Blocks until one of the signals are received and stops the updater.
Args:
stop_signals (:obj:`list` | :obj:`tuple`): List containing signals from the signal
module that should be subscribed to. Updater.stop() will be called on receiving one
of those signals. Defaults to (``SIGINT``, ``SIGTERM``, ``SIGABRT``).
"""
for sig in stop_signals:
signal(sig, self.signal_handler)
self.is_idle = True
while self.is_idle:
sleep(1)
def init(dispatcher: Dispatcher):
"""Provide handlers initialization."""
dispatcher.add_handler(CommandHandler('ban', ban, filters=Filters.chat(config.USER_IDS[0]), pass_args=True))
dispatcher.add_handler(CommandHandler('unban', unban, filters=Filters.chat(config.USER_IDS[0]), pass_args=True))
def load_all(dispatcher: Dispatcher, job_queue: JobQueue) -> None:
from .basic import (
callback_generic,
cmd_getid,
cmd_start,
)
from .broadcast import (
callback_broadcast,
cmd_broadcast,
)
from .conversation import cmd_mention
from .elections import load_all as load_elections_handlers
from .groups import load_all as load_groups_handlers
from .rooms import (
callback_dafi,
cmd_dafi,
job_dafi,
)
from .users import load_all as load_users_handlers
tzinfo = pytz.timezone('Europe/Madrid')
# Basic
dispatcher.add_handler(
CallbackQueryHandler(callback_generic, pattern='main'))
dispatcher.add_handler(CommandHandler('getid', cmd_getid))
dispatcher.add_handler(CommandHandler('start', cmd_start))
# Broadcast
dispatcher.add_handler(
CallbackQueryHandler(callback_broadcast, pattern='broadcast'))
dispatcher.add_handler(CommandHandler('broadcast', cmd_broadcast))
# Conversation
dispatcher.add_handler(CommandHandler('mencionar', cmd_mention))
# Rooms
dispatcher.add_handler(CallbackQueryHandler(callback_dafi, pattern='dafi'))
dispatcher.add_handler(CommandHandler('dafi', cmd_dafi))
job_queue.run_daily(job_dafi, time(hour=21, minute=10, tzinfo=tzinfo))
load_elections_handlers(dispatcher)
load_groups_handlers(dispatcher)
load_users_handlers(dispatcher)
class Updater(object):
"""
This class, which employs the :class:`telegram.ext.Dispatcher`, provides a frontend to
:class:`telegram.Bot` to the programmer, so they can focus on coding the bot. Its purpose is to
receive the updates from Telegram and to deliver them to said dispatcher. It also runs in a
separate thread, so the user can interact with the bot, for example on the command line. The
dispatcher supports handlers for different kinds of data: Updates from Telegram, basic text
commands and even arbitrary types. The updater can be started as a polling service or, for
production, use a webhook to receive updates. This is achieved using the WebhookServer and
WebhookHandler classes.
Attributes:
bot (:class:`telegram.Bot`): The bot used with this Updater.
user_sig_handler (:obj:`signal`): signals the updater will respond to.
update_queue (:obj:`Queue`): Queue for the updates.
job_queue (:class:`telegram.ext.JobQueue`): Jobqueue for the updater.
dispatcher (:class:`telegram.ext.Dispatcher`): Dispatcher that handles the updates and
dispatches them to the handlers.
running (:obj:`bool`): Indicates if the updater is running.
Args:
token (:obj:`str`, optional): The bot's token given by the @BotFather.
base_url (:obj:`str`, optional): Base_url for the bot.
workers (:obj:`int`, optional): Amount of threads in the thread pool for functions
decorated with ``@run_async``.
bot (:class:`telegram.Bot`, optional): A pre-initialized bot instance. If a pre-initialized
bot is used, it is the user's responsibility to create it using a `Request`
instance with a large enough connection pool.
user_sig_handler (:obj:`function`, optional): Takes ``signum, frame`` as positional
arguments. This will be called when a signal is received, defaults are (SIGINT,
SIGTERM, SIGABRT) setable with :attr:`idle`.
request_kwargs (:obj:`dict`, optional): Keyword args to control the creation of a
`telegram.utils.request.Request` object (ignored if `bot` argument is used). The
request_kwargs are very useful for the advanced users who would like to control the
default timeouts and/or control the proxy used for http communication.
Note:
You must supply either a :attr:`bot` or a :attr:`token` argument.
Raises:
ValueError: If both :attr:`token` and :attr:`bot` are passed or none of them.
"""
_request = None
def __init__(self,
token=None,
base_url=None,
workers=4,
bot=None,
user_sig_handler=None,
request_kwargs=None):
if (token is None) and (bot is None):
raise ValueError('`token` or `bot` must be passed')
if (token is not None) and (bot is not None):
raise ValueError('`token` and `bot` are mutually exclusive')
self.logger = logging.getLogger(__name__)
con_pool_size = workers + 4
if bot is not None:
self.bot = bot
if bot.request.con_pool_size < con_pool_size:
self.logger.warning(
'Connection pool of Request object is smaller than optimal value (%s)',
con_pool_size)
else:
# we need a connection pool the size of:
# * for each of the workers
# * 1 for Dispatcher
# * 1 for polling Updater (even if webhook is used, we can spare a connection)
# * 1 for JobQueue
# * 1 for main thread
if request_kwargs is None:
request_kwargs = {}
if 'con_pool_size' not in request_kwargs:
request_kwargs['con_pool_size'] = con_pool_size
self._request = Request(**request_kwargs)
self.bot = Bot(token, base_url, request=self._request)
self.user_sig_handler = user_sig_handler
self.update_queue = Queue()
self.job_queue = JobQueue(self.bot)
self.__exception_event = Event()
self.dispatcher = Dispatcher(self.bot,
self.update_queue,
job_queue=self.job_queue,
workers=workers,
exception_event=self.__exception_event)
self.last_update_id = 0
self.running = False
self.is_idle = False
self.httpd = None
self.__lock = Lock()
self.__threads = []
def _init_thread(self, target, name, *args, **kwargs):
thr = Thread(target=self._thread_wrapper,
name=name,
args=(target, ) + args,
kwargs=kwargs)
thr.start()
self.__threads.append(thr)
def _thread_wrapper(self, target, *args, **kwargs):
thr_name = current_thread().name
self.logger.debug('{0} - started'.format(thr_name))
try:
target(*args, **kwargs)
except Exception:
self.__exception_event.set()
self.logger.exception('unhandled exception')
raise
self.logger.debug('{0} - ended'.format(thr_name))
def start_polling(self,
poll_interval=0.0,
timeout=10,
clean=False,
bootstrap_retries=0,
read_latency=2.,
allowed_updates=None):
"""Starts polling updates from Telegram.
Args:
poll_interval (:obj:`float`, optional): Time to wait between polling updates from
Telegram in seconds. Default is 0.0.
timeout (:obj:`float`, optional): Passed to :attr:`telegram.Bot.get_updates`.
clean (:obj:`bool`, optional): Whether to clean any pending updates on Telegram servers
before actually starting to poll. Default is False.
bootstrap_retries (:obj:`int`, optional): Whether the bootstrapping phase of the
`Updater` will retry on failures on the Telegram server.
* < 0 - retry indefinitely
* 0 - no retries (default)
* > 0 - retry up to X times
allowed_updates (List[:obj:`str`], optional): Passed to
:attr:`telegram.Bot.get_updates`.
read_latency (:obj:`float` | :obj:`int`, optional): Grace time in seconds for receiving
the reply from server. Will be added to the `timeout` value and used as the read
timeout from server (Default: 2).
Returns:
:obj:`Queue`: The update queue that can be filled from the main thread.
"""
with self.__lock:
if not self.running:
self.running = True
# Create & start threads
self.job_queue.start()
dispatcher_ready = Event()
self._init_thread(self.dispatcher.start,
"dispatcher",
ready=dispatcher_ready)
self._init_thread(self._start_polling, "updater",
poll_interval, timeout, read_latency,
bootstrap_retries, clean, allowed_updates)
dispatcher_ready.wait()
# Return the update queue so the main thread can insert updates
return self.update_queue
def start_webhook(self,
listen='127.0.0.1',
port=80,
url_path='',
cert=None,
key=None,
clean=False,
bootstrap_retries=0,
webhook_url=None,
allowed_updates=None):
"""
Starts a small http server to listen for updates via webhook. If cert
and key are not provided, the webhook will be started directly on
http://listen:port/url_path, so SSL can be handled by another
application. Else, the webhook will be started on
https://listen:port/url_path
Args:
listen (:obj:`str`, optional): IP-Address to listen on. Default ``127.0.0.1``.
port (:obj:`int`, optional): Port the bot should be listening on. Default ``80``.
url_path (:obj:`str`, optional): Path inside url.
cert (:obj:`str`, optional): Path to the SSL certificate file.
key (:obj:`str`, optional): Path to the SSL key file.
clean (:obj:`bool`, optional): Whether to clean any pending updates on Telegram servers
before actually starting the webhook. Default is ``False``.
bootstrap_retries (:obj:`int`, optional): Whether the bootstrapping phase of the
`Updater` will retry on failures on the Telegram server.
* < 0 - retry indefinitely
* 0 - no retries (default)
* > 0 - retry up to X times
webhook_url (:obj:`str`, optional): Explicitly specify the webhook url. Useful behind
NAT, reverse proxy, etc. Default is derived from `listen`, `port` & `url_path`.
allowed_updates (List[:obj:`str`], optional): Passed to
:attr:`telegram.Bot.set_webhook`.
Returns:
:obj:`Queue`: The update queue that can be filled from the main thread.
"""
with self.__lock:
if not self.running:
self.running = True
# Create & start threads
self.job_queue.start()
self._init_thread(self.dispatcher.start, "dispatcher"),
self._init_thread(self._start_webhook, "updater", listen, port,
url_path, cert, key, bootstrap_retries,
clean, webhook_url, allowed_updates)
# Return the update queue so the main thread can insert updates
return self.update_queue
def _start_polling(self, poll_interval, timeout, read_latency,
bootstrap_retries, clean,
allowed_updates): # pragma: no cover
# Thread target of thread 'updater'. Runs in background, pulls
# updates from Telegram and inserts them in the update queue of the
# Dispatcher.
cur_interval = poll_interval
self.logger.debug('Updater thread started')
self._bootstrap(bootstrap_retries,
clean=clean,
webhook_url='',
allowed_updates=None)
while self.running:
try:
updates = self.bot.get_updates(self.last_update_id,
timeout=timeout,
read_latency=read_latency,
allowed_updates=allowed_updates)
except RetryAfter as e:
self.logger.info(str(e))
cur_interval = 0.5 + e.retry_after
except TimedOut as toe:
self.logger.debug('Timed out getting Updates: %s', toe)
# If get_updates() failed due to timeout, we should retry asap.
cur_interval = 0
except TelegramError as te:
self.logger.error('Error while getting Updates: %s', te)
# Put the error into the update queue and let the Dispatcher
# broadcast it
self.update_queue.put(te)
cur_interval = self._increase_poll_interval(cur_interval)
else:
if not self.running:
if len(updates) > 0:
self.logger.debug('Updates ignored and will be pulled '
'again on restart.')
break
if updates:
for update in updates:
self.update_queue.put(update)
self.last_update_id = updates[-1].update_id + 1
cur_interval = poll_interval
if cur_interval:
sleep(cur_interval)
@staticmethod
def _increase_poll_interval(current_interval):
# increase waiting times on subsequent errors up to 30secs
if current_interval == 0:
current_interval = 1
elif current_interval < 30:
current_interval += current_interval / 2
elif current_interval > 30:
current_interval = 30
return current_interval
def _start_webhook(self, listen, port, url_path, cert, key,
bootstrap_retries, clean, webhook_url, allowed_updates):
self.logger.debug('Updater thread started')
use_ssl = cert is not None and key is not None
if not url_path.startswith('/'):
url_path = '/{0}'.format(url_path)
# Create and start server
self.httpd = WebhookServer((listen, port), WebhookHandler,
self.update_queue, url_path, self.bot)
if use_ssl:
self._check_ssl_cert(cert, key)
# DO NOT CHANGE: Only set webhook if SSL is handled by library
if not webhook_url:
webhook_url = self._gen_webhook_url(listen, port, url_path)
self._bootstrap(max_retries=bootstrap_retries,
clean=clean,
webhook_url=webhook_url,
cert=open(cert, 'rb'),
allowed_updates=allowed_updates)
elif clean:
self.logger.warning("cleaning updates is not supported if "
"SSL-termination happens elsewhere; skipping")
self.httpd.serve_forever(poll_interval=1)
def _check_ssl_cert(self, cert, key):
# Check SSL-Certificate with openssl, if possible
try:
exit_code = subprocess.call(
["openssl", "x509", "-text", "-noout", "-in", cert],
stdout=open(os.devnull, 'wb'),
stderr=subprocess.STDOUT)
except OSError:
exit_code = 0
if exit_code is 0:
try:
self.httpd.socket = ssl.wrap_socket(self.httpd.socket,
certfile=cert,
keyfile=key,
server_side=True)
except ssl.SSLError as error:
self.logger.exception('Failed to init SSL socket')
raise TelegramError(str(error))
else:
raise TelegramError('SSL Certificate invalid')
@staticmethod
def _gen_webhook_url(listen, port, url_path):
return 'https://{listen}:{port}{path}'.format(listen=listen,
port=port,
path=url_path)
def _bootstrap(self,
max_retries,
clean,
webhook_url,
allowed_updates,
cert=None):
retries = 0
while 1:
try:
if clean:
# Disable webhook for cleaning
self.bot.delete_webhook()
self._clean_updates()
sleep(1)
self.bot.set_webhook(url=webhook_url,
certificate=cert,
allowed_updates=allowed_updates)
except (Unauthorized, InvalidToken):
raise
except TelegramError:
msg = 'error in bootstrap phase; try={0} max_retries={1}'.format(
retries, max_retries)
if max_retries < 0 or retries < max_retries:
self.logger.warning(msg)
retries += 1
else:
self.logger.exception(msg)
raise
else:
break
sleep(1)
def _clean_updates(self):
self.logger.debug('Cleaning updates from Telegram server')
updates = self.bot.get_updates()
while updates:
updates = self.bot.get_updates(updates[-1].update_id + 1)
def stop(self):
"""Stops the polling/webhook thread, the dispatcher and the job queue."""
self.job_queue.stop()
with self.__lock:
if self.running or self.dispatcher.has_running_threads:
self.logger.debug('Stopping Updater and Dispatcher...')
self.running = False
self._stop_httpd()
self._stop_dispatcher()
self._join_threads()
# Stop the Request instance only if it was created by the Updater
if self._request:
self._request.stop()
def _stop_httpd(self):
if self.httpd:
self.logger.debug(
'Waiting for current webhook connection to be '
'closed... Send a Telegram message to the bot to exit '
'immediately.')
self.httpd.shutdown()
self.httpd = None
def _stop_dispatcher(self):
self.logger.debug('Requesting Dispatcher to stop...')
self.dispatcher.stop()
def _join_threads(self):
for thr in self.__threads:
self.logger.debug('Waiting for {0} thread to end'.format(thr.name))
thr.join()
self.logger.debug('{0} thread has ended'.format(thr.name))
self.__threads = []
def signal_handler(self, signum, frame):
self.is_idle = False
if self.running:
self.logger.info('Received signal {} ({}), stopping...'.format(
signum, get_signal_name(signum)))
self.stop()
if self.user_sig_handler:
self.user_sig_handler(signum, frame)
else:
self.logger.warning('Exiting immediately!')
import os
os._exit(1)
def idle(self, stop_signals=(SIGINT, SIGTERM, SIGABRT)):
"""Blocks until one of the signals are received and stops the updater.
Args:
stop_signals (:obj:`iterable`): Iterable containing signals from the signal module that
should be subscribed to. Updater.stop() will be called on receiving one of those
signals. Defaults to (``SIGINT``, ``SIGTERM``, ``SIGABRT``).
"""
for sig in stop_signals:
signal(sig, self.signal_handler)
self.is_idle = True
while self.is_idle:
sleep(1)
def test_mutual_exclude_bot_dispatcher(self):
dispatcher = Dispatcher(None, None)
bot = Bot('123:zyxw')
with pytest.raises(ValueError):
Updater(bot=bot, dispatcher=dispatcher)
def ready(self):
if DjangoTelegramBot.ready_run:
return
DjangoTelegramBot.ready_run = True
self.mode = WEBHOOK_MODE
if settings.DJANGO_TELEGRAMBOT.get('MODE', 'WEBHOOK') == 'POLLING':
self.mode = POLLING_MODE
modes = ['WEBHOOK', 'POLLING']
logger.info('Django Telegram Bot <{} mode>'.format(modes[self.mode]))
bots_list = settings.DJANGO_TELEGRAMBOT.get('BOTS', [])
if self.mode == WEBHOOK_MODE:
webhook_site = settings.DJANGO_TELEGRAMBOT.get(
'WEBHOOK_SITE', None)
if not webhook_site:
logger.warn(
'Required TELEGRAM_WEBHOOK_SITE missing in settings')
return
if webhook_site.endswith("/"):
webhook_site = webhook_site[:-1]
webhook_base = settings.DJANGO_TELEGRAMBOT.get(
'WEBHOOK_PREFIX', '/')
if webhook_base.startswith("/"):
webhook_base = webhook_base[1:]
if webhook_base.endswith("/"):
webhook_base = webhook_base[:-1]
cert = settings.DJANGO_TELEGRAMBOT.get('WEBHOOK_CERTIFICATE', None)
certificate = None
if cert and os.path.exists(cert):
logger.info('WEBHOOK_CERTIFICATE found in {}'.format(cert))
certificate = open(cert, 'rb')
elif cert:
logger.error(
'WEBHOOK_CERTIFICATE not found in {} '.format(cert))
for b in bots_list:
token = b.get('TOKEN', None)
if not token:
break
allowed_updates = b.get('ALLOWED_UPDATES', None)
timeout = b.get('TIMEOUT', None)
if self.mode == WEBHOOK_MODE:
try:
bot = telegram.Bot(token=token)
DjangoTelegramBot.dispatchers.append(
Dispatcher(bot, None, workers=0))
hookurl = '{}/{}/{}/'.format(webhook_site, webhook_base,
token)
max_connections = b.get('WEBHOOK_MAX_CONNECTIONS', 40)
force_setWebhook = b.get('FORCE_SETWEBHOOK')
webhook_info = bot.getWebhookInfo()
setted = 'alredy setted'
if (webhook_info.url !=
hookurl) or (webhook_info.url == hookurl
and force_setWebhook is 'TRUE'):
logger.info('Update setWebhook')
setted = bot.setWebhook(
hookurl,
certificate=certificate,
timeout=timeout,
max_connections=max_connections,
allowed_updates=allowed_updates)
time.sleep(5)
webhook_info = bot.getWebhookInfo()
real_allowed = webhook_info.allowed_updates if webhook_info.allowed_updates else [
"ALL"
]
bot.more_info = webhook_info
bot.more_info = webhook_info
logger.info(
'Telegram Bot <{}> setting webhook [ {} ] max connections:{} allowed updates:{} pending updates:{} : {}'
.format(bot.username, webhook_info.url,
webhook_info.max_connections, real_allowed,
webhook_info.pending_update_count, setted))
except InvalidToken:
logger.error('Invalid Token : {}'.format(token))
return
except TelegramError as er:
logger.error('Error : {}'.format(repr(er)))
return
else:
try:
updater = Updater(token=token)
bot = updater.bot
bot.delete_webhook()
DjangoTelegramBot.updaters.append(updater)
DjangoTelegramBot.dispatchers.append(updater.dispatcher)
DjangoTelegramBot.__used_tokens.add(token)
except InvalidToken:
logger.error('Invalid Token : {}'.format(token))
return
except TelegramError as er:
logger.error('Error : {}'.format(repr(er)))
return
DjangoTelegramBot.bots.append(bot)
DjangoTelegramBot.bot_tokens.append(token)
DjangoTelegramBot.bot_usernames.append(bot.username)
logger.debug('Telegram Bot <{}> set as default bot'.format(
DjangoTelegramBot.bots[0].username))
def module_imported(module_name, method_name, execute):
try:
m = importlib.import_module(module_name)
if execute and hasattr(m, method_name):
logger.debug('Run {}.{}()'.format(module_name,
method_name))
getattr(m, method_name)()
else:
logger.debug('Run {}'.format(module_name))
except ImportError as er:
if settings.DJANGO_TELEGRAMBOT.get('STRICT_INIT'):
raise er
else:
logger.error('{} : {}'.format(module_name, repr(er)))
return False
return True
# import telegram bot handlers for all INSTALLED_APPS
for app_config in apps.get_app_configs():
if module_has_submodule(app_config.module,
TELEGRAM_BOT_MODULE_NAME):
module_name = '%s.%s' % (app_config.name,
TELEGRAM_BOT_MODULE_NAME)
if module_imported(module_name, 'main', True):
logger.info('Loaded {}'.format(module_name))
num_bots = len(DjangoTelegramBot.__used_tokens)
if self.mode == POLLING_MODE and num_bots > 0:
logger.info(
'Please manually start polling update for {0} bot{1}. Run command{1}:'
.format(num_bots, 's' if num_bots > 1 else ''))
for token in DjangoTelegramBot.__used_tokens:
updater = DjangoTelegramBot.get_updater(bot_id=token)
logger.info('python manage.py botpolling --username={}'.format(
updater.bot.username))
class Updater(object):
"""
This class, which employs the :class:`telegram.ext.Dispatcher`, provides a frontend to
:class:`telegram.Bot` to the programmer, so they can focus on coding the bot. Its purpose is to
receive the updates from Telegram and to deliver them to said dispatcher. It also runs in a
separate thread, so the user can interact with the bot, for example on the command line. The
dispatcher supports handlers for different kinds of data: Updates from Telegram, basic text
commands and even arbitrary types. The updater can be started as a polling service or, for
production, use a webhook to receive updates. This is achieved using the WebhookServer and
WebhookHandler classes.
Attributes:
bot (:class:`telegram.Bot`): The bot used with this Updater.
user_sig_handler (:obj:`signal`): signals the updater will respond to.
update_queue (:obj:`Queue`): Queue for the updates.
job_queue (:class:`telegram.ext.JobQueue`): Jobqueue for the updater.
dispatcher (:class:`telegram.ext.Dispatcher`): Dispatcher that handles the updates and
dispatches them to the handlers.
running (:obj:`bool`): Indicates if the updater is running.
Args:
token (:obj:`str`, optional): The bot's token given by the @BotFather.
base_url (:obj:`str`, optional): Base_url for the bot.
workers (:obj:`int`, optional): Amount of threads in the thread pool for functions
decorated with ``@run_async``.
bot (:class:`telegram.Bot`, optional): A pre-initialized bot instance. If a pre-initialized
bot is used, it is the user's responsibility to create it using a `Request`
instance with a large enough connection pool.
user_sig_handler (:obj:`function`, optional): Takes ``signum, frame`` as positional
arguments. This will be called when a signal is received, defaults are (SIGINT,
SIGTERM, SIGABRT) setable with :attr:`idle`.
request_kwargs (:obj:`dict`, optional): Keyword args to control the creation of a request
object (ignored if `bot` argument is used).
Note:
You must supply either a :attr:`bot` or a :attr:`token` argument.
Raises:
ValueError: If both :attr:`token` and :attr:`bot` are passed or none of them.
"""
_request = None
def __init__(self,
token=None,
base_url=None,
workers=4,
bot=None,
user_sig_handler=None,
request_kwargs=None):
if (token is None) and (bot is None):
raise ValueError('`token` or `bot` must be passed')
if (token is not None) and (bot is not None):
raise ValueError('`token` and `bot` are mutually exclusive')
self.logger = logging.getLogger(__name__)
con_pool_size = workers + 4
if bot is not None:
self.bot = bot
if bot.request.con_pool_size < con_pool_size:
self.logger.warning(
'Connection pool of Request object is smaller than optimal value (%s)',
con_pool_size)
else:
# we need a connection pool the size of:
# * for each of the workers
# * 1 for Dispatcher
# * 1 for polling Updater (even if webhook is used, we can spare a connection)
# * 1 for JobQueue
# * 1 for main thread
if request_kwargs is None:
request_kwargs = {}
if 'con_pool_size' not in request_kwargs:
request_kwargs['con_pool_size'] = con_pool_size
self._request = Request(**request_kwargs)
self.bot = Bot(token, base_url, request=self._request)
self.user_sig_handler = user_sig_handler
self.update_queue = Queue()
self.job_queue = JobQueue(self.bot)
self.__exception_event = Event()
self.dispatcher = Dispatcher(
self.bot,
self.update_queue,
job_queue=self.job_queue,
workers=workers,
exception_event=self.__exception_event)
self.last_update_id = 0
self.running = False
self.is_idle = False
self.httpd = None
self.__lock = Lock()
self.__threads = []
def _init_thread(self, target, name, *args, **kwargs):
thr = Thread(target=self._thread_wrapper, name=name, args=(target,) + args, kwargs=kwargs)
thr.start()
self.__threads.append(thr)
def _thread_wrapper(self, target, *args, **kwargs):
thr_name = current_thread().name
self.logger.debug('{0} - started'.format(thr_name))
try:
target(*args, **kwargs)
except Exception:
self.__exception_event.set()
self.logger.exception('unhandled exception')
raise
self.logger.debug('{0} - ended'.format(thr_name))
def start_polling(self,
poll_interval=0.0,
timeout=10,
network_delay=None,
clean=False,
bootstrap_retries=0,
read_latency=2.,
allowed_updates=None):
"""Starts polling updates from Telegram.
Args:
poll_interval (:obj:`float`, optional): Time to wait between polling updates from
Telegram in seconds. Default is 0.0.
timeout (:obj:`float`, optional): Passed to :attr:`telegram.Bot.get_updates`.
clean (:obj:`bool`, optional): Whether to clean any pending updates on Telegram servers
before actually starting to poll. Default is False.
bootstrap_retries (:obj:`int`, optional): Whether the bootstrapping phase of the
`Updater` will retry on failures on the Telegram server.
* < 0 - retry indefinitely
* 0 - no retries (default)
* > 0 - retry up to X times
allowed_updates (List[:obj:`str`], optional): Passed to
:attr:`telegram.Bot.get_updates`.
read_latency (:obj:`float` | :obj:`int`, optional): Grace time in seconds for receiving
the reply from server. Will be added to the `timeout` value and used as the read
timeout from server (Default: 2).
network_delay: Deprecated. Will be honoured as :attr:`read_latency` for a while but
will be removed in the future.
Returns:
:obj:`Queue`: The update queue that can be filled from the main thread.
"""
if network_delay is not None:
warnings.warn('network_delay is deprecated, use read_latency instead')
read_latency = network_delay
with self.__lock:
if not self.running:
self.running = True
# Create & start threads
self.job_queue.start()
self._init_thread(self.dispatcher.start, "dispatcher")
self._init_thread(self._start_polling, "updater", poll_interval, timeout,
read_latency, bootstrap_retries, clean, allowed_updates)
# Return the update queue so the main thread can insert updates
return self.update_queue
def start_webhook(self,
listen='127.0.0.1',
port=80,
url_path='',
cert=None,
key=None,
clean=False,
bootstrap_retries=0,
webhook_url=None,
allowed_updates=None):
"""
Starts a small http server to listen for updates via webhook. If cert
and key are not provided, the webhook will be started directly on
http://listen:port/url_path, so SSL can be handled by another
application. Else, the webhook will be started on
https://listen:port/url_path
Args:
listen (:obj:`str`, optional): IP-Address to listen on. Default ``127.0.0.1``.
port (:obj:`int`, optional): Port the bot should be listening on. Default ``80``.
url_path (:obj:`str`, optional): Path inside url.
cert (:obj:`str`, optional): Path to the SSL certificate file.
key (:obj:`str`, optional): Path to the SSL key file.
clean (:obj:`bool`, optional): Whether to clean any pending updates on Telegram servers
before actually starting the webhook. Default is ``False``.
bootstrap_retries (:obj:`int`, optional): Whether the bootstrapping phase of the
`Updater` will retry on failures on the Telegram server.
* < 0 - retry indefinitely
* 0 - no retries (default)
* > 0 - retry up to X times
webhook_url (:obj:`str`, optional): Explicitly specify the webhook url. Useful behind
NAT, reverse proxy, etc. Default is derived from `listen`, `port` & `url_path`.
allowed_updates (List[:obj:`str`], optional): Passed to
:attr:`telegram.Bot.set_webhook`.
Returns:
:obj:`Queue`: The update queue that can be filled from the main thread.
"""
with self.__lock:
if not self.running:
self.running = True
# Create & start threads
self.job_queue.start()
self._init_thread(self.dispatcher.start, "dispatcher"),
self._init_thread(self._start_webhook, "updater", listen, port, url_path, cert,
key, bootstrap_retries, clean, webhook_url, allowed_updates)
# Return the update queue so the main thread can insert updates
return self.update_queue
def _start_polling(self, poll_interval, timeout, read_latency, bootstrap_retries, clean,
allowed_updates):
# """
# Thread target of thread 'updater'. Runs in background, pulls
# updates from Telegram and inserts them in the update queue of the
# Dispatcher.
# """
cur_interval = poll_interval
self.logger.debug('Updater thread started')
self._bootstrap(bootstrap_retries, clean=clean, webhook_url='', allowed_updates=None)
while self.running:
try:
updates = self.bot.get_updates(
self.last_update_id,
timeout=timeout,
read_latency=read_latency,
allowed_updates=allowed_updates)
except RetryAfter as e:
self.logger.info(str(e))
cur_interval = 0.5 + e.retry_after
except TelegramError as te:
self.logger.error("Error while getting Updates: {0}".format(te))
# Put the error into the update queue and let the Dispatcher
# broadcast it
self.update_queue.put(te)
cur_interval = self._increase_poll_interval(cur_interval)
else:
if not self.running:
if len(updates) > 0:
self.logger.debug('Updates ignored and will be pulled '
'again on restart.')
break
if updates:
for update in updates:
self.update_queue.put(update)
self.last_update_id = updates[-1].update_id + 1
cur_interval = poll_interval
sleep(cur_interval)
@staticmethod
def _increase_poll_interval(current_interval):
# increase waiting times on subsequent errors up to 30secs
if current_interval == 0:
current_interval = 1
elif current_interval < 30:
current_interval += current_interval / 2
elif current_interval > 30:
current_interval = 30
return current_interval
def _start_webhook(self, listen, port, url_path, cert, key, bootstrap_retries, clean,
webhook_url, allowed_updates):
self.logger.debug('Updater thread started')
use_ssl = cert is not None and key is not None
if not url_path.startswith('/'):
url_path = '/{0}'.format(url_path)
# Create and start server
self.httpd = WebhookServer((listen, port), WebhookHandler, self.update_queue, url_path,
self.bot)
if use_ssl:
self._check_ssl_cert(cert, key)
# DO NOT CHANGE: Only set webhook if SSL is handled by library
if not webhook_url:
webhook_url = self._gen_webhook_url(listen, port, url_path)
self._bootstrap(
max_retries=bootstrap_retries,
clean=clean,
webhook_url=webhook_url,
cert=open(cert, 'rb'),
allowed_updates=allowed_updates)
elif clean:
self.logger.warning("cleaning updates is not supported if "
"SSL-termination happens elsewhere; skipping")
self.httpd.serve_forever(poll_interval=1)
def _check_ssl_cert(self, cert, key):
# Check SSL-Certificate with openssl, if possible
try:
exit_code = subprocess.call(
["openssl", "x509", "-text", "-noout", "-in", cert],
stdout=open(os.devnull, 'wb'),
stderr=subprocess.STDOUT)
except OSError:
exit_code = 0
if exit_code is 0:
try:
self.httpd.socket = ssl.wrap_socket(
self.httpd.socket, certfile=cert, keyfile=key, server_side=True)
except ssl.SSLError as error:
self.logger.exception('Failed to init SSL socket')
raise TelegramError(str(error))
else:
raise TelegramError('SSL Certificate invalid')
@staticmethod
def _gen_webhook_url(listen, port, url_path):
return 'https://{listen}:{port}{path}'.format(listen=listen, port=port, path=url_path)
def _bootstrap(self, max_retries, clean, webhook_url, allowed_updates, cert=None):
retries = 0
while 1:
try:
if clean:
# Disable webhook for cleaning
self.bot.delete_webhook()
self._clean_updates()
sleep(1)
self.bot.set_webhook(
url=webhook_url, certificate=cert, allowed_updates=allowed_updates)
except (Unauthorized, InvalidToken):
raise
except TelegramError:
msg = 'error in bootstrap phase; try={0} max_retries={1}'.format(retries,
max_retries)
if max_retries < 0 or retries < max_retries:
self.logger.warning(msg)
retries += 1
else:
self.logger.exception(msg)
raise
else:
break
sleep(1)
def _clean_updates(self):
self.logger.debug('Cleaning updates from Telegram server')
updates = self.bot.get_updates()
while updates:
updates = self.bot.get_updates(updates[-1].update_id + 1)
def stop(self):
"""Stops the polling/webhook thread, the dispatcher and the job queue."""
self.job_queue.stop()
with self.__lock:
if self.running or self.dispatcher.has_running_threads:
self.logger.debug('Stopping Updater and Dispatcher...')
self.running = False
self._stop_httpd()
self._stop_dispatcher()
self._join_threads()
# Stop the Request instance only if it was created by the Updater
if self._request:
self._request.stop()
def _stop_httpd(self):
if self.httpd:
self.logger.debug('Waiting for current webhook connection to be '
'closed... Send a Telegram message to the bot to exit '
'immediately.')
self.httpd.shutdown()
self.httpd = None
def _stop_dispatcher(self):
self.logger.debug('Requesting Dispatcher to stop...')
self.dispatcher.stop()
def _join_threads(self):
for thr in self.__threads:
self.logger.debug('Waiting for {0} thread to end'.format(thr.name))
thr.join()
self.logger.debug('{0} thread has ended'.format(thr.name))
self.__threads = []
def signal_handler(self, signum, frame):
self.is_idle = False
if self.running:
self.stop()
if self.user_sig_handler:
self.user_sig_handler(signum, frame)
else:
self.logger.warning('Exiting immediately!')
import os
os._exit(1)
def idle(self, stop_signals=(SIGINT, SIGTERM, SIGABRT)):
"""Blocks until one of the signals are received and stops the updater.
Args:
stop_signals (:obj:`iterable`): Iterable containing signals from the signal module that
should be subscribed to. Updater.stop() will be called on receiving one of those
signals. Defaults to (``SIGINT``, ``SIGTERM``, ``SIGABRT``).
"""
for sig in stop_signals:
signal(sig, self.signal_handler)
self.is_idle = True
while self.is_idle:
sleep(1)
from bot.handlers.Mutual_PR.Telegram import categories
from bot.handlers.Mutual_PR.Instagram import categories_inst
from bot.handlers.Mutual_PR.Telegram.pr_menu import pr_menu
from bot.handlers.Mutual_PR.Instagram.pr_menu import pr_menu_inst
from bot.handlers.PersonalArea.SupportProject import support_project
from bot.handlers.PersonalArea.Feedback import feedback
from bot.handlers.Back import back_inline, back
from bot.handlers.Adminka.admin import (admin_menu, send_msg_menu, send_msg_text, send_msg, reply_to_admin,
send_reply_to_admin, delete_ad_menu, delete_ad_reason, delete_ads,
broadcast_menu, broadcast_text, broadcast, statistic)
from bot.handlers.MainMenu import MainMenu
API_TOKEN = '721609870:AAGBix6dGkIqjsA1nAY_4AtqAftYhTrN-Sc'
BOT = Bot(API_TOKEN)
DIS = Dispatcher(BOT, None, workers=0)
DIS.add_handler(CommandHandler('start', start))
Filter = Filters.text & Filters.private & BaseFilters.FilterBan() & BaseFilters.FilterRules()
# Adminka
DIS.add_handler(CommandHandler('admin', admin_menu))
DIS.add_handler(CallbackQueryHandler(send_msg_menu, pattern='^admin_send_msg$'))
DIS.add_handler(MessageHandler(Filter & BaseFilters.FilterAdminkaSendMsg(),
send_msg_text, pass_user_data=True))
DIS.add_handler(MessageHandler(Filter & BaseFilters.FilterAdminkaSendMsgText(),
send_msg, pass_user_data=True))
DIS.add_handler(CallbackQueryHandler(reply_to_admin, pattern='^admin_msg_reply$'))
DIS.add_handler(MessageHandler(Filter & BaseFilters.FilterAdminkaReplyToAmin(),
send_reply_to_admin))
DIS.add_handler(CallbackQueryHandler(delete_ad_menu, pattern='^admin_delete_ad$'))
DIS.add_handler(MessageHandler(Filter & BaseFilters.FilterAdminkaDeleteAd(),
def ready(self):
if DjangoTelegramBot.ready_run:
return
DjangoTelegramBot.ready_run = True
self.mode = WEBHOOK_MODE
if settings.DJANGO_TELEGRAMBOT.get('MODE', 'WEBHOOK') == 'POLLING':
self.mode = POLLING_MODE
modes = ['WEBHOOK', 'POLLING']
logger.info('Django Telegram Bot <{} mode>'.format(modes[self.mode]))
bots_list = settings.DJANGO_TELEGRAMBOT.get('BOTS', [])
if self.mode == WEBHOOK_MODE:
webhook_site = settings.DJANGO_TELEGRAMBOT.get(
'WEBHOOK_SITE', None)
if not webhook_site:
logger.warn(
'Required TELEGRAM_WEBHOOK_SITE missing in settings')
return
if webhook_site.endswith("/"):
webhook_site = webhook_site[:-1]
webhook_base = settings.DJANGO_TELEGRAMBOT.get(
'WEBHOOK_PREFIX', '/')
if webhook_base.startswith("/"):
webhook_base = webhook_base[1:]
if webhook_base.endswith("/"):
webhook_base = webhook_base[:-1]
cert = settings.DJANGO_TELEGRAMBOT.get('WEBHOOK_CERTIFICATE', None)
certificate = None
if cert and os.path.exists(cert):
logger.info('WEBHOOK_CERTIFICATE found in {}'.format(cert))
certificate = open(cert, 'rb')
elif cert:
logger.error(
'WEBHOOK_CERTIFICATE not found in {} '.format(cert))
for b in bots_list:
token = b.get('TOKEN', None)
context = b.get('CONTEXT', False)
if not token:
break
allowed_updates = b.get('ALLOWED_UPDATES', None)
timeout = b.get('TIMEOUT', None)
proxy = b.get('PROXY', None)
if self.mode == WEBHOOK_MODE:
try:
if b.get('MESSAGEQUEUE_ENABLED', False):
q = mq.MessageQueue(
all_burst_limit=b.get(
'MESSAGEQUEUE_ALL_BURST_LIMIT', 29),
all_time_limit_ms=b.get(
'MESSAGEQUEUE_ALL_TIME_LIMIT_MS', 1024))
if proxy:
request = Request(
proxy_url=proxy['proxy_url'],
urllib3_proxy_kwargs=proxy[
'urllib3_proxy_kwargs'],
con_pool_size=b.get(
'MESSAGEQUEUE_REQUEST_CON_POOL_SIZE', 8))
else:
request = Request(con_pool_size=b.get(
'MESSAGEQUEUE_REQUEST_CON_POOL_SIZE', 8))
bot = MQBot(token, request=request, mqueue=q)
else:
request = None
if proxy:
request = Request(proxy_url=proxy['proxy_url'],
urllib3_proxy_kwargs=proxy[
'urllib3_proxy_kwargs'])
bot = telegram.Bot(token=token, request=request)
DjangoTelegramBot.dispatchers.append(
Dispatcher(bot, None, workers=0, use_context=context))
hookurl = '{}/{}/{}/'.format(webhook_site, webhook_base,
token)
max_connections = b.get('WEBHOOK_MAX_CONNECTIONS', 40)
setted = bot.setWebhook(hookurl,
certificate=certificate,
timeout=timeout,
max_connections=max_connections,
allowed_updates=allowed_updates)
webhook_info = bot.getWebhookInfo()
real_allowed = webhook_info.allowed_updates if webhook_info.allowed_updates else [
"ALL"
]
bot.more_info = webhook_info
logger.info(
'Telegram Bot <{}> setting webhook [ {} ] max connections:{} allowed updates:{} pending updates:{} : {}'
.format(bot.username, webhook_info.url,
webhook_info.max_connections, real_allowed,
webhook_info.pending_update_count, setted))
except InvalidToken:
logger.error('Invalid Token : {}'.format(token))
return
except RetryAfter as er:
logger.debug(
'Error: "{}". Will retry in {} seconds'.format(
er.message, er.retry_after))
sleep(er.retry_after)
self.ready()
except TelegramError as er:
logger.error('Error: "{}"'.format(er.message))
return
else:
try:
updater = Updater(token=token,
request_kwargs=proxy,
use_context=context)
bot = updater.bot
bot.delete_webhook()
DjangoTelegramBot.updaters.append(updater)
DjangoTelegramBot.dispatchers.append(updater.dispatcher)
DjangoTelegramBot.__used_tokens.add(token)
except InvalidToken:
logger.error('Invalid Token : {}'.format(token))
return
except RetryAfter as er:
logger.debug(
'Error: "{}". Will retry in {} seconds'.format(
er.message, er.retry_after))
sleep(er.retry_after)
self.ready()
except TelegramError as er:
logger.error('Error: "{}"'.format(er.message))
return
DjangoTelegramBot.bots.append(bot)
DjangoTelegramBot.bot_tokens.append(token)
DjangoTelegramBot.bot_usernames.append(bot.username)
logger.debug('Telegram Bot <{}> set as default bot'.format(
DjangoTelegramBot.bots[0].username))
def module_imported(module_name, method_name, execute):
try:
m = importlib.import_module(module_name)
if execute and hasattr(m, method_name):
logger.debug('Run {}.{}()'.format(module_name,
method_name))
getattr(m, method_name)()
else:
logger.debug('Run {}'.format(module_name))
except ImportError as er:
if settings.DJANGO_TELEGRAMBOT.get('STRICT_INIT'):
raise er
else:
logger.error('{} : {}'.format(module_name, repr(er)))
return False
return True
# import telegram bot handlers for all INSTALLED_APPS
for app_config in apps.get_app_configs():
if module_has_submodule(app_config.module,
TELEGRAM_BOT_MODULE_NAME):
module_name = '%s.%s' % (app_config.name,
TELEGRAM_BOT_MODULE_NAME)
if module_imported(module_name, 'main', True):
logger.info('Loaded {}'.format(module_name))
num_bots = len(DjangoTelegramBot.__used_tokens)
if self.mode == POLLING_MODE and num_bots > 0:
logger.info(
'Please manually start polling update for {0} bot{1}. Run command{1}:'
.format(num_bots, 's' if num_bots > 1 else ''))
for token in DjangoTelegramBot.__used_tokens:
updater = DjangoTelegramBot.get_updater(bot_id=token)
logger.info('python manage.py botpolling --username={}'.format(
updater.bot.username))
class Updater(object):
"""
This class, which employs the Dispatcher class, provides a frontend to
telegram.Bot to the programmer, so they can focus on coding the bot. Its
purpose is to receive the updates from Telegram and to deliver them to said
dispatcher. It also runs in a separate thread, so the user can interact
with the bot, for example on the command line. The dispatcher supports
handlers for different kinds of data: Updates from Telegram, basic text
commands and even arbitrary types.
The updater can be started as a polling service or, for production, use a
webhook to receive updates. This is achieved using the WebhookServer and
WebhookHandler classes.
Attributes:
Args:
token (Optional[str]): The bot's token given by the @BotFather
base_url (Optional[str]):
workers (Optional[int]): Amount of threads in the thread pool for
functions decorated with @run_async
bot (Optional[Bot]):
job_queue_tick_interval(Optional[float]): The interval the queue should
be checked for new tasks. Defaults to 1.0
Raises:
ValueError: If both `token` and `bot` are passed or none of them.
"""
def __init__(self,
token=None,
base_url=None,
workers=4,
bot=None,
job_queue_tick_interval=1.0):
if (token is None) and (bot is None):
raise ValueError('`token` or `bot` must be passed')
if (token is not None) and (bot is not None):
raise ValueError('`token` and `bot` are mutually exclusive')
if bot is not None:
self.bot = bot
else:
self.bot = Bot(token, base_url)
self.update_queue = Queue()
self.job_queue = JobQueue(self.bot, job_queue_tick_interval)
self.__exception_event = Event()
self.dispatcher = Dispatcher(self.bot, self.update_queue, workers, self.__exception_event)
self.last_update_id = 0
self.logger = logging.getLogger(__name__)
self.running = False
self.is_idle = False
self.httpd = None
self.__lock = Lock()
self.__threads = []
""":type: list[Thread]"""
def _init_thread(self, target, name, *args, **kwargs):
thr = Thread(target=self._thread_wrapper, name=name, args=(target,) + args, kwargs=kwargs)
thr.start()
self.__threads.append(thr)
def _thread_wrapper(self, target, *args, **kwargs):
thr_name = current_thread().name
self.logger.debug('{0} - started'.format(thr_name))
try:
target(*args, **kwargs)
except Exception:
self.__exception_event.set()
self.logger.exception('unhandled exception')
raise
self.logger.debug('{0} - ended'.format(thr_name))
def start_polling(self,
poll_interval=0.0,
timeout=10,
network_delay=2,
clean=False,
bootstrap_retries=0):
"""
Starts polling updates from Telegram.
Args:
poll_interval (Optional[float]): Time to wait between polling
updates from Telegram in seconds. Default is 0.0
timeout (Optional[float]): Passed to Bot.getUpdates
network_delay (Optional[float]): Passed to Bot.getUpdates
clean (Optional[bool]): Whether to clean any pending updates on
Telegram servers before actually starting to poll. Default is
False.
bootstrap_retries (Optional[int[): Whether the bootstrapping phase
of the `Updater` will retry on failures on the Telegram server.
| < 0 - retry indefinitely
| 0 - no retries (default)
| > 0 - retry up to X times
Returns:
Queue: The update queue that can be filled from the main thread
"""
with self.__lock:
if not self.running:
self.running = True
# Create & start threads
self._init_thread(self.dispatcher.start, "dispatcher")
self._init_thread(self._start_polling, "updater", poll_interval, timeout,
network_delay, bootstrap_retries, clean)
# Return the update queue so the main thread can insert updates
return self.update_queue
def start_webhook(self,
listen='127.0.0.1',
port=80,
url_path='',
cert=None,
key=None,
clean=False,
bootstrap_retries=0,
webhook_url=None):
"""
Starts a small http server to listen for updates via webhook. If cert
and key are not provided, the webhook will be started directly on
http://listen:port/url_path, so SSL can be handled by another
application. Else, the webhook will be started on
https://listen:port/url_path
Args:
listen (Optional[str]): IP-Address to listen on
port (Optional[int]): Port the bot should be listening on
url_path (Optional[str]): Path inside url
cert (Optional[str]): Path to the SSL certificate file
key (Optional[str]): Path to the SSL key file
clean (Optional[bool]): Whether to clean any pending updates on
Telegram servers before actually starting the webhook. Default
is False.
bootstrap_retries (Optional[int[): Whether the bootstrapping phase
of the `Updater` will retry on failures on the Telegram server.
| < 0 - retry indefinitely
| 0 - no retries (default)
| > 0 - retry up to X times
webhook_url (Optional[str]): Explicitly specifiy the webhook url.
Useful behind NAT, reverse proxy, etc. Default is derived from
`listen`, `port` & `url_path`.
Returns:
Queue: The update queue that can be filled from the main thread
"""
with self.__lock:
if not self.running:
self.running = True
# Create & start threads
self._init_thread(self.dispatcher.start, "dispatcher"),
self._init_thread(self._start_webhook, "updater", listen, port, url_path, cert,
key, bootstrap_retries, clean, webhook_url)
# Return the update queue so the main thread can insert updates
return self.update_queue
def _start_polling(self, poll_interval, timeout, network_delay, bootstrap_retries, clean):
"""
Thread target of thread 'updater'. Runs in background, pulls
updates from Telegram and inserts them in the update queue of the
Dispatcher.
"""
cur_interval = poll_interval
self.logger.debug('Updater thread started')
self._bootstrap(bootstrap_retries, clean=clean, webhook_url='')
while self.running:
try:
updates = self.bot.getUpdates(self.last_update_id,
timeout=timeout,
network_delay=network_delay)
except TelegramError as te:
self.logger.error("Error while getting Updates: {0}".format(te))
# Put the error into the update queue and let the Dispatcher
# broadcast it
self.update_queue.put(te)
cur_interval = self._increase_poll_interval(cur_interval)
else:
if not self.running:
if len(updates) > 0:
self.logger.debug('Updates ignored and will be pulled '
'again on restart.')
break
if updates:
for update in updates:
self.update_queue.put(update)
self.last_update_id = updates[-1].update_id + 1
cur_interval = poll_interval
sleep(cur_interval)
@staticmethod
def _increase_poll_interval(current_interval):
# increase waiting times on subsequent errors up to 30secs
if current_interval == 0:
current_interval = 1
elif current_interval < 30:
current_interval += current_interval / 2
elif current_interval > 30:
current_interval = 30
return current_interval
def _start_webhook(self, listen, port, url_path, cert, key, bootstrap_retries, clean,
webhook_url):
self.logger.debug('Updater thread started')
use_ssl = cert is not None and key is not None
if not url_path.startswith('/'):
url_path = '/{0}'.format(url_path)
# Create and start server
self.httpd = WebhookServer((listen, port), WebhookHandler, self.update_queue, url_path)
if use_ssl:
self._check_ssl_cert(cert, key)
# DO NOT CHANGE: Only set webhook if SSL is handled by library
if not webhook_url:
webhook_url = self._gen_webhook_url(listen, port, url_path)
self._bootstrap(max_retries=bootstrap_retries,
clean=clean,
webhook_url=webhook_url,
cert=open(cert, 'rb'))
elif clean:
self.logger.warning("cleaning updates is not supported if "
"SSL-termination happens elsewhere; skipping")
self.httpd.serve_forever(poll_interval=1)
def _check_ssl_cert(self, cert, key):
# Check SSL-Certificate with openssl, if possible
try:
exit_code = subprocess.call(
["openssl", "x509", "-text", "-noout", "-in", cert],
stdout=open(os.devnull, 'wb'),
stderr=subprocess.STDOUT)
except OSError:
exit_code = 0
if exit_code is 0:
try:
self.httpd.socket = ssl.wrap_socket(self.httpd.socket,
certfile=cert,
keyfile=key,
server_side=True)
except ssl.SSLError as error:
self.logger.exception('Failed to init SSL socket')
raise TelegramError(str(error))
else:
raise TelegramError('SSL Certificate invalid')
@staticmethod
def _gen_webhook_url(listen, port, url_path):
return 'https://{listen}:{port}{path}'.format(listen=listen, port=port, path=url_path)
def _bootstrap(self, max_retries, clean, webhook_url, cert=None):
retries = 0
while True:
try:
if clean:
# Disable webhook for cleaning
self.bot.setWebhook(webhook_url='')
self._clean_updates()
self.bot.setWebhook(webhook_url=webhook_url, certificate=cert)
except (Unauthorized, InvalidToken):
raise
except TelegramError:
msg = 'error in bootstrap phase; try={0} max_retries={1}'\
.format(retries, max_retries)
if max_retries < 0 or retries < max_retries:
self.logger.warning(msg)
retries += 1
else:
self.logger.exception(msg)
raise
else:
break
sleep(1)
def _clean_updates(self):
self.logger.debug('Cleaning updates from Telegram server')
updates = self.bot.getUpdates()
while updates:
updates = self.bot.getUpdates(updates[-1].update_id + 1)
def stop(self):
"""
Stops the polling/webhook thread, the dispatcher and the job queue
"""
self.job_queue.stop()
with self.__lock:
if self.running:
self.logger.debug('Stopping Updater and Dispatcher...')
self.running = False
self._stop_httpd()
self._stop_dispatcher()
self._join_threads()
# async threads must be join()ed only after the dispatcher
# thread was joined, otherwise we can still have new async
# threads dispatched
self._join_async_threads()
def _stop_httpd(self):
if self.httpd:
self.logger.debug('Waiting for current webhook connection to be '
'closed... Send a Telegram message to the bot to exit '
'immediately.')
self.httpd.shutdown()
self.httpd = None
def _stop_dispatcher(self):
self.logger.debug('Requesting Dispatcher to stop...')
self.dispatcher.stop()
def _join_async_threads(self):
with dispatcher.async_lock:
threads = list(dispatcher.async_threads)
total = len(threads)
for i, thr in enumerate(threads):
self.logger.debug('Waiting for async thread {0}/{1} to end'.format(i, total))
thr.join()
self.logger.debug('async thread {0}/{1} has ended'.format(i, total))
def _join_threads(self):
for thr in self.__threads:
self.logger.debug('Waiting for {0} thread to end'.format(thr.name))
thr.join()
self.logger.debug('{0} thread has ended'.format(thr.name))
self.__threads = []
def signal_handler(self, signum, frame):
self.is_idle = False
if self.running:
self.stop()
else:
self.logger.warning('Exiting immediately!')
import os
os._exit(1)
def idle(self, stop_signals=(SIGINT, SIGTERM, SIGABRT)):
"""
Blocks until one of the signals are received and stops the updater
Args:
stop_signals: Iterable containing signals from the signal module
that should be subscribed to. Updater.stop() will be called on
receiving one of those signals. Defaults to (SIGINT, SIGTERM,
SIGABRT)
"""
for sig in stop_signals:
signal(sig, self.signal_handler)
self.is_idle = True
while self.is_idle:
sleep(1)
def test_mutual_exclude_use_context_dispatcher(self):
dispatcher = Dispatcher(None, None)
use_context = not dispatcher.use_context
with pytest.raises(ValueError):
Updater(dispatcher=dispatcher, use_context=use_context)
'https://python-telegram-bot.readthedocs.io/en/stable/index.html'),
InlineKeyboardButton('Google 首頁', url='https://www.google.com.tw/')
]])
# 需要有4個參數值 1.聊天室的id 2.發送訊息的標題 3. 回覆訊息的id, 4 回覆的內容
bot.send_message(update.message.chat.id,
'網站連結',
reply_to_message_id=update.message.message_id,
reply_markup=reply_markup)
def echo(bot, update):
"""
簡稱自動回話，也就是你打什麼，他就回你什麼
"""
text = update.message.text # 取得對話的內容
update.message.reply_text(text) # 回覆你輸入的內容
# 這是一個呼叫bot的方式，但跟之前寫的呼叫bot的有作用，至於這兩種呼叫bot有什麼差別，我還要再查查看
dispatcher = Dispatcher(bot, None)
start_handler = CommandHandler('start', start) # 對bot輸入 /start 會執行這塊
echo_handler = MessageHandler(Filters.text, echo) # 當你輸入 hi 機器人就會回你 hi
dispatcher.add_handler(start_handler) # 將剛剛的 /start功能加入到你的 bot內
dispatcher.add_handler(echo_handler) # 也將剛剛自動回覆的功能加到你的 bot內
if __name__ == "__main__":
# Running server
app.run(debug=True)
def get_bot_dispatcher():
bot = get_bot()
dispatcher = Dispatcher(bot, None, workers=0, use_context=True)
def start(update, context):
sub = get_subscription(update.message.chat_id)
context.bot.send_message(chat_id=update.message.chat_id,
text="Welkom bij Covid19 NL nieuws bot! "
"Gebruik /help voor informatie voor gebruik")
def caps(update, context):
text_caps = ' '.join(context.args).upper()
context.bot.send_message(chat_id=update.message.chat_id,
text=text_caps)
def tuewarning(update, context):
sub = get_subscription(update.message.chat_id)
if len(context.args) < 1:
context.bot.send_message(chat_id=update.message.chat_id,
text="vereist argument, zie /help")
return
try:
arg = bool(int(context.args[0]))
except:
context.bot.send_message(chat_id=update.message.chat_id,
text="verkeerd argument, zie /help")
return
sub.tuewarning = arg
sub.save()
context.bot.send_message(chat_id=update.message.chat_id,
text="TU/e push bericht ge{}activeerd".format(
"de" if not arg else ""))
def top20warning(update, context):
sub = get_subscription(update.message.chat_id)
if len(context.args) < 1:
context.bot.send_message(chat_id=update.message.chat_id,
text="vereist argument, zie /help")
return
try:
arg = bool(int(context.args[0]))
except:
context.bot.send_message(chat_id=update.message.chat_id,
text="verkeerd argument, zie /help")
return
sub.top20warning = arg
sub.save()
context.bot.send_message(
chat_id=update.message.chat_id,
text="top20 update bericht ge{}activeerd".format(
"de" if not arg else ""))
def subtocity(update, context):
sub = get_subscription(update.message.chat_id)
if len(context.args) < 1:
context.bot.send_message(chat_id=update.message.chat_id,
text="Vereist argument, zie /help")
return
city = context.args[0]
try:
city = int(city)
if city >= len(validcities()) or city < 0:
context.bot.send_message(
chat_id=update.message.chat_id,
text="Ongeldig nummer, zie /gemeenten")
return
city = validcities()[city]
except ValueError:
if city not in validcities():
context.bot.send_message(
chat_id=update.message.chat_id,
text="Ongeldige gemeente, zie /gemeenten")
return
existing = set(sub.citieswarning.split(';'))
existing.add(city)
sub.citieswarning = ";".join(existing)
sub.save()
context.bot.send_message(chat_id=update.message.chat_id,
text="Subscription geupdate")
def unsubtocity(update, context):
sub = get_subscription(update.message.chat_id)
if len(context.args) < 1:
context.bot.send_message(chat_id=update.message.chat_id,
text="Vereist argument, zie /help")
return
city = context.args[0]
try:
city = int(city)
if city >= len(validcities()) or city < 0:
context.bot.send_message(
chat_id=update.message.chat_id,
text="Ongeldig nummer, zie /gemeenten")
return
city = validcities()[city]
except ValueError:
if city not in validcities():
context.bot.send_message(
chat_id=update.message.chat_id,
text="Ongeldige gemeente, zie /gemeenten")
return
existing = set(sub.citieswarning.split(';'))
try:
existing.remove(city)
except KeyError:
context.bot.send_message(
chat_id=update.message.chat_id,
text="Deze stad stond niet in subscriptions")
return
sub.citieswarning = ";".join(existing)
sub.save()
context.bot.send_message(chat_id=update.message.chat_id,
text="Subscription geupdate")
def cities(update, context):
sub = get_subscription(update.message.chat_id)
# context.bot.send_message(chat_id=update.message.chat_id, text=str(validcities()))
context.bot.send_message(
chat_id=update.message.chat_id,
text=
"Lijst van gemeenten met index [klik hier](https://covid19bot.boerman.dev/telegram/cities/NL/)",
parse_mode='MarkdownV2')
def status(update, context):
sub = get_subscription(update.message.chat_id)
cities = sub.citieswarning.split(';')
msg = "Laatste RIVM data:\n ``` " + get_latest_rivm_datatable(
cities) + " ``` "
context.bot.send_message(chat_id=update.message.chat_id,
text=msg,
parse_mode='MarkdownV2')
def top20(update, context):
msg = "top 20 gemeenten:\n ``` " + get_top20_datatable() + " ``` "
context.bot.send_message(chat_id=update.message.chat_id,
text=msg,
parse_mode='MarkdownV2')
def help(update, context):
helpmessage = """/help dit bericht
/tuewarning <0/1> - krijg bericht als TU/e nieuwe update pushed
/top20warning <0/1> - krijg een update van top20 van gemeenten zodra RIVM dat pushed
/subscribestad stad - krijg een update van stand van corona gevallen zodra het RIVM dat pushed, mag ook getal zijn in index
/unsubscribestad stad - zet stad update uit, mag ook getal zijn in index
/status - krijg een een stand van zaken van je geselecteerde steden volgens laatste data van RIVM
/gemeenten - lijst van alle ondersteunde gemeenten
/top20 - de top 20 van nederlandse gemeente met actieve corona gevallen
"""
context.bot.send_message(chat_id=update.message.chat_id,
text=helpmessage)
dispatcher.add_handler(CommandHandler('start', start))
dispatcher.add_handler(CommandHandler('caps', caps))
dispatcher.add_handler(CommandHandler('help', help))
dispatcher.add_handler(CommandHandler('tuewarning', tuewarning))
dispatcher.add_handler(CommandHandler('subscribestad', subtocity))
dispatcher.add_handler(CommandHandler('unsubscribestad', unsubtocity))
dispatcher.add_handler(CommandHandler('gemeenten', cities))
dispatcher.add_handler(CommandHandler('status', status))
dispatcher.add_handler(CommandHandler('top20', top20))
dispatcher.add_handler(CommandHandler('top20warning', top20warning))
fh = logging.FileHandler('telegram.log')
fh.setLevel(logging.INFO)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fh.setFormatter(formatter)
for name in [
name for name in logging.root.manager.loggerDict
if 'telegram' in name
]:
logger = logging.getLogger(name)
logger.setLevel(logging.INFO)
logger.addHandler(fh)
return dispatcher
def test_mutual_exclude_persistence_dispatcher(self):
dispatcher = Dispatcher(None, None)
persistence = DictPersistence()
with pytest.raises(ValueError):
Updater(dispatcher=dispatcher, persistence=persistence)
reply_to_message_id=update.message.message_id,
disable_web_page_preview=False)
return handler
if is_dev:
updater = Updater(token=bot_token, use_context=True)
dispatcher = updater.dispatcher
else:
# Create bot, update queue and dispatcher instances
bot = Bot(bot_token)
update_queue = Queue()
dispatcher = Dispatcher(bot, update_queue, use_context=True)
# Register handlers
dispatcher.add_handler(CommandHandler('help', abort_say_help))
dispatcher.add_handler(
CommandHandler('resolve',
handle_link_message(resolve=True),
filters=Filters.reply))
dispatcher.add_handler(
CommandHandler('resolve',
abort_say_no_reply_to_resolve,
filters=~Filters.reply))
dispatcher.add_handler(
MessageHandler(~Filters.text & ~Filters.command, abort_say_no_text))
dispatcher.add_handler(MessageHandler(Filters.all, handle_link_message(False)))
def test_mutual_exclude_workers_dispatcher(self):
dispatcher = Dispatcher(None, None)
with pytest.raises(ValueError):
Updater(dispatcher=dispatcher, workers=8)
result_text = t_heads[0][0]+' 目前天氣概況 : \n\n'+t_bodys[0][0]+'\n'
for i in range(1,len(t_heads[0])):
result_text += '{0} : {1}\n'.format(t_heads[0][i],t_bodys[0][i])
for i in range(0,len(t_heads[2])):
result_text += '{0} : {1}\n'.format(t_heads[2][i],t_nums[1][i])
update.callback_query.edit_message_text(result_text)
#New a dispatcher for bot
dispatcher = Dispatcher(bot,None)
#Add handler for handing message,there are many kinds of message,For this handler,it particular handle text
#message
dispatcher.add_handler(MessageHandler(Filters.text,replay_handler))
dispatcher.add_handler(CommandHandler('start',start))
dispatcher.add_handler(CallbackQueryHandler(result))
if __name__ == '__main__':
#Running server
#app.debug = True
app.run()