def __init__(self, *args, **kwargs):
"""
:param args: Must have at least a token.
:param kwargs:
"""
debug = False
if 'debug' in kwargs:
debug = kwargs['debug']
del kwargs['debug']
apihelper.ENABLE_MIDDLEWARE = True
super(Bot, self).__init__(*args, **kwargs)
if debug:
logger.setLevel(logging.DEBUG)
self.__subscriptions = []
def start_env(self):
"""
Seetup corresponding environment (dev or prod ) and star bot
"""
if "LOCAL" in os.environ.keys():
self.remove_webhook()
self.polling()
else:
# logger = log
logger.setLevel(logging.DEBUG)
server = Flask(__name__)
@server.route("/" + self.TOKEN, methods=["POST"])
def getMessage():
self.process_new_updates([
types.Update.de_json(request.stream.read().decode("utf-8"))
])
return "!", 200
self.remove_webhook()
self.set_webhook(url=f"{self.WEBHOOK_URL}/{self.TOKEN}")
server.run(host="0.0.0.0", port=os.environ.get("PORT", 80))
from telebot import TeleBot, types, logger
from app.user.decorators import register_required
from app.user.steps import start_register
from app.config import bot
logger.setLevel('INFO')
@bot.message_handler(commands=['help', 'start'])
@register_required
def get_text_messages(message):
print('Авторизация пройдена')
@bot.callback_query_handler(func=lambda call: call.data == 'register')
def callback_register(call):
start_register(call.message)
bot.enable_save_next_step_handlers(delay=2)
bot.load_next_step_handlers()
bot.infinity_polling(long_polling_timeout=10)
# -*- coding: utf-8 -*- from __future__ import unicode_literals import logging from telebot import TeleBot, logger from bot.bots_constants import release_token bot = TeleBot(release_token, threaded=False) logger.setLevel(logging.INFO) from bot import handlers
import logging
import hashlib
from sqlalchemy.orm import Session
from telebot import TeleBot, apihelper, logger
from telebot.types import Message as TelegramMessage, Chat as TelegramChat, InlineQueryResultCachedVoice
from app import config, db, repo, utils
from app.models import Chat, Voice
from app.messages import t
if config.BOT_PROXY:
apihelper.proxy = {"https": config.BOT_PROXY}
logger.setLevel(logging.ERROR)
bot = TeleBot(config.BOT_TOKEN)
@bot.message_handler(commands=["start", "help"])
@db.commit_session
def on_help_command(message: TelegramMessage, session=None):
chat = repo.chat_get_by_telegram_id(message.chat.id)
bot.send_message(chat.telegram_chat_id,
t("app.message.help"),
parse_mode="Markdown")
@bot.message_handler(commands=["cancel"])
@db.commit_session
def set_log_level(level):
""" Set a level of logging for used libraries. """
from telebot import logger as tg_logger
from vk import logger as vk_logger
tg_logger.setLevel(level)
vk_logger.setLevel(level)
import os
import json
import logging
from typing import Union, Callable, Optional
from telebot import TeleBot, types, logger
from telebot.apihelper import ApiException, ApiTelegramException
from sqlalchemy.exc import SQLAlchemyError
from .const import Choice
from .database import Messages, Users
from .languages import Language
from .utils import JSON_COMMON_DATA
logger.setLevel(logging.DEBUG)
CallbackDataType = Union[str, dict[str, JSON_COMMON_DATA]] # parsed json data
class ExtraTeleBot(TeleBot):
callback_query_handlers: dict[str, CallbackDataType]
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.callback_query_handlers = {}
self.pending_callback_ids = set()
def callback_query_handler(self, func: Callable[[types.CallbackQuery, Optional[CallbackDataType]], None], **kwargs):
return super().callback_query_handler(func, **kwargs)
from presenter.config.token import bot
from telebot import logger
@bot.message_handler(commands=['start', 'help'])
def answer(message):
bot.reply_to(
message,
"Если вы это читаете, для вас хорошие новости. Гениальный @DeMaximilianster и его..."
"партнёры? сотрудники? товарищи? помощники? @ProBeUs и @artm04 разрабатывают бота для игры в "
"великолепную игру 'Манчкин' прямо в Телеграме!")
@bot.message_handler(commands=['test', 'test_pic'])
def test(message):
bot.send_photo(
message.chat.id,
"AgADAgADrqsxG0Le0UgY3xAe2q1FZ7vrug8ABAEAAwIAA20AA5lRAwABFgQ")
logger.setLevel("DEBUG")
bot.polling()
# Тестовое изменение
def runbot():
import logging
from telebot import logger
logger.setLevel(logging.INFO)
bot.polling()
import logging
import os
from time import sleep
from flask import Flask, request
from telebot import types, logger as telebot_logger
from bot_handlers import bot
from config import BOT_TOKEN, HOST
telebot_logger.setLevel(logging.DEBUG)
server = Flask(__name__)
# if bot.get_webhook_info().url != f"https://{HOST}/{BOT_TOKEN}":
# bot.remove_webhook()
# sleep(2)
# bot.set_webhook(url=f"https://{HOST}/{BOT_TOKEN}", certificate=open('webhook_cert.pem', 'r'))
@server.route('/' + BOT_TOKEN, methods=['POST'])
def get_message():
bot.process_new_updates(
[types.Update.de_json(request.stream.read().decode('utf-8'))])
return 'OK', 200
# @server.route('/', methods=['GET'])
# def index():
# return 'Home page', 200
# from questgen import facts
import config
import telebot
import example
from telebot import logger
from telebot import types
logger.setLevel("INFO")
bot = telebot.TeleBot(config.token)
class User:
def __init__(self, name):
self.name = name
self._pointer = example.Pointer()
self._step = 0
def update_pointer(self, **pointer_fields):
self._pointer.update(**pointer_fields)
def get_pointer(self):
return self._pointer
def set_step(self, step):
self._step = step
def get_step(self):
return self._step
import logging from telebot import logger logger.setLevel(logging.WARNING)
def __init__(self):
self.bot = TeleBot(self.token)
logger.setLevel(logging.INFO) # Outputs debug messages to console.
self.db = DBManager()
self.handler = Handler(self.bot)
from storage import UserStorage
from settings import TELEGRAM_BOT_TOKEN, MAX_PASS_COUNT, MAX_PASS_LEN
from keyboards import settings_keyboard
from generator import generate_password, generate_only_numbers, generate_only_str, generate_str_and_numbers, \
generate_str_nums_and_spec
from html import escape
from tools import get_translated_message
from typing import Callable
import logging
import inline
# TODO: В докере сделать db.json вне контейнера
bot = TeleBot(TELEGRAM_BOT_TOKEN)
logger = telelogger
telelogger.setLevel(logging.INFO)
storj = UserStorage()
def send_settings_message(message: Message) -> None:
chat_id = message.from_user.id
bot.send_message(chat_id,
get_translated_message('settings_message', message),
reply_markup=settings_keyboard(
storj.get_or_create(chat_id),
message.from_user.language_code))
def edit_settings_message(chat_id: int, message_id: int,
lang_code: str) -> None:
bot.edit_message_text(get_translated_message('settings_message',
depth += 1
logger.opt(depth=depth, exception=record.exc_info).log(level, record.getMessage())
if not LOG_IS_SET:
handler = NotificationHandler(
"telegram",
defaults={
"token": NOTIFY_BOT_TOKEN,
"chat_id": NOTIFY_CHAT_ID
}
)
logger.add(handler, level=logging.WARNING)
bot_logger.setLevel(logging.WARNING)
bot_logger.removeHandler(bot_logger.handlers[0])
bot_logger.addHandler(InterceptHandler())
logger.add('./logs/{time:YYYY-MM-DD_HH-mm-ss}.log',
encoding='UTF-8',
backtrace=True,
diagnose=True,
rotation='10 MB',
compression='zip',
)
LOG_IS_SET = True
@require_GET
from django.conf import settings
from ..dbmodels.auth import ScheduleUser
import time
from telebot import AsyncTeleBot, logger, types
import logging
__author__ = "@schedulebase_bot"
logger.setLevel(settings.LOG_LEVEL)
bot = AsyncTeleBot(settings.TOKEN)
bot.threaded = True
settings.BOT = bot
bot.remove_webhook()
logging.info("Removed previous webhook")
time.sleep(1)
bot.set_webhook(url=f"{settings.DOMAIN}/bot/")
logging.info("Set new webhook")
logging.info(f"Webhook info: {bot.get_webhook_info()}")
