try:
print('Receiving tweet: ' + tweet.text)
if 'media' in tweet.entities:
if 'video' in tweet.extended_entities['media'][0]['type']:
print('Saving Video')
vid = tweet.extended_entities['media'][0]['video_info'][
'variants'][1]['url']
bot.send_video(chat_id=telegram_group, video=vid)
else:
print('Saving Image')
img = tweet.entities['media'][0]['media_url_https']
bot.send_photo(chat_id=telegram_group,
photo=f'{img}:large')
else:
print("Tweet doesn't contain an image")
except Exception as e:
print(e)
# Telegram bot startup
bot = Bot(token=telegram_api_token)
# Twitter stream startup
auth = tweepy.auth.OAuthHandler(twitter_api_key, twitter_api_secret_key)
auth.set_access_token(twitter_access_token, twitter_access_token_secret)
stream = tweepy.Stream(auth, MyStreamListener(), timeout=None)
print('Bot started successfully.')
# Twitter account to filter
stream.filter(follow=[twitter_filter])
if vaild_usr_doc is None:
login_col.insert_one({
"_id": "login_info",
"user_id": 1,
"username": "******",
"password": "******",
"user_role": "admin"
})
### drive().list
all_drive = gdrive.GoogleDrive().drive_list()
### ns
manager = Manager()
ns = manager.Namespace()
### Restore Unexpected Interrupted Task status 2 --> 0
task_list.update_one(
{"status": 2},
{"$set": {
"status": 0,
}},
)
### regex entry pattern
regex_entry_pattern = r"https://drive\.google\.com/(?:drive/(?:u/[\d]+/)?(?:mobile/)?folders/([\w.\-_]+)(?:\?[\=\w]+)?|folderview\?id=([\w.\-_]+)(?:\&[=\w]+)?|open\?id=([\w.\-_]+)(?:\&[=\w]+)?|(?:a/[\w.\-_]+/)?file/d/([\w.\-_]+)|(?:a/[\w.\-_]+/)?uc\?id\=([\w.\-_]+)&?)"
### define bot
request = TGRequest(con_pool_size=8)
bot = Bot(token=f"{cfg['tg']['token']}", request=request)
def __init__(self, context):
self.context = context
self.bot = Bot(context.config["telegram"]["token"])
self.updater = Updater(context.config["telegram"]["token"])
import responder
import utm
import logging
from location_model import ChatLocations
# parametri di configurazione per server e token per API Telegram
base_url = 'https://71df8ac5.ngrok.io' + '/'
bot_token = '895587413:AAFNlfhLq2x0xMgBWByQQAZeIueUn5EfiWw'
logging.basicConfig(
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=logging.INFO)
logger = logging.getLogger()
bot_instance = Bot(bot_token)
secret_token = uuid4().hex
bot_instance.set_webhook(base_url + secret_token)
logger.info('Webhook URL set to %s', base_url + secret_token)
dispatcher = Dispatcher(bot_instance, None, workers=0, use_context=True)
#repository con tutta la chat avviato il bot
chat_repository = {}
def is_user_admin(chat, user):
return chat.type == Chat.PRIVATE or user.id in [
admin.user.id for admin in chat.get_administrators()
]
def test_mutual_exclude_bot_private_key(self):
bot = Bot('123:zyxw')
with pytest.raises(ValueError):
Updater(bot=bot, private_key=b'key')
def __init__(self, app):
self._app = app
self._settings = app._settings
self._bot = Bot(token=self._settings["BotToken"])
self._workerPools = []
articles = fetch_news(reply)
for article in articles:
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):
#reply=update.message.txt
bot.send_sticker(chat_id=update.message.chat_id,
sticker=update.message.sticker.file_id)
def error(bot, update, telegramError):
logger.error("Update '%s' caused error '%s'", update, telegramError)
if __name__ == "__main__":
bot = Bot(TOKEN)
bot.set_webhook("https://71cf95591a55.ngrok.io/" + TOKEN)
dp = Dispatcher(bot, None)
dp.add_handler(CommandHandler("start", start))
dp.add_handler(CommandHandler("help", _help))
dp.add_handler(MessageHandler(Filters.text, reply_text))
dp.add_handler(MessageHandler(Filters.sticker, echo_sticker))
dp.add_error_handler(error)
app.run(port=88)
def download_voice(token, file_id):
Bot(token).get_file(file_id).download(file_id+'.ogg')
return file_id+'.ogg'
from telegram.ext import (
CallbackContext, ConversationHandler,
CommandHandler, CallbackQueryHandler,
MessageHandler, Filters, Dispatcher
)
from flask import Flask, request, Response
from webhook import setwebhook, deletewebhook
logging.basicConfig(filename='logfile.log', filemode='w', format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', datefmt='%d-%b-%y %H:%M:%S', level=logging.INFO)
logger = logging.getLogger()
TOKEN = environ.get('TOKEN')
global bot
global dp
bot = Bot(token=TOKEN)
dp = Dispatcher(bot, None)
app = Flask(__name__)
# <Method>========================================================= #
def start(update: Update, _: CallbackContext):
update.message.reply_text("Silahkan liat /menu yang tersedia")
return ConversationHandler.END
def menu(update: Update, _: CallbackContext) -> int:
user = update.message.from_user
logger.info(f"User {user.first_name} started the conversation.")
keyboard = [
[InlineKeyboardButton("Info Pelanggan", callback_data='infoPelanggan')],
filemode='a',
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=logging.DEBUG)
logger = logging.getLogger(__name__)
pocket_instance = Pocket(tokens.POCKET_CONSUMER_TOKEN,
tokens.POCKET_ACCESS_TOKEN)
auth_token = ""
db = ForwardBotDatabase('botusers.db')
botan = Botan(tokens.BOTAN_TOKEN)
users = {}
#updater = Updater(tokens.TELEGRAM_TOKEN)
bot = Bot(tokens.TELEGRAM_TOKEN)
update_queue = Queue()
dp = Dispatcher(bot, update_queue)
app = Flask(__name__)
def start(bot, update, args):
telegram_user = update.message.from_user
botan.track(update, "/start")
if len(args) > 0:
try:
access_token = pocket_instance.get_access_token(
tokens.POCKET_CONSUMER_TOKEN, args[0])
def send_message(msg, token, chat_id):
Bot(token).send_message(chat_id=chat_id, text=msg)
def bot(bot_info):
return Bot(bot_info['token'], private_key=PRIVATE_KEY)
from __main__ import updater
from telegram import Bot
from feedparser import parse
from TrishnaBot.modules.sql import rss_records_sql
from TrishnaBot import BOT_TOKEN, SHT_DELAY, GIT_FDS_CNL
from os.path import join
# Init bot
bot = Bot(BOT_TOKEN)
# URLs from kernel.org
KERNEL_GIT_URL = 'https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/log/?h=v'
KERNEL_RSS_URL = 'https://www.kernel.org/feeds/kdist.xml'
KERNEL_DL_URL = 'https://cdn.kernel.org/pub/linux/kernel/v%s.x/linux-'
# Linux Kernel releases via RSS feed!
def linux_releases(context):
kernel_list = parse(KERNEL_RSS_URL)
for i in range(0, len(kernel_list.entries)):
# Don't count linux-next
if not 'linux-next' in kernel_list.entries[i].title:
global details, release, series, append_file, final_tar_file, final_dl_url
details = kernel_list.entries[i].id.split(',')
release = details[2].split('.')
series = release[0] + '.' + release[1]
append_file = join(series + '-' + details[1])
informRelease()
def __init__(self, settings: Settings):
super().__init__(settings)
assert isinstance(settings.telegram_bot_token, str)
self.bot = Bot(settings.telegram_bot_token)
def webhook_notification(chat_id):
webhook = Webhook(chat_id)
req_json = request.json
try:
bot = Bot(token=ACCESS_TOKEN)
dict_message = webhook.get_message_info(req_json)
if req_json["action"] == "opened":
if "pull_request" in list(req_json.keys()): # new pr
message = "❕ *Novo pull request aberto* em "\
"[{repo_name}#{pr_number} "\
"{title}]({pr_url})\n"\
"por [{user}]({user_url})\n\n"\
"{pr_body}"\
.format(repo_name=dict_message["repo_name"],
pr_number=dict_message["number"],
title=dict_message["title"],
pr_url=dict_message["url"],
user=dict_message["user"],
user_url=dict_message["user_url"],
pr_body=dict_message["body"])
bot.send_message(chat_id=chat_id,
text=message,
parse_mode=telegram.ParseMode.MARKDOWN,
disable_web_page_preview=True)
elif "issue" in list(req_json.keys()): # new issue
message = "❇ *Nova issue aberta* em "\
"[{repo_name}#{issue_number} "\
"{title}]({issue_url})\n"\
"por [{user}]({user_url}).\n\n"\
"_Caso você queira comentar "\
"essa issue, é só você escrever: 'Comentar "\
"#{issue_number}: e o comentário aqui'_"\
.format(repo_name=dict_message["repo_name"],
issue_number=dict_message["number"],
user=dict_message["user"],
user_url=dict_message["user_url"],
title=dict_message["title"],
issue_url=dict_message["url"])
bot.send_message(chat_id=chat_id,
text=message,
parse_mode=telegram.ParseMode.MARKDOWN,
disable_web_page_preview=True)
elif req_json["action"] == "created":
if "pull_request_review_comment" in list(req_json.keys()):
# new comment on pr review
pass
if "issue" in list(req_json.keys()):
# new issue comment
comment_url, comment_body = \
webhook.get_body_and_body_url(req_json)
message = "💬 *Novo comentário* em "\
"[{repo_name}#{issue_number} "\
"{title}]({comment_url})\n"\
"por [{user}]({user_url})\n"\
"\n{comment_body}\n\n_Caso você queira comentar "\
"essa issue, é só você escrever: 'Comentar "\
"#{issue_number}: e o comentário aqui'_"\
.format(repo_name=dict_message["repo_name"],
issue_number=dict_message["number"],
user=dict_message["user"],
user_url=dict_message["user_url"],
title=dict_message["title"],
comment_url=comment_url,
comment_body=comment_body)
bot.send_message(chat_id=chat_id,
text=message,
parse_mode=telegram.ParseMode.MARKDOWN,
disable_web_page_preview=True)
elif req_json["action"] == "submitted":
if "review" in list(req_json.keys()):
# new reviewed pr
pull_request_name = "[{title}]({url})".format(
title=dict_message["title"], url=dict_message["url"])
if req_json["review"]["state"] == "approved":
review_state = "✅ Pull request " + pull_request_name +\
" aprovado"
elif req_json["review"]["state"] == "changes_requested":
review_state = " ❗️Mudanças solicitadas no pull request" +\
" " + pull_request_name
else:
review_state = "💬 Pull request " + pull_request_name +\
"revisado"
message = review_state + " por [@{username}]({user_url})\n\n"\
.format(username=dict_message["user"],
user_url=dict_message
["user_url"])
message += '{review_body}'.format(
review_body=dict_message["body"])
bot.send_message(chat_id=chat_id,
text=message,
parse_mode='Markdown',
disable_web_page_preview=True)
elif req_json["action"] == "review_requested":
if "pull_request" in list(req_json.keys()):
# new review requested
reviewer = ""
reviewer += webhook.get_reviewer_login(req_json)
reviewer += "(" + (req_json["pull_request"][
"requested_reviewers"][0]["html_url"]) + ")"
message = "📝 [{user}]({user_url}) "\
"solicitou a revisão de {reviewer} "\
"no pull request "\
"[{repo_name}#{pr_number}"\
"{title}]({pr_url})."\
.format(repo_name=dict_message["repo_name"],
pr_number=dict_message["number"],
title=dict_message["title"],
reviewer=reviewer,
pr_url=dict_message["url"],
user=dict_message["user"],
user_url=dict_message["user_url"])
bot.send_message(chat_id=chat_id,
text=message,
parse_mode=telegram.ParseMode.MARKDOWN,
disable_web_page_preview=True)
except KeyError:
return jsonify({"failed": "400"}), 400
else:
return jsonify({"success": "200"}), 200
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,
dispatcher=None,
base_file_url=None):
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,
base_url,
base_file_url=base_file_url,
request=self._request,
private_key=private_key,
private_key_password=private_key_password)
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)
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 = []
def __init__(self, token):
self.bot = Bot(token=token)
self.updater = Updater(bot=self.bot)
self.dispatcher = self.updater.dispatcher
Filters,MessageHandler,InlineQueryHandler
import logging
from uuid import uuid4
import json
from telegram import ParseMode
logging.basicConfig(
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=logging.INFO)
logger = logging.getLogger(__name__)
with open('token.json') as j:
token = json.load(j)
BOT = Bot(token['token'])
A, B, C, D, E, F, X, Z = range(8)
prev = None
NEXT = 10
def inlinequery(update, context):
"""Handle the inline query."""
query = update.inline_query.query
print(query)
results = [
InlineQueryResultArticle(id=uuid4(),
title="Caps",
input_message_content=InputTextMessageContent(
query.upper())),
def test_mutualExclusiveTokenBot(self):
bot = Bot('123:zyxw')
self.assertRaises(ValueError, Updater, token='123:abcd', bot=bot)
def __new__(self):
if not self._instance:
self._instance = super(TelegramBot, self).__new__(self)
self.bot = Bot(settings.TG_TOKEN)
self.dispatcher = Dispatcher(self.bot, None, workers=0)
return self._instance
#!/usr/bin/env python
from telegram import Bot, ChatActions
from datetime import datetime
from time import gmtime, strftime
import os, sys
import time
myBot = Bot('telegram bot account_id')
chat_id = 'chat_id'
result = myBot.getMe()
now1 = time.ctime()
num = len(sys.argv)
if num <= 3:
result = myBot.sendMessage(
chat_id, u"\U0001F44D " + sys.argv[1] + '\n\n ' + sys.argv[2] +
'\n\n' + 'Time :' + now1)
else:
result = myBot.sendMessage(
chat_id,
'\n\xF0\x9F\x98\x89SCAN COMPLETED\xF0\x9F\x98\x89\n---------------------------------------\ndomain name : '
+ sys.argv[1] + '\ntotal subdomains : ' + sys.argv[2] +
'\ntotal live domains : ' + sys.argv[3] + '\ntotal live urls : ' +
sys.argv[4] + '\n' + '\n' + 'Time :' + now1)
dir_path = os.path.dirname(os.path.realpath(__file__))
# Logging
logger = logging.getLogger()
logger.setLevel(logging.INFO)
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
app = Flask(__name__)
app.secret_key = os.urandom(24)
with open('services.json') as conf_file:
conf = json.load(conf_file)
connectionString = conf['mongo']['connectionString']
telegram_token = conf['telegram']['bot_token']
bot = Bot(telegram_token)
client = MongoClient(connectionString)
db = client.get_default_database()
col_refs = db['referrals']
"""
render index template
"""
@app.route('/', methods=['GET', 'POST'])
def index():
try:
return render_template('index.html')
except Exception as exc:
def test_mutual_exclude_token_bot(self):
bot = Bot('123:zyxw')
with pytest.raises(ValueError):
Updater(token='123:abcd', bot=bot)
from telethon import TelegramClient
from telethon.tl.functions.channels import JoinChannelRequest, InviteToChannelRequest
from telethon.tl.types import ChannelParticipantsAdmins
from telethon.errors import AuthKeyUnregisteredError, UserBannedInChannelError, PeerFloodError, \
UserChannelsTooMuchError, ChatWriteForbiddenError, UserDeactivatedError, ChannelPrivateError, \
PhoneNumberOccupiedError, UserNotMutualContactError, UserPrivacyRestrictedError, UserKickedError
from telegram import Bot, ParseMode
from sqlalchemy import desc
from models import TelegramAccount, Contact, Task, Proxy, InviteError
from database import session
from getsmscode_svc import get_summary, get_sms, get_mobile_number, blacklist_mobile_number
from randomuser_svc import get_random_first_last_names
import config
bot = Bot(config.TELEGRAM_TOKEN)
def run_threaded(job_func, args=None):
if args is None:
job_thread = threading.Thread(target=job_func)
else:
job_thread = threading.Thread(target=job_func, args=args)
job_thread.start()
def start_schedule():
while True:
try:
schedule.run_pending()
time.sleep(1)
def main():
'''Setting up all needed to launch bot'''
logger.info('Started')
req = Request(
connect_timeout=30.0,
read_timeout=1.0,
con_pool_size=8,
)
bot = Bot(
token=TOKEN,
request=req,
)
updater = Updater(
bot=bot,
use_context=True,
)
# Проверить что бот корректно подключился к Telegram API
info = bot.get_me()
logger.info('Bot info: %s', info)
# Навесить обработчики команд
conv_handler = ConversationHandler(
entry_points=[
CommandHandler('start', start_buttons_handler),
],
states={
NAME: [
CallbackQueryHandler(name_handler, pass_user_data=True),
],
NICHE: [
MessageHandler(Filters.all, niche_handler,
pass_user_data=True),
],
VERTICAL: [
CallbackQueryHandler(vertical_handler, pass_user_data=True),
],
GEO: [
CallbackQueryHandler(geo_handler, pass_user_data=True),
],
SPEND: [
CallbackQueryHandler(spend_handler, pass_user_data=True),
],
CASES: [
CallbackQueryHandler(cases_handler, pass_user_data=True),
],
CASE_DETAILS: [
CallbackQueryHandler(case_details_handler,
pass_user_data=True),
],
FINISH: [
CallbackQueryHandler(finish_handler, pass_user_data=True),
MessageHandler(Filters.all,
finish_handler,
pass_user_data=True),
]
},
fallbacks=[
CommandHandler('cancel', cancel_handler),
],
)
updater.dispatcher.add_handler(conv_handler)
updater.dispatcher.add_handler(MessageHandler(Filters.all, echo_handler))
if MODE == "dev":
updater.start_polling()
updater.idle()
logger.info('Stopped')
elif MODE == "prod":
updater.start_webhook(listen="0.0.0.0", port=PORT, url_path=TOKEN)
updater.bot.set_webhook("https://{}.herokuapp.com/{}".format(
HEROKU_APP_NAME, TOKEN))
from queue import Queue
import os
from playhouse.db_url import connect
import dotenv
dotenv.load_dotenv()
def config(key: str, default=None):
return os.environ.get(key) or os.environ.get(key.upper()) or default
# db = SqliteDatabase(config('db', 'database.sqlite'))
db = Proxy()
db.initialize(connect(config('DATABASE_URL', 'sqlite:///database.sqlite')))
class CustomDispatcher(Dispatcher):
def process_update(self, update):
with db.atomic() as txn:
super().process_update(update)
db.close()
updater = Updater(dispatcher=CustomDispatcher(Bot(config('token')),
Queue(),
job_queue=JobQueue()),
workers=None)
bot = updater.bot
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] = []
from telegram import Bot
from telegram.ext import Dispatcher, ConversationHandler
from telegram.ext import Updater, CommandHandler, MessageHandler, Filters, CallbackQueryHandler
from bot.main import *
from bot.login import *
from bot.output import *
from bot.conversationList import *
from bot.task import *
from dotenv import load_dotenv
import os
from app.models import *
basedir = os.path.abspath(os.path.dirname(''))
load_dotenv(os.path.join(basedir, '.env'))
TOKEN = os.environ.get('TOKEN')
WHERE = os.environ.get('WHERE')
bot_obj = Bot(TOKEN)
if WHERE == 'SERVER':
updater = 1213
dp = Dispatcher(bot_obj, None, workers=0, use_context=True)
else:
updater = Updater(token=TOKEN, use_context=True)
dp = updater.dispatcher
# delete un completed objects ones, after restart
c_task = Completed_task.objects.filter(photo='')
output = Output.objects.filter(price=None)
user = Bot_user.objects.filter(birthday=None)
for i in c_task:
i.delete()
for i in output:
i.delete()
import telegram
from telegram.ext import Updater, CommandHandler, MessageHandler, Filters, run_async
import requests
from bs4 import BeautifulSoup as bs
from telegram import Bot, InlineKeyboardButton, InlineKeyboardMarkup
# from instaloader import Instaloader, Profile, Post
import sys
import shutil
import glob
import os
import zipfile
import pathlib
bot_token = os.environ.get("BOT_TOKEN", "")
bot = Bot(token=bot_token)
help_keyboard = [[InlineKeyboardButton("Updates Channel", url="https://t.me/MBNUpdates"),
InlineKeyboardButton("Support Chat", url="https://t.me/MBNChat")]]
help_reply_markup = InlineKeyboardMarkup(help_keyboard)
def start(update, context):
user = update.message.from_user
chat_member = context.bot.get_chat_member(
chat_id='-1001225141087', user_id=update.message.chat_id)
status = chat_member["status"]
if(status == 'left'):
context.bot.send_message(chat_id=update.message.chat_id,
text=f"Hi {user.first_name}, to use me you have to be a member of the updates channel in order to stay updated with the latest developments.\nPlease click below button to join and /start the bot again.", reply_markup=help_reply_markup)
return
def launch_dispatcher():
# Different command handlers
dp.add_handler(CommandHandler("start", start))
dp.add_handler(CommandHandler("about", about))
dp.add_handler(CommandHandler("help", help))
dp.add_handler(CommandHandler("spiv", spiv))
dp.add_handler(CommandHandler("settings", settings))
# On message
dp.add_handler(MessageHandler(Filters.text, echo))
# log all errors
dp.add_error_handler(error)
# start the dispatcher in different thread to process every update
thread = Thread(target=dp.start, name='dp')
thread.start()
# Starting the application
if __name__ == '__main__':
bot = Bot(TELEGRAM_TOKEN) # Creating the Bot object with TELEGRAM_TOKEN
update_queue = Queue() # Creating the Queue for the Dispatcher
dp = Dispatcher(bot, update_queue) # Creating the Dispatcher object
launch_dispatcher() # Preparing and launching the Dispatcher
bot.deleteWebhook(drop_pending_updates=True)
bot.setWebhook(f"https://sbbotapp.herokuapp.com/{TELEGRAM_TOKEN}"
) # Setting the WebHook for bot to receive updates
#bot.setWebhook(f"https://testflasksbbot.herokuapp.com/{TELEGRAM_TOKEN}") # Setting the WebHook for bot to receive updates
gsheets_manager = GSheetsManager()
app.run(
host="0.0.0.0", port=int(os.environ.get('PORT', 5000)),
threaded=True) # Launching the Flask app on appropriate IP and PORT
