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())
