async def click(self,
pattern: Pattern,
filters: Filter = None,
quote: bool = False) -> "Response":
"""
Uses `find_button` with the given `pattern`, clicks the button if found, and waits for the bot to react. For
a `ReplyKeyboard`, this means that a message with the button's caption will be sent to the same chat.
If not button could be found, `NoButtonFound` will be raised.
Args:
pattern: The button caption to look for (by `re.match`).
filters: Additional filters to be given to `collect`. Will be merged with a "same chat" filter and
`filters.text | filters.edited`.
quote: Whether to reply to the message containing the buttons.
Returns:
The bot's `Response`.
"""
button = self.find_button(pattern)
filters = (filters & f.chat(self._peer_id)
if filters else f.chat(self._peer_id)) & (f.text | f.edited)
async with self._controller.collect(
filters=filters) as res: # type: Response
await self._controller.client.send_message(
self._controller.peer,
button.text if hasattr(button, "text") else button,
reply_to_message_id=self._message_id if quote else None,
)
return res
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
def prepare(self):
admin_filter = filters.chat(self._config.admins) & filters.private
self._mtproto.register(
MessageHandler(self._new_document,
filters.document & admin_filter))
self._mtproto.register(
MessageHandler(self._new_document, filters.video & admin_filter))
self._mtproto.register(
MessageHandler(self._new_document, filters.audio & admin_filter))
self._mtproto.register(
MessageHandler(self._new_document,
filters.animation & admin_filter))
self._mtproto.register(
MessageHandler(self._new_document, filters.voice & admin_filter))
self._mtproto.register(
MessageHandler(self._new_document,
filters.video_note & admin_filter))
admin_filter_inline = create(
lambda _, __, m: m.from_user.id in self._config.admins)
self._mtproto.register(
CallbackQueryHandler(self._device_player_function,
admin_filter_inline))
state_filter = create(lambda _, __, m: self._state_machine.get_state(m)
[0] == States.SELECT)
self._mtproto.register(
MessageHandler(self._select_device,
filters.text & admin_filter & state_filter))
async def click(
self,
pattern: Union[Pattern, str] = None,
index: Optional[int] = None,
) -> "Response":
"""
Uses `find_button` with the given `pattern` or `index`, clicks the button if found, and waits for the bot
to react in the same chat.
If not button could be found, `NoButtonFound` will be raised.
Args:
pattern: The button caption to look for (by `re.match`).
index: The index of the button, couting from top left to bottom right and starting at 0.
Returns:
The bot's `Response`.
"""
button = self.find_button(pattern, index)
async with self._controller.collect(
filters=f.chat(self._peer_id)) as res: # type: Response
logger.debug(f"Clicking button with caption '{button.text}'...")
await self._controller.client.request_callback_answer(
chat_id=self._peer_id,
message_id=self._message_id,
callback_data=button.callback_data,
timeout=30,
)
return res
async def ping_bot(
self,
bot: Union[int, str],
override_messages: List[str] = None,
max_wait_response: float = None,
min_wait_consecutive: float = None,
) -> Union[Response, bool]:
messages = ["/start"]
if override_messages:
messages = override_messages
async def send_pings():
for n, m in enumerate(messages):
try:
if n >= 1:
await asyncio.sleep(1)
await self.send_message(bot, m)
except FloodWait as e:
if e.x > 5:
self.logger.warning("send_message flood: waiting {} seconds".format(e.x))
await asyncio.sleep(e.x)
continue
action = AwaitableAction(
send_pings,
filters=chat(bot),
max_wait=max_wait_response,
min_wait_consecutive=min_wait_consecutive,
)
return await self.act_await_response(action)
def __init__(self, client: Client, key: str):
self.client = client
self.key = key
self.future: Optional[concurrent.futures.Future] = None
self.handler = MessageHandler(
self.message_handler,
filters.chat(Players.WEREWOLF_BOT_ID) & filters.text)
class Config:
""" Configs to setup Userge """
API_ID = int(os.environ.get("API_ID"))
API_HASH = os.environ.get("API_HASH")
WORKERS = min(32, int(os.environ.get("WORKERS")) or os.cpu_count() + 4)
BOT_TOKEN = os.environ.get("BOT_TOKEN", None)
HU_STRING_SESSION = os.environ.get("HU_STRING_SESSION", None)
OWNER_ID = int(os.environ.get("OWNER_ID", 0))
LOG_CHANNEL_ID = int(os.environ.get("LOG_CHANNEL_ID"))
DB_URI = os.environ.get("DATABASE_URL")
LANG = os.environ.get("PREFERRED_LANGUAGE")
DOWN_PATH = os.environ.get("DOWN_PATH")
CMD_TRIGGER = os.environ.get("CMD_TRIGGER")
SUDO_TRIGGER = os.environ.get("SUDO_TRIGGER")
FINISHED_PROGRESS_STR = os.environ.get("FINISHED_PROGRESS_STR")
UNFINISHED_PROGRESS_STR = os.environ.get("UNFINISHED_PROGRESS_STR")
ALIVE_MEDIA = os.environ.get("ALIVE_MEDIA", None)
CUSTOM_PACK_NAME = os.environ.get("CUSTOM_PACK_NAME")
UPSTREAM_REPO = os.environ.get("UPSTREAM_REPO")
UPSTREAM_REMOTE = os.environ.get("UPSTREAM_REMOTE")
SCREENSHOT_API = os.environ.get("SCREENSHOT_API", None)
SPAM_WATCH_API = os.environ.get("SPAM_WATCH_API", None)
CURRENCY_API = os.environ.get("CURRENCY_API", None)
OCR_SPACE_API_KEY = os.environ.get("OCR_SPACE_API_KEY", None)
OPEN_WEATHER_MAP = os.environ.get("OPEN_WEATHER_MAP", None)
REMOVE_BG_API_KEY = os.environ.get("REMOVE_BG_API_KEY", None)
WEATHER_DEFCITY = os.environ.get("WEATHER_DEFCITY", None)
TZ_NUMBER = os.environ.get("TZ_NUMBER", 1)
G_DRIVE_CLIENT_ID = os.environ.get("G_DRIVE_CLIENT_ID", None)
G_DRIVE_CLIENT_SECRET = os.environ.get("G_DRIVE_CLIENT_SECRET", None)
G_DRIVE_PARENT_ID = os.environ.get("G_DRIVE_PARENT_ID", None)
G_DRIVE_INDEX_LINK = os.environ.get("G_DRIVE_INDEX_LINK", None)
GOOGLE_CHROME_DRIVER = os.environ.get("GOOGLE_CHROME_DRIVER", None)
GOOGLE_CHROME_BIN = os.environ.get("GOOGLE_CHROME_BIN", None)
HEROKU_API_KEY = os.environ.get("HEROKU_API_KEY", None)
HEROKU_APP_NAME = os.environ.get("HEROKU_APP_NAME", None)
HEROKU_GIT_URL = os.environ.get("HEROKU_GIT_URL", None)
BOT_MEDIA = os.environ.get("BOT_MEDIA", None)
G_DRIVE_IS_TD = os.environ.get("G_DRIVE_IS_TD") == "true"
LOAD_UNOFFICIAL_PLUGINS = os.environ.get(
"LOAD_UNOFFICIAL_PLUGINS") == "true"
THUMB_PATH = DOWN_PATH + "thumb_image.jpg"
TMP_PATH = "userge/plugins/temp/"
MAX_MESSAGE_LENGTH = 4096
MSG_DELETE_TIMEOUT = 120
WELCOME_DELETE_TIMEOUT = 120
EDIT_SLEEP_TIMEOUT = 10
AUTOPIC_TIMEOUT = 300
ALLOWED_CHATS = filters.chat([])
ALLOW_ALL_PMS = True
USE_USER_FOR_CLIENT_CHECKS = False
SUDO_ENABLED = False
SUDO_USERS: Set[int] = set()
ALLOWED_COMMANDS: Set[str] = set()
ANTISPAM_SENTRY = False
RUN_DYNO_SAVER = False
HEROKU_APP = heroku3.from_key(HEROKU_API_KEY).apps()[HEROKU_APP_NAME] \
if HEROKU_API_KEY and HEROKU_APP_NAME else None
STATUS = None
BOT_FORWARDS = False
def _merge_default_filters(
self, user_filters: Filter = None, override_peer: Union[int, str] = None
) -> Filter:
chat_filter = filters.chat(override_peer or self.peer_id) & filters.incoming
if user_filters is None:
return chat_filter
else:
return user_filters & chat_filter
def start(signuper: Signuper):
@app.on_message(filters.chat('@telebot_ch'))
def from_saz(client, message):
if re.search('Поточний етап у САЗ', message.text) is not None:
signuper.execute()
app.stop()
app.run()
def prepare(self):
admin_filter = filters.chat(self._config.admins) & filters.private
self._mtproto.register(MessageHandler(self._new_document, filters.document & admin_filter))
self._mtproto.register(MessageHandler(self._new_document, filters.video & admin_filter))
self._mtproto.register(MessageHandler(self._new_document, filters.audio & admin_filter))
self._mtproto.register(MessageHandler(self._new_document, filters.animation & admin_filter))
self._mtproto.register(MessageHandler(self._new_document, filters.voice & admin_filter))
self._mtproto.register(MessageHandler(self._new_document, filters.video_note & admin_filter))
state_filter = create(lambda _, __, m: self._state_machine.get_state(m)[0] == States.SELECT)
self._mtproto.register(MessageHandler(self._select_device, filters.text & admin_filter & state_filter))
async def press_button_await(self,
pattern,
filters=None,
num_expected=None,
raise_=True,
quote=False) -> "Response":
button = self.find_button(pattern)
if filters:
filters = filters & chat(self._peer_id)
else:
filters = chat(self._peer_id)
filters = filters & (text | edited)
action = AwaitableAction(
func=self._client.send_message,
args=(self._peer_id, button),
kwargs=dict(
reply_to_message_id=self._message_id if quote else None),
filters=filters,
num_expected=num_expected,
)
return await self._client.act_await_response(action, raise_=raise_)
async def main():
await controller.initialize()
while True:
async with controller.collect(
f.chat("@TgIntegration"), max_wait=30
) as response:
await client.send_message(
"@TgIntegration",
"Hi @deerspangle! Please say something in the next 30 seconds...",
)
await client.send_message(
"@TgIntegration",
"You did not reply :("
if response.is_empty
else f"You replied with: {response.full_text}",
)
def init_message_handler(self) -> None:
if self._listen_to_group[0] == 0:
raise ValueError('listen_to_group value must be set')
self.client_group[0].add_handler(
MessageHandler(
self.handle_set_target,
filters.chat(self.owner) & filters.command('target')))
self.client_group[0].add_handler(
MessageHandler(
self.handle_resend_command,
filters.user(self.owner) & filters.chat(self._listen_to_group)
& filters.command('resend')))
self.client_group[0].add_handler(
MessageHandler(self.handle_toggle_debug_command,
filters.chat(self.owner)
& filters.command('debug')))
self.client_group[0].add_handler(
MessageHandler(
self.handle_normal_resident,
filters.chat(self._listen_to_group)
& filters.user(self.WEREWOLF_BOT_ID) & filters.text))
self.client_group[0].add_handler(
MessageHandler(
self.handle_join_game,
filters.chat(self._listen_to_group)
& filters.user(self.WEREWOLF_BOT_ID)))
self.client_group[0].add_handler(
MessageHandler(
self.handle_close_auto_join,
filters.chat(self._listen_to_group) & filters.command('off')))
self.client_group[0].add_handler(
MessageHandler(
self.handle_set_num_worker,
filters.chat(self._listen_to_group) & filters.command('setw')))
for x in self.client_group:
x.add_handler(
MessageHandler(
self.handle_werewolf_game,
filters.chat(self.WEREWOLF_BOT_ID) & filters.incoming))
logger.debug('Current workers: %d', len(self.client_group))
async def press_button_await(
self,
pattern: Union[Pattern, str] = None,
index: Optional[int] = None,
num_expected: Optional[int] = None,
max_wait: float = 8,
min_wait_consecutive: float = 1.5,
raise_: Optional[bool] = True,
):
button = self.find_button(pattern, index)
action = AwaitableAction(
func=self._client.press_inline_button,
args=(self._peer_id, self._message_id, button.callback_data),
filters=chat(self._peer_id),
num_expected=num_expected,
max_wait=max_wait,
min_wait_consecutive=min_wait_consecutive,
)
return await self._client.act_await_response(action, raise_=raise_)
'''
This snippet deletes incoming text messages using filters to delete just text messages from specific groups and user ids
'''
from pyrogram import Client, filters
USER_LIST_IDS = []
GROUP_IDS = []
app = Client("client")
@app.on_message(filters.text & filters.chat(GROUP_IDS) & filters.user(USER_LIST_IDS))
def delete_message(client, message):
try:
app.delete_messages(
chat_id=message.chat.id,
message_ids=message.message_id
)
except Exception as e:
print(e)
pass
app.run()
class Config:
""" Configs to setup Userge """
API_ID = int(os.environ.get("API_ID"))
API_HASH = os.environ.get("API_HASH")
WORKERS = int(os.environ.get("WORKERS")) or os.cpu_count() + 4
BOT_TOKEN = os.environ.get("BOT_TOKEN", None)
HU_STRING_SESSION = os.environ.get("HU_STRING_SESSION", None)
OWNER_ID = tuple(
filter(lambda x: x, map(int,
os.environ.get("OWNER_ID", "0").split())))
LOG_CHANNEL_ID = int(os.environ.get("LOG_CHANNEL_ID"))
AUTH_CHATS = (OWNER_ID[0],
LOG_CHANNEL_ID) if OWNER_ID else (LOG_CHANNEL_ID, )
DB_URI = os.environ.get("DATABASE_URL")
LANG = os.environ.get("PREFERRED_LANGUAGE")
DOWN_PATH = os.environ.get("DOWN_PATH")
CMD_TRIGGER = os.environ.get("CMD_TRIGGER")
SUDO_TRIGGER = os.environ.get("SUDO_TRIGGER")
FINISHED_PROGRESS_STR = os.environ.get("FINISHED_PROGRESS_STR")
UNFINISHED_PROGRESS_STR = os.environ.get("UNFINISHED_PROGRESS_STR")
ALIVE_MEDIA = os.environ.get("ALIVE_MEDIA", None)
CUSTOM_PACK_NAME = os.environ.get("CUSTOM_PACK_NAME")
INSTA_ID = os.environ.get("INSTA_ID")
INSTA_PASS = os.environ.get("INSTA_PASS")
UPSTREAM_REPO = os.environ.get("UPSTREAM_REPO")
UPSTREAM_REMOTE = os.environ.get("UPSTREAM_REMOTE")
SPAM_WATCH_API = os.environ.get("SPAM_WATCH_API", None)
CURRENCY_API = os.environ.get("CURRENCY_API", None)
OCR_SPACE_API_KEY = os.environ.get("OCR_SPACE_API_KEY", None)
OPEN_WEATHER_MAP = os.environ.get("OPEN_WEATHER_MAP", None)
REMOVE_BG_API_KEY = os.environ.get("REMOVE_BG_API_KEY", None)
WEATHER_DEFCITY = os.environ.get("WEATHER_DEFCITY", None)
TZ_NUMBER = os.environ.get("TZ_NUMBER", 1)
G_DRIVE_CLIENT_ID = os.environ.get("G_DRIVE_CLIENT_ID", None)
G_DRIVE_CLIENT_SECRET = os.environ.get("G_DRIVE_CLIENT_SECRET", None)
G_DRIVE_PARENT_ID = os.environ.get("G_DRIVE_PARENT_ID", None)
G_DRIVE_INDEX_LINK = os.environ.get("G_DRIVE_INDEX_LINK", None)
GOOGLE_CHROME_DRIVER = os.environ.get("GOOGLE_CHROME_DRIVER", None)
GOOGLE_CHROME_BIN = os.environ.get("GOOGLE_CHROME_BIN", None)
HEROKU_API_KEY = os.environ.get("HEROKU_API_KEY", None)
HEROKU_APP_NAME = os.environ.get("HEROKU_APP_NAME", None)
G_DRIVE_IS_TD = os.environ.get("G_DRIVE_IS_TD") == "true"
LOAD_UNOFFICIAL_PLUGINS = os.environ.get(
"LOAD_UNOFFICIAL_PLUGINS") == "true"
THUMB_PATH = DOWN_PATH + "thumb_image.jpg"
TMP_PATH = "userge/plugins/temp/"
MAX_MESSAGE_LENGTH = 4096
MSG_DELETE_TIMEOUT = 120
WELCOME_DELETE_TIMEOUT = 120
EDIT_SLEEP_TIMEOUT = 10
AUTOPIC_TIMEOUT = 300
ALLOWED_CHATS = filters.chat([])
ALLOW_ALL_PMS = True
USE_USER_FOR_CLIENT_CHECKS = False
SUDO_ENABLED = False
SUDO_USERS: Set[int] = set()
DISABLED_ALL = False
DISABLED_CHATS: Set[int] = set()
ALLOWED_COMMANDS: Set[str] = set()
ANTISPAM_SENTRY = False
RUN_DYNO_SAVER = False
HEROKU_APP = heroku3.from_key(HEROKU_API_KEY).apps()[HEROKU_APP_NAME] \
if HEROKU_API_KEY and HEROKU_APP_NAME else None
STATUS = None
BOT_FORWARDS = False
BOT_MEDIA = os.environ.get("BOT_MEDIA", None)
### Spotify
SPOTIFY_CLIENT_ID = os.environ.get('SPOTIFY_CLIENT_ID', None)
SPOTIFY_CLIENT_SECRET = os.environ.get('SPOTIFY_CLIENT_SECRET', None)
SPOTIFY_MODE = False
### MEME Generator
IMGFLIP_ID = os.environ.get('IMGFLIP_ID', None)
IMGFLIP_PASS = os.environ.get('IMGFLIP_PASS', None)
ALLOW_NSFW = os.environ.get("ALLOW_NSFW", "False")
PM_LOG_GROUP_ID = int(os.environ.get("PM_LOG_GROUP_ID", 0))
PM_LOGGING = False
DEEP_AI = os.environ.get("DEEP_AI", None)
### Last FM
LASTFM_USERNAME = os.environ.get("LASTFM_USERNAME", None)
LASTFM_API_KEY = os.environ.get("LASTFM_API_KEY", None)
TG_IDS = [777000, 1087968824, 454000]
INLINE_NOTES = False
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
exec_message_handler = MessageHandler(
exec_message_f,
filters=filters.command(["exec", f"exec@{BOT_USERNAME}"])
& filters.chat(chats=AUTH_USERS))
app.add_handler(exec_message_handler)
# HELP command
help_text_handler = MessageHandler(help_message_f,
filters=filters.command(
["help", f"help@{BOT_USERNAME}"]))
app.add_handler(help_text_handler)
chat_joined = False # Tell if chat is joined or not
# Pyrogram Client
if not HEROKU:
app = Client("tgvc", api_id=api_id, api_hash=api_hash)
else:
app = Client(SESSION_STRING, api_id=api_id, api_hash=api_hash)
# Pytgcalls Client
vc = GroupCall(app, input_filename="input.raw", play_on_repeat=True)
# Arq Client
arq = ARQ(ARQ_API)
@app.on_message(filters.command("start") & filters.chat(sudo_chat_id))
async def start(_, message):
await send(START_TEXT)
@app.on_message(filters.command("help") & filters.chat(sudo_chat_id))
async def help(_, message):
await send(HELP_TEXT)
@app.on_message(filters.command("repo") & filters.chat(sudo_chat_id))
async def repo(_, message):
await send(REPO_TEXT)
@app.on_message(filters.command("joinvc") & filters.user(owner_id))
elif service == "deezer":
print(f"Playing {song} via {service}")
playing = True
del queue[0]
try:
await deezer(requested_by, song)
except Exception as e:
print(str(e))
pass
# Queue Append
@app.on_message(
filters.command("play") & filters.chat(sudo_chat_id) & ~filters.edited)
async def queuer(_, message):
if message.from_user.id in blacks:
return
if len(message.command) < 3:
await message.reply_text(
"**Usage:**\n/play youtube/saavn/deezer [song_name]")
return
await message.delete()
text = message.text.split(None, 2)[1:]
service = text[0]
song_name = text[1]
requested_by = message.from_user.first_name
services = ["youtube", "deezer", "saavn"]
if service not in services:
await app.send_message(
os.makedirs(DOWNLOAD_LOCATION)
#
app = Client(":memory:",
bot_token=TG_BOT_TOKEN,
api_id=APP_ID,
api_hash=API_HASH,
workers=343,
workdir=DOWNLOAD_LOCATION)
#
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)
# along with this program. If not, see <https://github.com/SpEcHiDe/TerminalBot/blob/Pyrogram/COPYING>.
import io
import os
import sys
import traceback
from pyrogram import (Client, filters)
from pyrogram.types import Message
from bot import (AUTHORIZED_CHATS)
from bot.helper.telegram_helper.bot_commands import BotCommands
@Client.on_message(
filters.command(BotCommands.EvalCommand) & filters.chat(AUTHORIZED_CHATS))
def evaluation_cmd_t(client, message: Message):
PROCESS_RUNNING = "..."
status_message = message.reply_text(PROCESS_RUNNING, quote=True)
cmd = message.text.split(" ", maxsplit=1)[1]
old_stderr = sys.stderr
old_stdout = sys.stdout
redirected_output = sys.stdout = io.StringIO()
redirected_error = sys.stderr = io.StringIO()
stdout, stderr, exc = None, None, None
try:
aexec(cmd, client, message)
except Exception:
class Config:
""" Configs to setup Userge """
API_ID = int(os.environ.get("API_ID"))
API_HASH = os.environ.get("API_HASH")
WORKERS = int(os.environ.get("WORKERS")) or os.cpu_count() + 4
BOT_TOKEN = os.environ.get("BOT_TOKEN")
HU_STRING_SESSION = os.environ.get("HU_STRING_SESSION")
OWNER_ID = tuple(
filter(lambda x: x, map(int,
os.environ.get("OWNER_ID", "0").split())))
LOG_CHANNEL_ID = int(os.environ.get("LOG_CHANNEL_ID"))
AUTH_CHATS = (OWNER_ID[0],
LOG_CHANNEL_ID) if OWNER_ID else (LOG_CHANNEL_ID, )
DB_URI = os.environ.get("DATABASE_URL")
LANG = os.environ.get("PREFERRED_LANGUAGE")
DOWN_PATH = os.environ.get("DOWN_PATH")
CMD_TRIGGER = os.environ.get("CMD_TRIGGER")
SUDO_TRIGGER = os.environ.get("SUDO_TRIGGER")
FINISHED_PROGRESS_STR = os.environ.get("FINISHED_PROGRESS_STR")
UNFINISHED_PROGRESS_STR = os.environ.get("UNFINISHED_PROGRESS_STR")
ALIVE_MEDIA = os.environ.get("ALIVE_MEDIA")
CUSTOM_PACK_NAME = os.environ.get("CUSTOM_PACK_NAME")
UPSTREAM_REPO = os.environ.get("UPSTREAM_REPO")
UPSTREAM_REMOTE = os.environ.get("UPSTREAM_REMOTE")
USERGE_ANTISPAM_API = os.environ.get("USERGE_ANTISPAM_API")
SPAM_WATCH_API = os.environ.get("SPAM_WATCH_API")
CURRENCY_API = os.environ.get("CURRENCY_API")
OCR_SPACE_API_KEY = os.environ.get("OCR_SPACE_API_KEY")
OPEN_WEATHER_MAP = os.environ.get("OPEN_WEATHER_MAP")
REMOVE_BG_API_KEY = os.environ.get("REMOVE_BG_API_KEY")
WEATHER_DEFCITY = os.environ.get("WEATHER_DEFCITY")
TZ_NUMBER = os.environ.get("TZ_NUMBER", 1)
MAX_DURATION = int(os.environ.get("MAX_DURATION", 900))
G_DRIVE_CLIENT_ID = os.environ.get("G_DRIVE_CLIENT_ID")
G_DRIVE_CLIENT_SECRET = os.environ.get("G_DRIVE_CLIENT_SECRET")
G_DRIVE_PARENT_ID = os.environ.get("G_DRIVE_PARENT_ID")
G_DRIVE_INDEX_LINK = os.environ.get("G_DRIVE_INDEX_LINK")
GOOGLE_CHROME_DRIVER = os.environ.get("GOOGLE_CHROME_DRIVER")
GOOGLE_CHROME_BIN = os.environ.get("GOOGLE_CHROME_BIN")
HEROKU_ENV = bool(int(os.environ.get("HEROKU_ENV", "0")))
HEROKU_API_KEY = os.environ.get("HEROKU_API_KEY")
HEROKU_APP_NAME = os.environ.get("HEROKU_APP_NAME")
G_DRIVE_IS_TD = os.environ.get("G_DRIVE_IS_TD") == "true"
LOAD_UNOFFICIAL_PLUGINS = os.environ.get(
"LOAD_UNOFFICIAL_PLUGINS") == "true"
ASSERT_SINGLE_INSTANCE = os.environ.get("ASSERT_SINGLE_INSTANCE") == "true"
THUMB_PATH = DOWN_PATH + "thumb_image.jpg"
TMP_PATH = "userge/plugins/temp/"
MAX_MESSAGE_LENGTH = 4096
MSG_DELETE_TIMEOUT = 120
WELCOME_DELETE_TIMEOUT = 120
EDIT_SLEEP_TIMEOUT = 10
AUTOPIC_TIMEOUT = 300
ALLOWED_CHATS = filters.chat([])
ALLOW_ALL_PMS = True
USE_USER_FOR_CLIENT_CHECKS = False
SUDO_ENABLED = False
SUDO_USERS: Set[int] = set()
DISABLED_ALL = False
DISABLED_CHATS: Set[int] = set()
ALLOWED_COMMANDS: Set[str] = set()
ANTISPAM_SENTRY = False
RUN_DYNO_SAVER = False
HEROKU_APP = heroku3.from_key(HEROKU_API_KEY).apps()[HEROKU_APP_NAME] \
if HEROKU_ENV and HEROKU_API_KEY and HEROKU_APP_NAME else None
STATUS = None
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))
import ffmpeg
from opencc import OpenCC
from config import MUSIC_CHATS, MUSIC_USERS, MUSIC_DELAY_DELETE_INFORM
from config import MUSIC_INFORM_AVAILABILITY, MUSIC_MAX_LENGTH
TG_THUMB_MAX_LENGTH = 320
REGEX_SITES = (r"^((?:https?:)?\/\/)"
r"?((?:www|m)\.)"
r"?((?:youtube\.com|youtu\.be|soundcloud\.com|mixcloud\.com))"
r"(\/)([-a-zA-Z0-9()@:%_\+.~#?&//=]*)([\w\-]+)(\S+)?$")
REGEX_EXCLUDE_URL = (r"\/channel\/|\/playlist\?list=|&list=|\/sets\/")
s2tw = OpenCC('s2tw.json').convert
@Client.on_message(filters.text
& (filters.chat(MUSIC_CHATS) | filters.private)
& filters.incoming
& filters.regex(REGEX_SITES)
& ~filters.regex(REGEX_EXCLUDE_URL)
& ~filters.edited)
async def music_downloader(client, message: Message):
"""Add members of specified chats to the list when it's a private
chat
"""
# print(' '.join([str(u) for u in MUSIC_USERS]))
if message.chat.type == "private":
user_id = message.from_user.id
if user_id not in MUSIC_USERS:
for chat in MUSIC_CHATS:
try:
await client.get_chat_member(chat, user_id)
from info import START_MSG, CHANNELS, ADMINS, COLLECTION_NAME
from utils import Media, db
@Client.on_message(filters.command('start'))
async def start(bot, message):
"""Start command handler"""
buttons = [[
InlineKeyboardButton('Search Here', switch_inline_query_current_chat=''),
InlineKeyboardButton('Go Inline', switch_inline_query=''),
]]
reply_markup = InlineKeyboardMarkup(buttons)
await message.reply(START_MSG, reply_markup=reply_markup)
@Client.on_message(filters.command('channel') & filters.chat(ADMINS))
async def channel_info(bot, message):
"""Send basic information of channel"""
if isinstance(CHANNELS, (int, str)):
channels = [CHANNELS]
elif isinstance(CHANNELS, list):
channels = CHANNELS
else:
raise ValueError("Unexpected type of CHANNELS")
for channel in channels:
channel_info = await bot.get_chat(channel)
try:
await message.reply(str(channel_info))
except Exception as e:
@Client.on_message(filters.command(["start"]) & ~filters.edited)
async def start(_, message: Message):
if message.from_user.id in blacks():
await message.reply_text("You're Blacklisted, So Stop Spamming.")
return
await message.reply_text(
"Hi I'm Telegram Voice Chat Bot, Join @TheHamkerChat For Support.")
# Help
@Client.on_message(
filters.command(["help"]) & filters.chat(sudo_chat_id) & ~filters.edited)
async def help(_, message: Message):
if message.from_user.id in blacks():
await message.reply_text("You're Blacklisted, So Stop Spamming.")
return
await message.reply_text('''Currently These Commands Are Supported.
/start To Start The bot.
/help To Show This Message.
/ping To Ping All Datacenters Of Telegram.
/end To Stop Any Playing Music.
"/jiosaavn <song_name>" To Play A Song From Jiosaavn.
"/ytsearch <song_name>" To Search For A Song On Youtube.
"/youtube <song_link>" To Play A Song From Youtube.
"/playlist <youtube_playlist_url> To Play A Playlist From Youtube".
/radio To Play Radio Continuosly.
/black To Blacklist A User.
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import aiohttp
from pyrogram import Client, filters
from pyrogram.types import Message
NEKO = "> nekobin.com/{}.py"
ENDPOINT = "https://nekobin.com/api/documents"
ANSWER = "**Please use Nekobin for pastes.**\n"
TIMEOUT = 3
CHAT = filters.chat("PyrogramChat")
REGEX = filters.regex(
r"(https?://)?(www\.)?(?P<service>(p|h)asteb(\.?in|in\.com)|del\.dog|haste.thevillage.chat)/(raw/)?(?P<tag>\w+)"
# https://regex101.com/r/cl5iGU/3
)
FILTER = REGEX & CHAT & ~filters.edited
async def get_and_post(paste_url: str):
"""Get the pasted content from a paste service and repaste it to nekobin.
Returns a `str` of the key saved on nekobin or an error code as `int`.
"""
async with aiohttp.ClientSession() as session:
async with session.get(paste_url) as response:
try:
import requests
import asyncio
import os
from pyrogram import Client, filters
from pyrogram.types import Message
from config import jio_saavn_api, sudo_chat_id
from youtube_search import YoutubeSearch
# Ping
@Client.on_message(filters.command(["ping"]) & (filters.chat(sudo_chat_id)))
async def ping(_, message: Message):
j = await message.reply_text("Wait, Pinging all Datacenters`")
result = ""
for i in range(1, 6):
datacenter = (f"https://cdn{i}.telesco.pe")
ping1 = round(requests.head(datacenter).elapsed.total_seconds() * 1000)
result += f'`DC{i} - {ping1}ms`\n'
await j.edit(result)
# Start
@Client.on_message(filters.command(["start"]) & (filters.chat(sudo_chat_id)))
async def start(_, message: Message):
await message.reply_text(
"Hi I'm Telegram Voice Chat Bot, Pressing /help wen?")
#
app = Client(
":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)
)
continue
liste = liste + f"{i}.**Song:**`{qq[3]}` Via {qq[5]}- Requested by {qq[2]}\n"
return liste
async def getadmins(chat_id):
admins = []
async for i in app.iter_chat_members(chat_id, filter="administrators"):
admins.append(i.user.id)
admins.append(owner_id)
return admins
#Help ------------------------------------------------------------------------------------
@app.on_message(
filters.command(["help"]) & filters.chat(sudo_chat_id) & ~filters.edited)
async def help(_, message: Message):
await message.reply_text("""**Currently These Commands Are Supported.**
/help To Show This Message.
/skip To Skip Any Playing Music.
/queue To See Queue List.
/saavn "Song_Name" To Play A Song From Jiosaavn.
/playlist "saavn_playlist_link" To add all songs to Queue and Play.
/youtube "Song_Name" To Search For A Song And Play The Top-Most Song Or Play With A Link.
/deezer "Song_Name" To Play A Song From Deezer.
/telegram While Tagging a Song To Play From Telegram File.
**Admin Commands**:
/kill Yeah it kills the bot LOL
/clearqueue It clears entire Queue in a snap""")
