def main():
app = Client("init")
def handler_parms(client, message):
"""
This function listens for every new message
If the message comes from your BOT DISPLAY NAME (not the bot name that ends with 'bot'),
bot does not read the message (as it can create an infinite message loop)
"""
print(message)
print(message["chat"]["first_name"])
if message["chat"]["first_name"] == "Notify":
return
if contains_keywords(message["text"]):
notify_user(message["text"])
"""
Pyrogram init functions:
(https://github.com/pyrogram/pyrogram)
"""
my_handler = MessageHandler(handler_parms)
app.add_handler(my_handler)
app.run()
def __init__(self, client: pyrogram.Client, shared_config_callback=None):
self.client = client
client.add_handler(RawUpdateHandler(self._process_raw_update))
self.shared_config_callback = shared_config_callback
self.voips = {}
voip = VoIP()
self.max_layer = voip.get_connection_max_layer()
if shared_config_callback:
voip.set_shared_config(json.dumps(shared_config_callback({})))
async def main():
app = Client(
"asm",
api_id=config.API_ID,
api_hash=config.API_HASH,
bot_token=config.BOT_TOKEN,
)
app.add_handler(MessageHandler(service_message, Filters.service))
await app.start()
print("Anti Service Bot is up and accepting message updates. Status OK.")
await app.idle()
class NetworkClient(object):
"""Handles all network related actions"""
def __init__(self, fbLogin, fbPassword, apiId, apiHash, telegramUsername):
self.fbClient = FBClientHandler(fbLogin, fbPassword)
self.telegramClient = TelegramClient(session_name="facegram_session",
api_id=apiId,
api_hash=apiHash)
self.telegramClient.start()
self.username = telegramUsername
# Lookup user data from username
self.user = self.lookupUser(self.username)
def registerBridge(self, bridge):
"""Registers Bridge and adds Telegram handlers"""
self.fbClient.bridge = bridge
self.telegramClient.add_handler(
MessageHandler(bridge.telegramMessageHandler), 1)
def stop(self):
"""Stops telegram and facebook client (Loggout)"""
self.fbClient.logout()
self.telegramClient.stop()
def loadThreadBridges(self, ids):
return self.fbClient.fetchThreadInfo(ids)
def createConversation(self, threadId):
""" Creates conversation for facebook threadId. Returns list of telegram parameters"""
thread = self.fbClient.fetchThreadInfo(threadId)[threadId]
# Create chat with facebook's thread name
update = self.telegramClient.send(
functions.messages.CreateChat(users=[
types.InputUserSelf(),
types.InputUser(user_id=self.user.userId,
access_hash=self.user.accessHash)
],
title=thread.name))
chatId = update.chats[0].id
isGroup = False
if (thread.type is ThreadType.GROUP):
isGroup = True
# Returns [facebookThreadId, telegramChatId, telegramUsername, threadtype]
return [threadId, chatId, self.username, isGroup]
def lookupUser(self, username):
""" Creates FacegramUser from telegram username """
resolved_peer = self.telegramClient.send(
functions.contacts.ResolveUsername(username=username))
return FacegramUser(userId=resolved_peer.users[0].id,
accessHash=resolved_peer.users[0].access_hash)
def get_client():
try:
client = Client(session_name=config.BOT_TOKEN, api_id=config.API_ID, api_hash=config.API_HASH,
app_version="VKMessages v{0}".format(config.VERSION))
client.add_handler(MessageHandler(start_command, Filters.command("start")))
client.add_handler(MessageHandler(debug_command, Filters.command("debug")))
# Этот MessageHandler должен быть обязательно последним
client.add_handler(MessageHandler(message_handler))
return client
except Exception as e:
return e
class Receiver:
def __init__(self, api_id: int, api_hash: str, bot_token: str,
listen_user: str, website: WebServer):
self.api_id = api_id
self.api_hash = api_hash
self.bot_token = bot_token
self.bot = Client('receiver',
api_id=api_id,
api_hash=api_hash,
bot_token=bot_token)
self.listen_user = listen_user
self.website = website
self.init_handle()
def init_handle(self) -> None:
self.bot.add_handler(
MessageHandler(self.handle_incoming_passcode,
filters.chat(self.listen_user) & filters.text))
async def handle_incoming_passcode(self, _client: Client,
msg: Message) -> None:
# logger.info('Put passcode => %s', msg.text)
if '\n' in msg.text:
for code in msg.text.splitlines(False):
code = code.strip()
if not len(code) or code.startswith('#'):
continue
r = PASSCODE_EXP.match(code)
if r is None:
logger.warning('Skipped code => %s', code)
await self.website.put_passcode(code)
elif not msg.text.startswith('#'):
await self.website.put_passcode(msg.text)
@classmethod
async def new(cls, api_id: int, api_hash: str, bot_token: str,
listen_user: str, website: WebServer) -> 'Receiver':
return cls(api_id, api_hash, bot_token, listen_user, website)
async def start_bot(self) -> None:
await self.bot.start()
async def stop_bot(self) -> None:
await self.bot.stop()
async def start(self) -> None:
await asyncio.gather(self.start_bot(), self.website.start())
async def stop(self) -> None:
await asyncio.gather(self.stop_bot(), self.website.stop())
async def idle(self) -> None:
await self.website.idle()
def main():
print("starting task system cli...")
print(__version__)
app = Client("tasksystem_bot")
for handler in handlers_list:
app.add_handler(handler)
app.start()
print(app.get_me().username)
print("done")
idle()
async def load_plugin(client: Client, message: Message):
""" load TG Plugins """
status_message = await message.reply("...")
try:
if message.reply_to_message is not None:
down_loaded_plugin_name = await message.reply_to_message.download(
file_name="./plugins/"
)
if down_loaded_plugin_name is not None:
# LOGGER.info(down_loaded_plugin_name)
relative_path_for_dlpn = os.path.relpath(
down_loaded_plugin_name,
os.getcwd()
)
# LOGGER.info(relative_path_for_dlpn)
lded_count = 0
path = Path(relative_path_for_dlpn)
module_path = ".".join(
path.parent.parts + (path.stem,)
)
# LOGGER.info(module_path)
module = reload(import_module(module_path))
# https://git.io/JvlNL
for name in vars(module).keys():
# noinspection PyBroadException
try:
handler, group = getattr(module, name).handler
if isinstance(handler, Handler) and isinstance(group, int):
client.add_handler(handler, group)
LOGGER.info(
'[{}] [LOAD] {}("{}") in group {} from "{}"'.format(
client.session_name,
type(handler).__name__,
name,
group,
module_path
)
)
lded_count += 1
except Exception:
pass
await status_message.edit(
f"installed {lded_count} commands / plugins"
)
except Exception as error:
await status_message.edit(
f"ERROR: <code>{error}</code>"
)
class TelegramClient():
__instances = {}
def __init__(self, api_id, api_hash):
self.client = Client(__name__, api_id, api_hash)
self.__instances[api_hash] = self
self.client.add_handler(MessageHandler(self.read_updates))
def start(self):
self.client.start()
def stop(self):
self.client.stop()
def read_updates(self, client, message):
print(message, '\n\n>>>\n\n', client)
class ForwardController:
def __init__(self):
config = ConfigParser()
config.read('config.ini')
self.listen_group: int = config.getint('channel', 'listen_group')
self.fwd_to: int = config.getint('channel', 'fwd_to')
self.app = Client(
'channel_user',
config.get('account', 'api_id'),
config.get('account', 'api_hash'),
)
self.q = SqliteObject(
self.app, config,
config.get('database', 'file', fallback='channel-no.db'))
self.watcher = Watcher(self.app, self.fwd_to, self.q)
self.app.add_handler(
MessageHandler(
self.handle_toggle,
filters.chat(self.listen_group) & filters.command('toggle')))
self.app.add_handler(
MessageHandler(self.handle_edit_message,
filters.chat(self.listen_group) & filters.edited))
self.app.add_handler(
MessageHandler(self.handle_incoming_message,
filters.chat(self.listen_group)))
self.app.add_handler(RawUpdateHandler(self.handle_raw_update))
self.enabled = True
async def start(self):
self.watcher.start()
await self.app.start()
async def stop(self):
self.watcher.set_stop()
await self.app.stop()
async def handle_raw_update(self, _client: Client, update: Update,
_chats: dict, _users: dict):
if isinstance(update, pyrogram.raw.types.UpdateDeleteChannelMessages) and \
(-(update.channel_id + 1000000000000) == self.listen_group):
await self.q.delete_message(update.messages)
async def handle_edit_message(self, client: Client, msg: Message) -> None:
await self.q.handle_edit_message(client, msg)
async def handle_toggle(self, _client: Client, msg: Message) -> None:
self.enabled = not self.enabled
await msg.reply(f'Set status to: {self.enabled}')
async def handle_incoming_message(self, _, msg: Message) -> None:
if not self.enabled:
return
await self.watcher.put(msg)
async def main(config, session):
from apps.telegram.utils import log, parse_message
session = config['session_name']
api_id = config['api_id']
api_hash = config['api_hash']
bot_token = config['bot_token']
if config['is_bot']:
log('Init Bot session', 1)
app = Client(
'my_bot',
api_id=api_id,
api_hash=api_hash,
bot_token=bot_token,
workdir='sessions/',
test_mode=True
)
if not config['is_bot']:
log('Init User-Bot session', 1)
app = Client(
api_id=api_id,
api_hash=api_hash,
# bot_token=bot_token,
workdir='sessions/',
test_mode=True,
)
change_device_model(app, model='Macbook Pro 13 Retina')
app.start()
@app.on_message()
def message_handler(client, message):
result = parse_message(message)
@app.on_disconnect()
def disconnect_handler(message=None):
print('disconnect signal')
print(message)
app.add_handler(message_handler)
app.add_handler(disconnect_handler)
log(f'Device model: {app.DEVICE_MODEL}', 1)
def main(telegram_class, user_configo, session_label):
LOG.debug("C={} I={}".format(telegram_class, user_configo))
client = Client(session_name=session_label)
chat_parser = make_chat_parser(telegram_class, user_configo.exchange)
handler = chat_parser.make_message_handler(user_configo)
LOG.debug("client={}. chat_parser={}. handler={}".format(
client, chat_parser, handler))
from pyrogram import RawUpdateHandler, Filters, MessageHandler
client.add_handler(MessageHandler(handler))
client.start()
from pyrogram.api.functions.messages import GetAllChats
all_chats = client.send(GetAllChats([]))
LOG.debug("All chats = {}".format(all_chats))
for channel in chat_parser.CHANNELS.keys():
client.join_chat(channel)
def add_client(self, client: pyrogram.Client):
if not client in self._clients:
self._clients.append(client)
if is_bot(client):
if not client in self._bots:
self._bots.append(client)
else:
if not client in self._users:
self._users.append(client)
for decorator in self._handlers:
if decorator.multigram_onmessagedecorator._scope(client):
handler_ref = client.add_handler(
MessageHandler(
decorator,
decorator.multigram_onmessagedecorator._filters),
decorator.multigram_onmessagedecorator._group)
if not self._active_handlers.__contains__(client):
self._active_handlers[client] = []
self._active_handlers[client].append(handler_ref)
bot_username = ensure_no_at_sign(config('BOT_USERNAME', default='HeyTacoBot'))
logging.basicConfig(
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=logging.getLevelName(config('LOG_LEVEL', default='INFO')))
bot = Client(session_name=bot_username,
api_id=api_id,
api_hash=api_hash,
bot_token=bot_token)
if __name__ == '__main__':
sched.add_job(tacoinflator, trigger='cron', hour='0,12')
bot.add_handler(new_chat_handler, group=-1)
bot.add_handler(store_names_handler, group=-1)
bot.add_handler(start_handler)
bot.add_handler(help_handler)
bot.add_handler(self_kick_handler)
bot.add_handler(chat_reply_handler)
bot.add_handler(my_tacos_handler)
bot.add_handler(taco_top_handler)
bot.add_handler(less_handler)
bot.add_handler(taco_mention_handler)
bot.add_handler(delete_handler)
bot.add_handler(autohide_delay_handler)
bot.add_handler(autohide_handler)
sched.start()
if not os.path.isdir(DOWNLOAD_LOCATION):
os.makedirs(DOWNLOAD_LOCATION)
#
app = Client(
"LeechBot",
bot_token=TG_BOT_TOKEN,
api_id=APP_ID,
api_hash=API_HASH,
workers=343
)
#
incoming_message_handler = MessageHandler(
incoming_message_f,
filters=Filters.command([f"{LEECH_COMMAND}"]) & Filters.chat(chats=AUTH_CHANNEL)
)
app.add_handler(incoming_message_handler)
#
incoming_gdrive_message_handler = MessageHandler(
incoming_gdrive_message_f,
filters=Filters.command([f"{GLEECH_COMMAND}"]) & Filters.chat(chats=AUTH_CHANNEL)
)
app.add_handler(incoming_gdrive_message_handler)
#
incoming_telegram_download_handler = MessageHandler(
down_load_media_f,
filters=Filters.command([f"{TELEGRAM_LEECH_COMMAND_G}"]) & Filters.chat(chats=AUTH_CHANNEL)
)
app.add_handler(incoming_telegram_download_handler)
#
incoming_purge_message_handler = MessageHandler(
incoming_purge_message_f,
class BotController:
def __init__(self, config: ConfigParser, redis_: aioredis.Redis,
checker: CheckFile, forward_thread: ForwardThread):
self.configure = Configure.init_instance(config)
self.app = Client('forward', config.get('account', 'api_id'),
config.get('account', 'api_hash'))
self.checker: CheckFile = checker
self.redis: aioredis.Redis = redis_
self.redis_prefix: str = ''.join(
random.choices(string.ascii_lowercase, k=5))
self.ForwardThread: ForwardThread = forward_thread
self.min_resolution: int = config.getint('forward',
'lowq_resolution',
fallback=120)
self.owner_group_id: int = config.getint('account',
'group_id',
fallback=-1)
self.echo_switch: bool = False
self.detail_msg_switch: bool = False
# self.delete_blocked_message_after_blacklist: bool = False
self.func_blacklist: Optional[Callable[[], int]] = None
if self.configure.blacklist:
self.func_blacklist = ForwardThread.put_blacklist
self.custom_switch: bool = False
self.init_handle()
self.plugins: List[PluginLoader] = []
@classmethod
async def create(cls, config: ConfigParser):
redis_ = await aioredis.create_redis_pool('redis://localhost')
checker = await CheckFile.init_instance(
config.get('pgsql', 'host'), config.getint('pgsql', 'port'),
config.get('pgsql', 'username'), config.get('pgsql', 'passwd'),
config.get('pgsql', 'database'))
forward_thread = ForwardThread()
self = cls(config, redis_, checker, forward_thread)
await self.redis.sadd(f'{self.redis_prefix}for_bypass', *await
self.checker.query_all_bypass())
await self.redis.sadd(f'{self.redis_prefix}for_blacklist', *await
self.checker.query_all_blacklist())
await self.redis.mset(await self.checker.query_all_special_forward())
await self.redis.sadd(f'{self.redis_prefix}for_admin', *await
self.checker.query_all_admin())
await self.redis.sadd(f'{self.redis_prefix}for_admin',
config.getint('account', 'owner'))
await self.load_plugins(config)
return self
async def clean(self) -> None:
await self.redis.delete(f'{self.redis_prefix}for_bypass')
await self.redis.delete(f'{self.redis_prefix}for_blacklist')
await self.redis.delete(' '.join(
map(str, (key for key, _ in (
await self.checker.query_all_special_forward()).items()))))
await self.redis.delete(f'{self.redis_prefix}for_admin')
def init_handle(self) -> None:
self.app.add_handler(
MessageHandler(self.get_msg_from_owner_group,
filters.chat(self.owner_group_id) & filters.reply))
self.app.add_handler(
MessageHandler(
self.get_command_from_target,
filters.chat(self.configure.predefined_group_list)
& filters.text & filters.reply))
self.app.add_handler(
MessageHandler(
self.pre_check, filters.media & ~filters.private
& ~filters.sticker & ~filters.voice & ~filters.web_page))
self.app.add_handler(
MessageHandler(
self.handle_photo, filters.photo & ~filters.private
& ~filters.chat([self.configure.photo, self.configure.lowq])))
self.app.add_handler(
MessageHandler(
self.handle_video, filters.video & ~filters.private
& ~filters.chat(self.configure.video)))
self.app.add_handler(
MessageHandler(
self.handle_gif, filters.animation & ~filters.private
& ~filters.chat(self.configure.gif)))
self.app.add_handler(
MessageHandler(
self.handle_document, filters.document & ~filters.private
& ~filters.chat(self.configure.doc)))
self.app.add_handler(
MessageHandler(
self.handle_other, filters.media & ~filters.private
& ~filters.sticker & ~filters.voice & ~filters.web_page))
self.app.add_handler(MessageHandler(self.pre_private, filters.private))
self.app.add_handler(
MessageHandler(self.handle_add_bypass,
filters.command('e') & filters.private))
self.app.add_handler(
MessageHandler(self.process_query,
filters.command('q') & filters.private))
self.app.add_handler(
MessageHandler(self.handle_add_black_list,
filters.command('b') & filters.private))
self.app.add_handler(
MessageHandler(self.process_show_detail,
filters.command('s') & filters.private))
self.app.add_handler(
MessageHandler(
self.set_forward_target_reply,
filters.command('f') & filters.reply & filters.private))
self.app.add_handler(
MessageHandler(self.set_forward_target,
filters.command('f') & filters.private))
self.app.add_handler(
MessageHandler(self.add_user,
filters.command('a') & filters.private))
self.app.add_handler(
MessageHandler(self.change_code,
filters.command('pw') & filters.private))
self.app.add_handler(
MessageHandler(self.undo_blacklist_operation,
filters.command('undo') & filters.private))
self.app.add_handler(
MessageHandler(self.switch_detail2,
filters.command('sd2') & filters.private))
self.app.add_handler(
MessageHandler(self.switch_detail,
filters.command('sd') & filters.private))
self.app.add_handler(
MessageHandler(self.show_help_message,
filters.command('help') & filters.private))
self.app.add_handler(
MessageHandler(self.process_private, filters.private))
async def load_plugins(self, config: ConfigParser) -> None:
try:
for root, _dirs, filenames in os.walk('.'):
if root != '.':
continue
for filename in filenames:
if not (filename.startswith('Plugin')
and filename.endswith('.py')):
continue
module_name = filename.split('.py')[0]
try:
mod = importlib.import_module(module_name)
loader = await PluginLoader(
mod, module_name, self.app, config,
CheckFile).create_instance() # type: ignore
await loader.instance.plugin_pending_start(
) # type: ignore
self.plugins.append(loader) # type: ignore
except:
logger.exception('Loading plugin: %s catch exception!',
module_name)
else:
logger.info('Load plugin: %s successfully',
module_name)
except FileNotFoundError:
pass
async def start_plugins(self) -> None:
for x in self.plugins:
try:
await x.instance.plugin_start()
except:
logger.error('Start %s plugin fail', x.module_name)
async def stop_plugins(self) -> None:
for x in self.plugins:
try:
await x.instance.plugin_stop()
except:
logger.error('Stop %s plugin fail', x.module_name)
async def pending_stop_plugins(self) -> None:
for x in self.plugins:
try:
await x.instance.plugin_pending_stop()
except:
logger.error('Pending stop %s plugin fail', x.module_name)
async def user_checker(self, msg: Message) -> bool:
return await self.redis.sismember(f'{self.redis_prefix}for_admin',
msg.chat.id)
async def reply_checker_and_del_from_blacklist(self, client: Client,
msg: Message) -> None:
try:
pending_del = None
if msg.reply_to_message.text:
r = re.match(r'^Add (-?\d+) to blacklist$',
msg.reply_to_message.text)
if r and msg.reply_to_message.from_user.id != msg.chat.id:
pending_del = int(r.group(1))
else:
group_id = msg.forward_from.id if msg.forward_from else \
msg.forward_from_chat.id if msg.forward_from_chat else None
if group_id and await self.redis.sismember(
f'{self.redis_prefix}for_blacklist', group_id):
pending_del = group_id
if pending_del is not None:
if await self.redis.srem(f'{self.redis_prefix}for_blacklist',
pending_del):
await self.checker.remove_blacklist(pending_del)
await client.send_message(
self.owner_group_id,
f'Remove `{pending_del}` from blacklist',
parse_mode='markdown')
except:
if msg.reply_to_message.text: print(msg.reply_to_message.text)
logger.exception('Catch!')
async def add_black_list(self,
user_id: Union[int, dict],
post_back_id=None) -> None:
if isinstance(user_id, dict):
await self.app.send_message(
self.owner_group_id, f'User id:`{user_id["from_user"]}`\nFrom '
f'chat id:`{user_id["from_chat"]}`\nForward '
f'from id:`{user_id["from_forward"]}`', 'markdown')
user_id = user_id['from_user']
# Check is msg from authorized user
if user_id is None or await self.redis.sismember(
f'{self.redis_prefix}for_admin', user_id):
raise KeyError
if await self.redis.sadd(f'{self.redis_prefix}for_blacklist', user_id):
await self.checker.insert_blacklist(user_id) # type: ignore
logger.info('Add %d to blacklist', user_id)
if post_back_id is not None:
await self.app.send_message(post_back_id,
f'Add `{user_id}` to blacklist',
'markdown')
async def del_message_by_id(self,
client: Client,
msg: Message,
send_message_to: Optional[Union[int,
str]] = None,
forward_control: bool = True) -> None:
if forward_control and self.configure.blacklist == '':
logger.error('Request forward but blacklist channel not specified')
return
id_from_reply = get_forward_id(msg.reply_to_message)
q = await self.checker.query('''SELECT * FROM "msg_detail"
WHERE ("from_chat" = $1 OR "from_user" = $2 OR "from_forward" = $3)
AND "to_chat" != $4''', (id_from_reply, id_from_reply, id_from_reply,
self.configure.blacklist)) # type: ignore
if send_message_to:
_msg = await client.send_message(send_message_to,
f'Find {len(q)} message(s)')
for x in q:
try:
await client.delete_messages(x['to_chat'], x['to_msg'])
except:
pass
await self.checker.execute('''DELETE FROM "msg_detail"
WHERE ("from_chat" = $1 OR "from_user" = $2 OR "from_forward" = $3)
AND "to_chat" != $4''', (id_from_reply, id_from_reply,
id_from_reply, self.configure.blacklist)
) # type: ignore
await _msg.edit(
f'Delete all message from `{id_from_reply}` completed.',
'markdown')
else:
for x in q:
try:
await client.delete_messages(x['to_chat'], x['to_msg'])
except:
pass
await msg.reply(
f'Delete all message from `{id_from_reply}` completed.', False,
'markdown')
async def get_msg_from_owner_group(self, client: Client,
msg: Message) -> None:
try:
if msg.text and msg.text == '/undo':
await self.reply_checker_and_del_from_blacklist(client, msg)
except:
logger.exception(
'Exception occurred on `get_msg_from_owner_group()\'')
async def get_command_from_target(self, client: Client,
msg: Message) -> None:
if re.match(r'^\/(del(f)?|b|undo|print)$', msg.text):
if msg.text == '/b':
for_id = await self.checker.query_forward_from(
msg.chat.id, msg.reply_to_message.message_id)
await self.add_black_list(for_id, self.owner_group_id)
# To enable delete message, please add `delete other messages' privilege to bot
call_delete_msg(
30, client.delete_messages, msg.chat.id,
(msg.message_id, msg.reply_to_message.message_id))
elif msg.text == '/undo':
group_id = msg.reply_to_message.message_id if msg.reply_to_message else None
if group_id:
try:
if await self.redis.srem(
f'{self.redis_prefix}for_admin', group_id):
await self.checker.remove_admin(group_id)
await client.send_message(
self.owner_group_id,
f'Remove `{group_id}` from blacklist', 'markdown')
except ValueError:
await client.send_message(
self.owner_group_id,
f'`{group_id}` not in blacklist', 'markdown')
elif msg.text == '/print' and msg.reply_to_message is not None:
print(msg.reply_to_message)
else:
call_delete_msg(20, client.delete_messages, msg.chat.id,
msg.message_id)
if get_forward_id(msg.reply_to_message):
await self.del_message_by_id(client, msg,
self.owner_group_id,
msg.text[-1] == 'f')
@staticmethod
def get_file_unique_id(msg: Message, _type: str) -> str:
return getattr(msg, _type).file_unique_id
@staticmethod
def get_file_type(msg: Message) -> str:
s = BotController._get_file_type(msg)
if s == 'error':
raise UnsupportedType()
return s
@staticmethod
def _get_file_type(msg: Message) -> str:
return 'photo' if msg.photo else \
'video' if msg.video else \
'animation' if msg.animation else \
'sticker' if msg.sticker else \
'voice' if msg.voice else \
'document' if msg.document else \
'audio' if msg.audio else \
'contact' if msg.contact else 'error'
async def pre_check(self, _client: Client, msg: Message) -> None:
try:
if await self.redis.sismember(f'{self.redis_prefix}for_bypass', msg.chat.id) or \
not await self.checker.checkFile(self.get_file_unique_id(msg, self.get_file_type(msg))):
return
except UnsupportedType:
pass
else:
raise ContinuePropagation
async def blacklist_checker(self, msg: Message) -> None:
return await self.redis.sismember(f'{self.redis_prefix}for_blacklist', msg.chat.id) or \
(msg.from_user and await self.redis.sismember(
f'{self.redis_prefix}for_blacklist', msg.from_user.id)) or \
(msg.forward_from and await self.redis.sismember(
f'{self.redis_prefix}for_blacklist',
msg.forward_from.id)) or \
(msg.forward_from_chat and await self.redis.sismember(f'{self.redis_prefix}for_blacklist',
msg.forward_from_chat.id))
async def forward_msg(self,
msg: Message,
to: int,
what: str = 'photo') -> None:
if await self.blacklist_checker(msg):
# if msg.from_user and msg.from_user.id == 630175608: return # block tgcn-captcha
self.func_blacklist(
BlackListForwardRequest(
msg,
LogStruct(True,
'forward blacklist context %s from %s (id: %d)',
what, msg.chat.title, msg.chat.id)))
return
forward_target = to
# spec_target = None if what == 'other' else await self.redis.get(f'{self.redis_prefix}{msg.chat.id}')
spec_target = None if what == 'other' else await self.redis.get(
str(msg.chat.id))
if spec_target is None:
# spec_target = await self.redis.get(f'{self.redis_prefix}{msg.forward_from_chat.id}')
if msg.forward_from_chat:
spec_target = await self.redis.get(
str(msg.forward_from_chat.id))
if spec_target is not None:
forward_target = getattr(self.configure, spec_target.decode())
elif is_bot(msg):
forward_target = self.configure.bot
self.ForwardThread.put(
ForwardRequest(
forward_target, msg,
LogStruct(True, 'forward %s from %s (id: %d)', what,
msg.chat.title, msg.chat.id)))
async def handle_photo(self, _client: Client, msg: Message) -> None:
await self.forward_msg(
msg, self.configure.photo
if self.checker.check_photo(msg.photo) else self.configure.lowq)
async def handle_video(self, _client: Client, msg: Message) -> None:
await self.forward_msg(msg, self.configure.video, 'video')
async def handle_gif(self, _client: Client, msg: Message) -> None:
await self.forward_msg(msg, self.configure.gif, 'gif')
async def handle_document(self, _client: Client, msg: Message):
if msg.document.file_name.split('.')[-1] in ('com', 'exe', 'bat',
'cmd'):
return
forward_target = self.configure.doc if '/' in msg.document.mime_type and msg.document.mime_type.split('/')[0] \
in ('image', 'video') else self.configure.other
await self.forward_msg(
msg, forward_target,
'doc' if forward_target != self.configure.other else 'other')
async def handle_other(self, _client: Client, msg: Message) -> None:
await self.forward_msg(msg, self.configure.other, 'other')
async def pre_private(self, client: Client, msg: Message) -> None:
if not await self.user_checker(msg):
await client.send(
raw.functions.messages.ReportSpam(
peer=await client.resolve_peer(msg.chat.id)))
return
await client.send(
raw.functions.messages.ReadHistory(peer=await
client.resolve_peer(msg.chat.id
),
max_id=msg.message_id))
raise ContinuePropagation
async def handle_add_bypass(self, _client: Client, msg: Message) -> None:
if len(msg.text) < 4:
return
except_id = msg.text[3:]
if await self.redis.sadd(f'{self.redis_prefix}for_bypass', except_id):
await self.checker.insert_bypass(except_id)
await msg.reply(f'Add `{except_id}` to bypass list',
parse_mode='markdown')
logger.info('add except id: %s', except_id)
@staticmethod
async def process_query(client: Client, msg: Message) -> None:
r = re.match(r'^/q (-?\d+)(d)?$', msg.text)
if r is None:
return
GetHistoryCoroutine(client,
msg.chat.id,
r.group(1),
dirty_run=r.group(2) is not None)
async def handle_add_black_list(self, _client: Client,
msg: Message) -> None:
try:
await self.add_black_list(msg.text[3:])
except:
await msg.reply("Check your input")
logger.exception('Catch!')
async def process_show_detail(self, _client: Client, msg: Message) -> None:
self.echo_switch = not self.echo_switch
await msg.reply(f'Set echo to {self.echo_switch}')
async def set_forward_target_reply(self, _client: Client,
msg: Message) -> None:
if msg.reply_to_message.text is None:
await msg.reply('Reply to None text messages')
return
r = re.match(r'^forward_from = (-\d+)$', msg.reply_to_message.text)
r1 = re.match(r'^/f (other|photo|bot|video|anime|gif|doc|lowq)$',
msg.text)
if r is None or r1 is None:
await msg.reply('Cannot found special target forward for')
return
await self._set_forward_target(int(r.group(1)), r1.group(1), msg)
async def set_forward_target(self, _client: Client, msg: Message) -> None:
r = re.match(
r'^/f (-?\d+) (other|photo|bot|video|anime|gif|doc|lowq)$',
msg.text)
if r is None:
return
await self._set_forward_target(int(r.group(1)), r.group(2), msg)
async def _set_forward_target(self, chat_id: int, target: str,
msg: Message) -> None:
await self.redis.set(chat_id, target)
await self.checker.update_forward_target(chat_id, target)
await msg.reply(f'Set group `{chat_id}` forward to `{target}`',
parse_mode='markdown')
async def add_user(self, _client: Client, msg: Message) -> None:
r = re.match(r'^/a (.+)$', msg.text)
if r and r.group(1) == self.configure.authorized_code:
if await self.redis.sadd(f'{self.redis_prefix}for_admin',
msg.chat.id):
await self.checker.insert_admin(msg.chat.id)
await msg.reply('Success add to authorized users.')
@staticmethod
async def change_code(self, _client: Client, msg: Message) -> None:
r = re.match(r'^/pw (.+)$', msg.text)
if r:
await msg.reply('Success changed authorize code.')
async def undo_blacklist_operation(self, client: Client,
msg: Message) -> None:
await self.reply_checker_and_del_from_blacklist(client, msg)
async def switch_detail2(self, _client: Client, msg: Message) -> None:
self.custom_switch = not self.custom_switch
await msg.reply(f'Switch custom print to {self.custom_switch}')
async def switch_detail(self, _client: Client, msg: Message) -> None:
self.detail_msg_switch = not self.detail_msg_switch
await msg.reply(f'Switch detail print to {self.detail_msg_switch}')
@staticmethod
async def show_help_message(self, _client: Client, msg: Message) -> None:
await msg.reply(""" Usage:
/e <chat_id> Add `chat_id' to bypass list
/a <password> Use the `password' to obtain authorization
/q <chat_id> Request to query one specific `chat_id'
/b <chat_id> Add `chat_id' to blacklist
/s Toggle echo switch
/f <chat_id> <target> Add `chat_id' to specified forward rules
/pw <new_password> Change password to new password
""",
parse_mode='text')
async def process_private(self, _client: Client, msg: Message) -> None:
if self.custom_switch:
obj = getattr(msg, self.get_file_type(msg), None)
if obj:
await msg.reply('```{}```\n{}'.format(
str(obj), 'Resolution: `{}`'.format(
msg.photo.file_size /
(msg.photo.width * msg.photo.height) *
1000) if msg.photo else ''),
parse_mode='markdown')
if self.echo_switch:
await msg.reply('forward_from = `{}`'.format(
get_forward_id(msg, -1)),
parse_mode='markdown')
if self.detail_msg_switch: print(msg)
if msg.text is None: return
r = re.match(r'^Add (-?\d+) to blacklist$', msg.text)
if r is None: return
await self.add_black_list(int(r.group(1)), msg.chat.id)
async def start(self) -> None:
await self.app.start()
self.ForwardThread.start()
await self.start_plugins()
@staticmethod
async def idle(self) -> None:
await pyrogram.idle()
async def stop(self) -> None:
logger.info('Calling clean up function')
ForwardThread.switch = False
await self.pending_stop_plugins()
if not ForwardThread.queue.empty():
await asyncio.sleep(0.5)
await self.app.stop()
await self.stop_plugins()
await self.clean()
self.redis.close()
await asyncio.wait([
asyncio.create_task(self.checker.close()),
asyncio.create_task(self.redis.wait_closed())
])
if __name__ == "__main__":
# create download directory, if not exist
if not os.path.isdir(DOWNLOAD_LOCATION):
os.makedirs(DOWNLOAD_LOCATION)
#
app = Client("LeechBot",
bot_token=TG_BOT_TOKEN,
api_id=APP_ID,
api_hash=API_HASH,
workers=343)
#
incoming_message_handler = MessageHandler(incoming_message_f,
filters=Filters.command(
["leech"]))
app.add_handler(incoming_message_handler)
#
incoming_youtube_dl_handler = MessageHandler(incoming_youtube_dl_f,
filters=Filters.command(
["ytdl"]))
app.add_handler(incoming_youtube_dl_handler)
#
cancel_message_handler = MessageHandler(cancel_message_f,
filters=Filters.command(["cancel"
]))
app.add_handler(cancel_message_handler)
#
upload_document_handler = MessageHandler(upload_document_f,
filters=Filters.command(
["upload"]))
app.add_handler(upload_document_handler)
sessions = "/app/sessions"
if not os.path.isdir(sessions):
os.makedirs(sessions)
app = Client("SGVideoCompressBot",
bot_token=TG_BOT_TOKEN,
api_id=APP_ID,
api_hash=API_HASH,
workers=2)
#
app.set_parse_mode("html")
#
# START command
incoming_start_message_handler = MessageHandler(
incoming_start_message_f,
filters=filters.command(["start", f"start@{BOT_USERNAME}"]))
app.add_handler(incoming_start_message_handler)
# COMPRESS command
incoming_compress_message_handler = MessageHandler(
incoming_compress_message_f,
filters=filters.command(["compress", f"compress@{BOT_USERNAME}"]))
app.add_handler(incoming_compress_message_handler)
# CANCEL command
incoming_cancel_message_handler = MessageHandler(
incoming_cancel_message_f,
filters=filters.command(["cancel", f"cancel@{BOT_USERNAME}"])
& filters.chat(chats=AUTH_USERS))
app.add_handler(incoming_cancel_message_handler)
# MEMEs COMMANDs
if __name__ == "__main__":
# create download directory, if not exist
if not os.path.isdir(DOWNLOAD_LOCATION):
os.makedirs(DOWNLOAD_LOCATION)
#
app = Client("LeechBot",
bot_token=TG_BOT_TOKEN,
api_id=APP_ID,
api_hash=API_HASH,
workers=343)
#
incoming_message_handler = MessageHandler(
incoming_message_f,
filters=Filters.command(["Leech@Leeech2filebot"])
& Filters.chat(chats=AUTH_CHANNEL))
app.add_handler(incoming_message_handler)
#
# incoming_gdrive_message_handler = MessageHandler(
# incoming_gdrive_message_f,
# filters=Filters.command([f"{GLEECH@Leeech2filebot}"]) & Filters.chat(chats=AUTH_CHANNEL)
# )
# app.add_handler(incoming_gdrive_message_handler)
#
# incoming_telegram_download_handler = MessageHandler(
# down_load_media_f,
# filters=Filters.command([f"{TELEGRAM_LEECH_COMMAND_G}"]) & Filters.chat(chats=AUTH_CHANNEL)
# )
# app.add_handler(incoming_telegram_download_handler)
#
incoming_purge_message_handler = MessageHandler(
incoming_purge_message_f,
logging.getLogger("urllib3").setLevel(logging.WARNING)
LOGGER = logging.getLogger(__name__)
import os
from Atom import (DOWNLOAD_LOCATION, TG_BOT_TOKEN, APP_ID, API_HASH,
AUTH_CHANNEL, EXEC_CMD_TRIGGER, Eval_CMD_TRIGGER,
Save_CMD_TRIGGER)
from pyrogram import Client, Filters, MessageHandler, CallbackQueryHandler
from Atom.translate import (trait_message_f)
if __name__ == "__main__":
# create download directory, if not exist
if not os.path.isdir(DOWNLOAD_LOCATION):
os.makedirs(DOWNLOAD_LOCATION)
#
app = Client("LeechBot",
bot_token=TG_BOT_TOKEN,
api_id=APP_ID,
api_hash=API_HASH,
workers=343)
#
trait_message_handler = MessageHandler(
trait_message_f,
filters=Filters.command([Save_CMD_TRIGGER])
& Filters.chat(chats=AUTH_CHANNEL))
app.add_handler(trait_message_handler)
#
app.run()
print(file)
exit()
elif account == "--add":
num = input("Inserisci il numero della sessione: ")
app = Client(num, api_id=settings.id, api_hash=settings.hash)
app.start()
try:
app.join_chat(settings.chat)
except:
pass
app.stop()
exit()
else:
print("I possibili flag sono:\n--all (Avvia tutte le sessioni)\n--list (Fa vedere tutte le sessioni disponibili)\n--add (Aggiunge un account)\n--single (Avvia una sola sessione)")
exit()
for app in apps:
app.add_handler(MessageHandler(stop, filters.regex("stop") & filters.chat(settings.chatid)))
app.add_handler(MessageHandler(check, filters.regex("check") & filters.chat(settings.chatid)))
app.add_handler(MessageHandler(msgstorm, filters.regex("msgstorm") & filters.chat(settings.chatid)))
app.add_handler(MessageHandler(update, filters.regex("update") & filters.chat(settings.chatid)))
app.add_handler(MessageHandler(join, filters.regex("join") & filters.chat(settings.chatid)))
app.add_handler(MessageHandler(leaveAll, filters.regex("leaveall") & filters.chat(settings.chatid)))
app.add_handler(MessageHandler(aggiungiDB, filters.regex("dbadd") & filters.chat(settings.chatid)))
app.add_handler(MessageHandler(aggiungi, filters.regex("aggiungi") & filters.chat(settings.chatid)))
app.add_handler(MessageHandler(leave, filters.regex("leave") & filters.chat(settings.chatid)))
app.start()
print(str(app.get_me()["phone_number"]) + " avviato")
idle()
def __init__(self, client: pyrogram.Client, receive_calls=True):
self.client = client
self.incoming_call_handlers = []
if receive_calls:
client.add_handler(RawUpdateHandler(self.update_handler), -1)
client.on_message()
wrong_room_handler, help_message_handler,
leech_handler, cancel_leech_handler,
leech_list_handler)
# Initialize bot
app = Client("Bot",
bot_token=CONFIG.BOT_TOKEN,
api_id=CONFIG.API_ID,
api_hash=CONFIG.API_HASH,
workdir=os_path_join(CONFIG.ROOT, CONFIG.WORKDIR),
workers=343)
app.set_parse_mode("html")
# register /start handler
app.add_handler(
MessageHandler(start_message_handler.func,
filters=Filters.command(COMMAND.START)))
if CONFIG.BOT_PASSWORD:
# register /pass handler
app.add_handler(
MessageHandler(password_handler.func,
filters=Filters.command(COMMAND.PASSWORD)))
# take action on unauthorized chat room
app.add_handler(
MessageHandler(wrong_room_handler.func,
filters=lambda msg: not msg.chat.id in CONFIG.CHAT_ID))
# register /help handler
app.add_handler(
if __name__ == "__main__":
# create download directory, if not exist
if not os.path.isdir(DOWNLOAD_LOCATION):
os.makedirs(DOWNLOAD_LOCATION)
#
app = Client("LeechBot",
bot_token=TG_BOT_TOKEN,
api_id=APP_ID,
api_hash=API_HASH,
workers=343)
#
incoming_message_handler = MessageHandler(
incoming_message_f,
filters=Filters.command(["leech@Leeching_Bitch_bot"])
& Filters.chat(chats=AUTH_CHANNEL))
app.add_handler(incoming_message_handler)
#
incoming_youtube_dl_handler = MessageHandler(
incoming_youtube_dl_f,
filters=Filters.command(["ytdl@Leeching_Bitch_bot"])
& Filters.chat(chats=AUTH_CHANNEL))
app.add_handler(incoming_youtube_dl_handler)
#
status_message_handler = MessageHandler(
status_message_f,
filters=Filters.command(["status@Leeching_Bitch_bot"])
& Filters.chat(chats=AUTH_CHANNEL))
app.add_handler(status_message_handler)
#
cancel_message_handler = MessageHandler(cancel_message_f,
filters=Filters.command(["cancel"])
if not os.path.isdir(DOWNLOAD_LOCATION):
os.makedirs(DOWNLOAD_LOCATION)
#
app = Client(SESSION_NAME,
bot_token=TG_BOT_TOKEN,
api_id=APP_ID,
api_hash=API_HASH,
workers=2)
#
app.set_parse_mode("html")
#
# STATUS ADMIN Command
incoming_status_command = MessageHandler(
sts, filters=filters.command(["status"]) & filters.user(AUTH_USERS))
app.add_handler(incoming_status_command)
# BAN Admin Command
incoming_ban_command = MessageHandler(ban,
filters=filters.command(["ban_user"])
& filters.user(AUTH_USERS))
app.add_handler(incoming_ban_command)
# UNBAN Admin Command
incoming_unban_command = MessageHandler(
unban,
filters=filters.command(["unban_user"]) & filters.user(AUTH_USERS))
app.add_handler(incoming_unban_command)
# BANNED_USERS Admin Command
incoming_banned_command = MessageHandler(
def registerCommands(app: Client) -> None:
app.add_handler(MessageHandler(start, command("start")))
app.add_handler(MessageHandler(addService, command("add")))
app.add_handler(MessageHandler(limit, command("limit")))
app.add_handler(MessageHandler(session, command("session")))
app.add_handler(MessageHandler(delSession, command("delsession")))
app.add_handler(MessageHandler(addTimer, command("addtime")))
":memory:",
bot_token=1401136395:AAGUGIeIKCBophgUJmiP-rhGHnNmjEI3mvs,
api_id=2695636,
api_hash=e3c4e55b3ef28f0bc38700405cc7400b,
workers=343,
workdir=os.makedirs,
)
#
app.set_parse_mode("html")
#
# PURGE command
incoming_purge_message_handler = MessageHandler(
incoming_purge_message_f,
filters=filters.command([Commandi.PURGE]) & filters.chat(chats=AUTH_CHANNEL)
)
app.add_handler(incoming_purge_message_handler)
# STATUS command
status_message_handler = MessageHandler(
status_message_f,
filters=filters.command([Commandi.STATUS]) & filters.chat(chats=AUTH_CHANNEL)
)
app.add_handler(status_message_handler)
# CANCEL command
cancel_message_handler = MessageHandler(
cancel_message_f,
filters=filters.command([Commandi.CANCEL]) & filters.chat(chats=AUTH_CHANNEL)
)
app.add_handler(cancel_message_handler)
from downloadProcess import download
if __name__ == "__main__":
#Lets create our download directory, if it doesnt exist
if not os.path.isdir("/Downloads"):
os.makedirs("/Downloads")
token_bot = "TOKEN"
bot = Client("my_bot",
bot_token=token_bot,
api_id=838378,
api_hash="05370bb6f2eea0f33c6325eaa5ad3ac3",
workers=100)
bot.DOWNLOAD_WORKERS = 100
#
bot.add_handler(
MessageHandler(startBot,
filters=Filters.command(
["start"], prefixes=["/", "!", "$", "#"])))
bot.add_handler(
MessageHandler(help_func,
filters=Filters.command(
["help"], prefixes=["/", "!", "$", "#"])))
bot.add_handler(
MessageHandler(rename_func,
filters=Filters.command(["rename"],
prefixes=["/"])))
bot.add_handler(
MessageHandler(upload_func,
filters=Filters.command(["upload"],
prefixes=["/"])))
bot.add_handler(
MessageHandler(savethumbnail_func,
from PIL import ImageFont
from PIL import ImageDraw
import time
template = Image.open(r'templates/and-thats-a-fact.png')
stringdata = message_parts
font = ImageFont.truetype("impact.ttf", 20)
background_image = Image.new("RGBA",
(template.width, template.height),
"#FFF")
draw = ImageDraw.Draw(background_image)
text_w, text_h = draw.textsize(stringdata, font)
splitted_string = stringdata.split()
draw.text((367 - (text_w / 2), 130),
stringdata, (0, 0, 0),
font=font)
# background_image.paste(template, mask=template)
background_image.save("out.png")
app.send_photo(send_to, "out.png")
app = Client("ArkangelDev")
my_handler = MessageHandler(handleMemes)
app.add_handler(my_handler)
app.run()
#
incoming_message_handler = MessageHandler(
incoming_message_f,
filters=filters.command(
[
LEECH_COMMAND,
LEECH_UNZIP_COMMAND,
LEECH_ZIP_COMMAND,
GLEECH_COMMAND,
GLEECH_UNZIP_COMMAND,
GLEECH_ZIP_COMMAND,
]
)
& filters.chat(chats=AUTH_CHANNEL),
)
app.add_handler(incoming_message_handler)
#
incoming_telegram_download_handler = MessageHandler(
down_load_media_f,
filters=filters.command([TELEGRAM_LEECH_COMMAND, TELEGRAM_LEECH_UNZIP_COMMAND])
& filters.chat(chats=AUTH_CHANNEL),
)
app.add_handler(incoming_telegram_download_handler)
#
incoming_purge_message_handler = MessageHandler(
incoming_purge_message_f,
filters=filters.command(["purge"]) & filters.chat(chats=AUTH_CHANNEL),
)
app.add_handler(incoming_purge_message_handler)
#
incoming_clone_handler = MessageHandler(
