def run_custom(self): self.start() self.turn_on() idle() self.stop()
def begin(self, coro: Optional[Awaitable[Any]] = None) -> None:
""" start userge """
loop = asyncio.get_event_loop()
loop.add_signal_handler(signal.SIGHUP, _shutdown)
loop.add_signal_handler(signal.SIGTERM, _shutdown)
run = loop.run_until_complete
try:
run(self.start())
running_tasks: List[asyncio.Task] = []
for task in self._tasks:
running_tasks.append(loop.create_task(task()))
if coro:
_LOG.info(_LOG_STR, "Running Coroutine")
run(coro)
else:
_LOG.info(_LOG_STR, "Idling USERGE-X")
logbot.edit_last_msg("USERGE-X has Started Successfully !")
logbot.end()
idle()
_LOG.info(_LOG_STR, "Exiting USERGE-X")
for task in running_tasks:
task.cancel()
run(self.stop())
run(loop.shutdown_asyncgens())
except asyncio.exceptions.CancelledError:
pass
finally:
if not loop.is_running():
loop.close()
def begin(self, coro: Optional[Awaitable[Any]] = None) -> None:
""" start cpbot """
lock = asyncio.Lock()
running_tasks: List[asyncio.Task] = []
async def _finalize() -> None:
async with lock:
for t in running_tasks:
t.cancel()
if self.is_initialized:
await self.stop()
else:
_close_db()
pool._stop() # pylint: disable=protected-access
# pylint: disable=expression-not-assigned
[
t.cancel() for t in asyncio.all_tasks()
if t is not asyncio.current_task()
]
await self.loop.shutdown_asyncgens()
self.loop.stop()
_LOG.info(_LOG_STR, "Loop Stopped !")
async def _shutdown(_sig: signal.Signals) -> None:
global _SEND_SIGNAL # pylint: disable=global-statement
_LOG.info(
_LOG_STR,
f"Received Stop Signal [{_sig.name}], Exiting cpbot ...")
await _finalize()
if _sig == _sig.SIGUSR1:
_SEND_SIGNAL = True
for sig in (signal.SIGHUP, signal.SIGTERM, signal.SIGINT,
signal.SIGUSR1):
self.loop.add_signal_handler(
sig, lambda _sig=sig: self.loop.create_task(_shutdown(_sig)))
self.loop.run_until_complete(self.start())
for task in self._tasks:
running_tasks.append(self.loop.create_task(task()))
logbot.edit_last_msg("cpbot has Started Successfully !")
logbot.end()
mode = "[DUAL]" if RawClient.DUAL_MODE else "[BOT]" if Config.BOT_TOKEN else "[USER]"
try:
if coro:
_LOG.info(_LOG_STR, f"Running Coroutine - {mode}")
self.loop.run_until_complete(coro)
else:
_LOG.info(_LOG_STR, f"Idling cpbot - {mode}")
idle()
self.loop.run_until_complete(_finalize())
except (asyncio.exceptions.CancelledError, RuntimeError):
pass
finally:
self.loop.close()
_LOG.info(_LOG_STR, "Loop Closed !")
if _SEND_SIGNAL:
os.kill(os.getpid(), signal.SIGUSR1)
def run_custom(self):
self.db = shelve.open(self.db_file)
self.start()
self.bot = turn_on(self)
self.username = self.bot.username
idle()
self.stop()
self.db.close()
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()
def begin(self, coro: Optional[Awaitable[Any]] = None) -> None:
""" start USERGE-X """
lock = asyncio.Lock()
running_tasks: List[asyncio.Task] = []
async def _finalize() -> None:
async with lock:
for task in running_tasks:
task.cancel()
if self.is_initialized:
await self.stop()
# pylint: disable=expression-not-assigned
[
t.cancel() for t in asyncio.all_tasks()
if t is not asyncio.current_task()
]
await self.loop.shutdown_asyncgens()
self.loop.stop()
_LOG.info(_LOG_STR, "Loop Stopped !")
async def _shutdown(sig: signal.Signals) -> None:
_LOG.info(
_LOG_STR,
f"Received Stop Signal [{sig.name}], Exiting USERGE-X ...")
await _finalize()
for sig in (signal.SIGHUP, signal.SIGTERM, signal.SIGINT):
self.loop.add_signal_handler(
sig, lambda sig=sig: self.loop.create_task(_shutdown(sig)))
self.loop.run_until_complete(self.start())
for task in self._tasks:
running_tasks.append(self.loop.create_task(task()))
logbot.edit_last_msg("USERGE-X has Started Successfully !")
logbot.end()
try:
if coro:
_LOG.info(_LOG_STR, "Running Coroutine")
self.loop.run_until_complete(coro)
else:
_LOG.info(_LOG_STR, "Idling USERGE-X")
idle()
self.loop.run_until_complete(_finalize())
except (asyncio.exceptions.CancelledError, RuntimeError):
pass
finally:
self.loop.close()
_LOG.info(_LOG_STR, "Loop Closed !")
def main():
mongo.init()
telegram.start()
periodic_task.start()
print("Bot on")
if admins.estimated_document_count() == 0:
print(
"[!] Usa /makemeadmin per diventare admin senza intervenire manualmente"
)
print(
"[!] dal database. Funziona solamente quando non è rilevato alcun admin."
)
idle()
print("Il bot verrà fermato.\n")
telegram.stop()
def main():
test_handler = CommandHandler("test", test)
start_handler = CommandHandler("start", start, pass_args=True)
help_handler = CommandHandler("help", get_help)
help_callback_handler = CallbackQueryHandler(help_button, pattern=r"help_")
settings_handler = CommandHandler("settings", get_settings)
settings_callback_handler = CallbackQueryHandler(settings_button,
pattern=r"stngs_")
donate_handler = CommandHandler("donate", donate)
migrate_handler = MessageHandler(Filters.status_update.migrate,
migrate_chats)
# dispatcher.add_handler(test_handler)
dispatcher.add_handler(start_handler)
dispatcher.add_handler(help_handler)
dispatcher.add_handler(settings_handler)
dispatcher.add_handler(help_callback_handler)
dispatcher.add_handler(settings_callback_handler)
dispatcher.add_handler(migrate_handler)
dispatcher.add_handler(donate_handler)
# dispatcher.add_error_handler(error_callback)
# add antiflood processor
Dispatcher.process_update = process_update
if WEBHOOK:
LOGGER.info("Using webhooks.")
updater.start_webhook(listen="127.0.0.1", port=PORT, url_path=TOKEN)
if CERT_PATH:
updater.bot.set_webhook(url=URL + TOKEN,
certificate=open(CERT_PATH, 'rb'))
else:
updater.bot.set_webhook(url=URL + TOKEN)
else:
LOGGER.info("Using long polling.")
updater.start_polling(timeout=15, read_latency=4)
pg.start()
idle()
updater.idle()
def begin(self, coro: Optional[Awaitable[Any]] = None) -> None:
"""Start AnjaniBot"""
lock = asyncio.Lock()
tasks: List[asyncio.Task] = []
async def finalized() -> None:
async with lock:
for task in tasks:
task.cancel()
if self.is_initialized:
await self.stop()
# pylint: disable=expression-not-assigned
[
t.cancel() for t in asyncio.all_tasks()
if t is not asyncio.current_task()
]
await self.loop.shutdown_asyncgens()
self.loop.stop()
LOGGER.info("Loop stopped")
async def shutdown(sig: signal.Signals) -> None: # pylint: disable=no-member
LOGGER.info("Received Stop Signal [%s], Exiting...", sig.name)
await finalized()
for sig in (signal.SIGHUP, signal.SIGTERM, signal.SIGINT):
self.loop.add_signal_handler(
sig, lambda sig=sig: self.loop.create_task(shutdown(sig)))
self.loop.run_until_complete(self.start())
try:
if coro:
LOGGER.info("Running Coroutine")
self.loop.run_until_complete(coro)
else:
LOGGER.info("Idling")
idle()
self.loop.run_until_complete(finalized())
except (asyncio.CancelledError, RuntimeError):
pass
finally:
self.loop.close()
LOGGER.info("Loop closed")
def begin(self, coro: Optional[Awaitable[Any]] = None) -> None:
""" start userge """
loop = asyncio.get_event_loop()
run = loop.run_until_complete
run(self.start())
running_tasks: List[asyncio.Task] = []
for task in self._tasks:
running_tasks.append(loop.create_task(task()))
if coro:
_LOG.info(_LOG_STR, "Running Coroutine")
run(coro)
else:
_LOG.info(_LOG_STR, "Idling Userge")
logbot.edit_last_msg("Userge has Started Successfully !")
logbot.end()
idle()
_LOG.info(_LOG_STR, "Exiting Userge")
for task in running_tasks:
task.cancel()
run(self.stop())
run(loop.shutdown_asyncgens())
loop.close()
def run(self) -> None:
logger.info(mp.current_process().name)
logger.info(threading.current_thread())
self.telegram_client.start()
me = self.telegram_client.get_me()
if me:
self.telegram_client.telegram_id = me.id
self.db.update_or_create_user(me)
worker = ClientWorkerThread(
telegram_client=self.telegram_client,
index=0,
db=self.db,
task_queues=self.task_queues,
)
worker.start()
self.init_handlers()
self.register_update_handlers()
idle()
self.telegram_client.stop()
def run(self) -> None:
logger.info(mp.current_process().name)
logger.info(threading.current_thread())
client = get_client(self.client_name, False)
client.start()
self.client = client
me = client.get_me()
logger.info(me)
client.add_handler(DisconnectHandler(self.on_disconnect))
client.add_handler(MessageHandler(self.on_message))
client.add_handler(RawUpdateHandler(self.on_raw_update))
worker = ClientWorkerThread(
client=client,
index=0,
db=self.db,
task_queues=self.task_queues,
)
worker.start()
idle()
client.stop()
'input.raw',
)
if message.chat.id in VOICE_CHATS:
await message.reply('Already joined to Voice Chat 🛠')
return
chat_id = message.chat.id
try:
group_call = GroupCall(client, input_filename)
await group_call.start(chat_id)
except RuntimeError:
await message.reply('Error ❌')
return
VOICE_CHATS[chat_id] = group_call
await message.reply('Joined the Voice Chat ✅')
@app.on_message(filters.command('leavevc') & self_or_contact_filter)
async def leave_voice_chat(client, message):
chat_id = message.chat.id
group_call = VOICE_CHATS[chat_id]
await group_call.stop()
VOICE_CHATS.pop(chat_id, None)
await message.reply('Left Voice Chat ✅')
app.start()
print('>>> JEVC PLAYER STARTED <<<')
idle()
app.stop()
print('\n>>> JEVC PLAYER STOPPED <<<')
import pyrogram
import sys
bot = pyrogram.Client("matcom-bot", bot_token=open("token").read())
@bot.on_message(pyrogram.filters.command(['start', 'help']))
def send_welcome(client, message: pyrogram.types.Message):
bot.send_message(
message.chat.id,
"🖖 Hola! Bienvenido al chatbot de MatCom!",
disable_web_page_preview=True,
)
bot.start()
pyrogram.idle()
bot.stop()
def idle_app():
"""Idle app before chat is selected"""
idle()
