def wrapper(*args, **kwargs): loop = asyncio.get_event_loop() # Close db connections at the end of all all but the cli group function try: loop.run_until_complete(f(*args, **kwargs)) finally: if f.__name__ != "cli": loop.run_until_complete(Tortoise.close_connections())
def event_loop(monkeypatch): global ancap_bot monkeypatch.delattr("dotenv.load_dotenv") import ancap_bot.cogs.economy loop = asyncio.get_event_loop() loop.run_until_complete(ancap_bot.db.init()) yield loop loop.run_until_complete(Tortoise.close_connections()) loop.close()
def main(): loop = asyncio.get_event_loop() try: # Initialize database first log.server_logger.info("Initializing database") loop.run_until_complete(DBConfig().init_db()) # Setup server server = PippinServer(config.host, config.port) # Check is remote node is alive try: is_alive = loop.run_until_complete(RPCClient.instance().is_alive()) except Exception: log.server_logger.exception("Couldn't do is_alive RPC call") is_alive = False finally: if not is_alive: log.server_logger.error( f"Error: Could not connect to remote node at {Config.instance().node_url}" ) exit(1) # Start server log.server_logger.info( f"Pippin server starting at {config.host}:{config.port}") tasks = [server.start()] # Check if DPoW should be started dpow_client = WorkClient.instance().dpow_client if dpow_client is not None: loop.run_until_complete(dpow_client.setup()) tasks.append(dpow_client.loop()) loop.run_until_complete(asyncio.wait(tasks)) loop.run_forever() except Exception: log.server_logger.exception("Pippin exited with exception") except BaseException: pass finally: log.server_logger.info("Pipping is exiting") tasks = [ RPCClient.close(), server.stop(), RedisDB.close(), WorkClient.close(), NanoUtil.close(), Tortoise.close_connections() ] loop.run_until_complete(asyncio.wait(tasks)) loop.close()
def __init__(self): super().__init__(command_prefix=settings.PREFIX) self.logger = logging.getLogger(__name__) self.status = cycle([ discord.Game(name=_("Tax evasion simulator")), discord.Activity(type=discord.ActivityType.listening, name=_("Tax evasion hints")), discord.Activity(type=discord.ActivityType.watching, name=_("Tax evasion tutorial")), ]) try: self.loop.run_until_complete(self.start(settings.TOKEN)) except KeyboardInterrupt: pass finally: self.loop.run_until_complete(Tortoise.close_connections()) self.loop.close() self.logger.info(_("Bot logged out"))
def run_client(args: argparse.Namespace) -> None: """ starts the Discord.Client. :return: None """ loop = asyncio.get_event_loop() try: loop.run_until_complete(init_tortoise()) token = os.environ.get("DISCORD_CODESCORD") start_port, end_port = args.p.split(":") client = Discord.Client(start_port=int(start_port), end_port=int(end_port), loop=loop) loop.run_until_complete(client.start(token)) finally: loop.run_until_complete(Tortoise.close_connections()) print("closing containers...") close_containers() print("closed containers.")
def ishell(): from IPython import embed import cProfile import pdb main = importlib.import_module("__main__") from tifa.models.base import BaseModel models = {cls.__name__: cls for cls in BaseModel.__subclasses__()} loop = asyncio.get_event_loop() try: loop.run_until_complete(register_tortoise_async()) ctx = main.__dict__ ctx.update({ **models, "ipdb": pdb, "cProfile": cProfile, }) embed(user_ns=ctx, banner2="", using="asyncio", colors="neutral") finally: loop.run_until_complete(Tortoise.close_connections())
# Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in all # copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # 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 asyncio from tortoise import Tortoise from distrobuild_scheduler.main import main if __name__ == "__main__": loop = asyncio.new_event_loop() try: loop.run_until_complete(main(loop)) finally: loop.run_until_complete(Tortoise.close_connections()) loop.close()
await client.start() print(f"[SmudgeLord] Starting...\nDate: {date}") await connect_database() await client.send_message( chat_id=CHAT_LOGS, text="<b>SmudgeLord started!</b>\n<b>Date:</b> {}".format(date), ) @aiocron.crontab("*/60 * * * *") async def backup() -> None: await client.send_document( CHAT_LOGS, "smudge/database/database.db", caption="<b>Database backuped!</b>\n<b>- Date:</b> {}".format( date), ) logging.warning("[SmudgeLord] Database backuped!") await idle() await client.stop() if __name__ == "__main__": asyncio.create_task(run_async(main())) loop = asyncio.get_event_loop() try: loop.run_until_complete(main()) finally: asyncio.create_task(Tortoise.close_connections()) loop.close()
def on_shutdown(): loop = asyncio.get_event_loop() loop.run_until_complete(Tortoise.close_connections()) loop.close()
def main(): loop = asyncio.new_event_loop() try: loop.run_until_complete(DBConfig().init_db()) if options.command == 'wallet_list': loop.run_until_complete(wallet_list()) elif options.command == 'wallet_create': if options.seed is not None: if not Validators.is_valid_block_hash(options.seed): print("Invalid seed specified") exit(1) loop.run_until_complete(wallet_create(options.seed)) elif options.command == 'wallet_change_seed': if options.seed is not None: if not Validators.is_valid_block_hash(options.seed): print("Invalid seed specified") exit(1) else: while True: try: options.seed = getpass.getpass(prompt='Enter new wallet seed:') if Validators.is_valid_block_hash(options.seed): break print("**Invalid seed**, should be a 64-character hex string") except KeyboardInterrupt: break exit(0) password = '' if options.encrypt: while True: try: password = getpass.getpass(prompt='Enter password to encrypt wallet:') if password.strip() == '': print("**Bad password** - cannot be blanke") break except KeyboardInterrupt: break exit(0) loop.run_until_complete(wallet_change_seed(options.wallet, options.seed, password)) elif options.command == 'wallet_view_seed': loop.run_until_complete(wallet_view_seed(options.wallet, options.password, options.all_keys)) elif options.command == 'account_create': if options.key is not None: if not Validators.is_valid_block_hash(options.key): print("Invalid Private Key") exit(0) elif options.key is not None and options.count is not None: print("You can only specify one: --key or --count") print("--count can only be used for deterministic accounts") elif options.count is not None: if options.count < 1: print("Count needs to be at least 1...") loop.run_until_complete(account_create(options.wallet, options.key, options.count)) elif options.command == 'wallet_destroy': loop.run_until_complete(wallet_destroy(options.wallet)) elif options.command == 'wallet_representative_get': loop.run_until_complete(wallet_representative_get(options.wallet)) elif options.command == 'wallet_representative_set': loop.run_until_complete(wallet_representative_set(options.wallet, options.representatives, update_existing=options.update_existing)) else: parser.print_help() except Exception as e: print(str(e)) raise e finally: loop.run_until_complete(Tortoise.close_connections()) loop.close()
from tortoise import Tortoise from vkbottle import Bot from iris_cm_api import middlewares from iris_cm_api.handlers import blueprints from iris_cm_api.utils import get_config, init_tortoise if __name__ == "__main__": config = get_config() bot = Bot(config.bot.token) bot.labeler.vbml_ignore_case = True bot.loop_wrapper.on_startup += [init_tortoise(config.database.url)] bot.loop_wrapper.on_shutdown += [Tortoise.close_connections()] for bl in blueprints: bl.load(bot) bot.labeler.message_view.register_middleware( middlewares.OnlyUsersMiddleware()) bot.run_forever()
tasks = [ client.start(config.bot_token), # Create two queue consumers for transactions TransactionQueue.instance(bot=client).queue_consumer(), TransactionQueue.instance(bot=client).queue_consumer() ] # Setup optional server if configured server_host, server_port = Config.instance().get_server_info() if server_host is None or server_port is None: logger.info("Graham server is disabled") else: server = GrahamServer(client, server_host, server_port) logger.info( f"Graham server running at {server_host}:{server_port}") tasks.append(server.start()) loop.run_until_complete(asyncio.wait(tasks)) except Exception: logger.exception("Graham exited with exception") except BaseException: pass finally: logger.info("Graham is exiting") tasks = [ client.logout(), RPCClient.close(), RedisDB.close(), Tortoise.close_connections() ] loop.run_until_complete(asyncio.wait(tasks)) loop.close()
def tearDownClass(cls): cls.loop.run_until_complete(Tortoise.close_connections()) cls.loop.run_until_complete(NanoUtil.close()) cls.loop.close() cls.removeMockDB()
def initialize_tests(event_loop): event_loop.run_until_complete(_sync_db(db_url="sqlite://:memory:")) yield event_loop.run_until_complete(Tortoise.close_connections())