def cli():
parser = argparse.ArgumentParser()
subparsers = parser.add_subparsers(title="subcommands")
parser.add_argument(
"-c",
"--config",
required=True,
help="Tortoise-orm config dict import path,like settings.TORTOISE_ORM.",
)
parser.add_argument(
"--version",
"-V",
action="version",
version=f"fastapi-admin version, {version()}",
help="show the version",
)
parser_register_permissions = subparsers.add_parser("register_permissions")
parser_register_permissions.add_argument(
"--clean",
required=False,
action="store_true",
help="Clean up old permissions then renew.")
parser_register_permissions.set_defaults(func=register_permissions)
parser_createsuperuser = subparsers.add_parser("createsuperuser")
parser_createsuperuser.add_argument(
"-u",
"--user",
required=True,
help="User model name, like User or Admin.")
parser_createsuperuser.set_defaults(func=createsuperuser)
parse_args = parser.parse_args()
run_async(parse_args.func(parse_args))
def create_superuser(
username: str = typer.Option(..., prompt=True),
email: str = typer.Option(..., prompt=True),
password: str = typer.Option(...,
prompt=True,
confirmation_prompt=True,
hide_input=True),
is_test: bool = typer.Option(..., prompt=True),
) -> None:
"""Create super user.
Args:
username: prompt user to enter username
email: prompt user to enter email
password: prompt user to enter password with confirmation
is_test: checking if the creation is test env or not
"""
run_async(
run_tortoise(
data={
"username": username,
"password": password,
"email": email,
"is_superuser": True,
"is_active": True,
},
db_url="sqlite://:memory:" if is_test else settings.DATABASE_URL,
))
def create_database(_: argparse.Namespace) -> None:
"""
sets up and creates the database for the Discord.Client.
:return: None
"""
run_async(_create_database())
def cli():
parser = argparse.ArgumentParser()
subparsers = parser.add_subparsers(title='subcommands')
parser.add_argument(
'-c',
'--config',
required=True,
help='Tortoise-orm config dict import path,like settings.TORTOISE_ORM.'
)
parser_register_permissions = subparsers.add_parser('register_permissions')
parser_register_permissions.add_argument(
'--clean',
required=False,
action='store_true',
help='Clean up old permissions then renew.')
parser_register_permissions.set_defaults(func=register_permissions)
parser_createsuperuser = subparsers.add_parser('createsuperuser')
parser_createsuperuser.add_argument(
'--user-model',
required=True,
help='User model import path,like examples.models.User.')
parser_createsuperuser.set_defaults(func=createsuperuser)
parse_args = parser.parse_args()
run_async(parse_args.func(parse_args))
def test_run_async_raised(self):
self.assertEqual(connections._get_storage(), {})
self.assertEqual(self.somevalue, 1)
with self.assertRaises(Exception):
run_async(self.init_raise())
self.assertEqual(connections._get_storage(), {})
self.assertEqual(self.somevalue, 3)
def createuser():
username = typer.prompt("Username")
password = typer.prompt("Password")
email = typer.prompt("Email")
is_superuser = typer.confirm(f"is {username} super user?")
is_staff = typer.confirm(f"is {username} staff user?")
is_active = typer.confirm(f"is {username} active user?")
run_async(
run(
data={
"username": username,
"password": password,
"email": email,
"full_name": " ",
"is_superuser": is_superuser,
"is_staff": is_staff,
"is_active": is_active,
"phone_number": "0923275406",
}
)
)
def test_run_async_raised(self):
self.assertEqual(Tortoise._connections, {})
self.assertEqual(self.somevalue, 1)
with self.assertRaises(Exception):
run_async(self.init_raise())
self.assertEqual(Tortoise._connections, {})
self.assertEqual(self.somevalue, 3)
async def addusertobase():
await Tortoise.init(db_url="sqlte://DataBase.db", modules={"models": ["__main__"]})
await Tortoise.generate_schemas()
a = event = await Event.create(name="Test")
await Event.filter(id=event.id).update(name="Updated name")
await Event(name="Test 2").save()
print(a)
run_async(addusertobase())
def test_app_with_db() -> Generator:
app = create_application()
app.dependency_overrides[get_settings] = get_settings_override
initializer(db_url=os.environ.get("DATABASE_TEST_URL"),
modules=["app.models.tortoise.users"])
run_async(add_users())
with TestClient(app) as test_client:
yield test_client
finalizer()
def build_app(loop=None):
app = web.Application(loop=loop, middlewares=get_middlewares())
run_async(start_database())
app.on_startup.append(start_plugins)
app.on_cleanup.append(stop_plugins)
setup_swagger(
app,
swagger_url='/docs',
swagger_from_file="docs/swagger.yaml"
)
register_routes(app)
return app
def poller():
r = requests.get(POLLED_URL)
if r.status_code == requests.codes.ok:
data = r.json()
logger.info("Fetch from external API successful")
normalized_data = []
normalized_data.append(data["Global"])
normalized_data[0]["Country"] = "Global"
normalized_data[0]["CountryCode"] = "GLB"
interested_keys = {}
for key in normalized_data[0].keys():
interested_keys[key] = key
# Changing the column name from reserved postgresql keyword Date
interested_keys["Date"] = "FetchedDate"
# Converting datetime to a format the tortoise-orm accepts
normalized_data[0]["FetchedDate"] = datetime.strptime(
data["Date"], "%Y-%m-%dT%H:%M:%SZ")
# Calculating active cases
normalized_data[0]["TotalActive"] = normalized_data[0][
"TotalConfirmed"] - (normalized_data[0]["TotalDeaths"] +
normalized_data[0]["TotalRecovered"])
for country in data["Countries"]:
new_item = {}
for key, value in interested_keys.items():
new_item[value] = country[key]
new_item["TotalActive"] = new_item["TotalConfirmed"] - (
new_item["TotalDeaths"] + new_item["TotalRecovered"])
new_item["FetchedDate"] = datetime.strptime(
new_item["FetchedDate"], "%Y-%m-%dT%H:%M:%SZ")
normalized_data.append(new_item)
normalized_result = map(lambda item: Covid19Cases(**item),
normalized_data)
run_async(
save_to_db(normalized_result, normalized_data[0]["FetchedDate"]))
else:
logger.info("Fetch from external API failed")
def client() -> Generator:
try:
# create db and create table and create data
run_async(create_database())
# set token into environ
run_async(generate_token())
with TestClient(create_app()) as test_client:
yield test_client
finally:
# drop db
run_async(delete_database())
from models import init
from tortoise import Tortoise, run_async
async def create_db():
# Generate the schema
await init()
await Tortoise.generate_schemas()
run_async(create_db())
def init():
run_async(main())
print(Fore.GREEN + ret)
async def init_db(args):
await Tortoise.init(config=settings.TORTOISE_ORM)
if args.test:
sql = get_schema_sql(Tortoise.get_connection('default'), safe=False)
print(sql)
else:
await Tortoise.generate_schemas()
if __name__ == '__main__':
subparsers = parser.add_subparsers(title='subcommands')
parser_makemigrations = subparsers.add_parser('makemigrations')
parser_makemigrations.add_argument('-n', '--name', required=True)
parser_makemigrations.set_defaults(func=makemigrations)
parser_migrate = subparsers.add_parser('migrate')
parser_migrate.set_defaults(func=migrate)
parser_migrate = subparsers.add_parser('rollback')
parser_migrate.set_defaults(func=rollback)
parser_init_db = subparsers.add_parser('initdb')
parser_init_db.add_argument('--test', required=False, action='store_true', help='Print sql without execute.')
parser_init_db.set_defaults(func=init_db)
parse_args = parser.parse_args()
run_async(parse_args.func(parse_args))
class HistoryIngester(Consumer):
async def initialize(self):
logger.remove()
logger.add(sys.stderr, level="DEBUG")
logger.info(f"Initializing {str(self)}")
await Tortoise.init(db_url=DB_URL,
modules={"models": ["historedge_backend.models"]})
async def finalize(self):
logger.info(f"Finalizing {str(self)}")
async def handle_event(self, event: Dict[bytes, bytes]):
try:
history_dump = HistoryDumpReceived.deserialize(event)
logger.info(
"History dump received {dump} n_items:{n_items}",
dump=history_dump.id,
n_items=len(history_dump.items),
)
except ValidationError as e:
if event and "opening" not in event:
logger.exception(str(e))
else:
await history_dump.save()
if __name__ == "__main__":
ingester = HistoryIngester.create("history_chunks", "group", REDIS_HOST,
REDIS_PORT)
run_async(ingester.run())
def add_user(name, email, password):
run_async(_add_user(name=name, password=password, email=email))
keys = [
('id', 0),
('title', ''),
('url', ''),
('score', 0),
('by', ''),
('time', 0),
]
await Tortoise.init(db_url=db_url, modules=modules)
await models.Story.all().delete()
for item in p.iterdir():
if not item.suffix == '.json':
continue
with item.open() as f:
story = json.load(f)
record = {key: story.get(key, default) for (key, default) in keys}
# try:
await models.Story.create(**record)
# except...
await Tortoise.close_connections()
if __name__ == '__main__':
db_url = 'sqlite://db.sqlite3'
modules = {'models': ['lib.models']}
data = './data'
run_async(insert_all(db_url, modules, data))
# print(entry_date, data['date'])
entry = CoffeeEntry(user=user,
text=data['text'],
channel_id=data['channel_id'],
channel_name=data['channel_name'],
date=int(entry_date.timestamp() * 1000))
await entry.save()
async def import_entries():
async with aiofiles.open('log.json', mode='r',
encoding='utf8') as log_file:
async for line in log_file:
await make_entry(json.loads(line.strip()))
async def import_old_data():
await init_db()
# create users
print('IMPORTING USERS')
await import_users()
# create entries, connecting them to users
print('IMPORTING ENTRIES')
await import_entries()
if __name__ == '__main__':
run_async(import_old_data())
from tortoise.models import Model
from tortoise import fields
from tortoise import run_async
from database import init
from enums import Mood
class MoodModel(Model):
mood = fields.CharField(
max_length=255,
null=False,
description=f"Mood being recorded: {[m.value for m in Mood]}")
ts = fields.IntField(null=False, description=f"Epoch time")
def __str__(self):
return f"Mood: {self.mood} Time: {self.ts}"
if __name__ == "__main__":
run_async(init())
def test_run_async(self):
self.assertEqual(Tortoise._connections, {})
self.assertEqual(self.somevalue, 1)
run_async(self.init())
self.assertEqual(Tortoise._connections, {})
self.assertEqual(self.somevalue, 2)
PageVisit.filter(is_processed=False)
.prefetch_related("page")
.order_by("visited_at")
.limit(SCRAPER_DISTRIBUTOR_CHUNK_LENGTH)
.offset(offset)
.values(id="page__id", url="page__url")
)
if page_visits:
pages = {
"id": uuid4(),
"items": [
{"id": str(page["id"]), "url": page["url"]}
for page in page_visits
],
}
await self.redis.xadd(
self.publish_stream, {"data": orjson.dumps(pages)}
)
logger.info(
"Batch of pages sent {batch} n_items:{n_items}",
batch=pages["id"],
n_items=len(pages["items"]),
)
if __name__ == "__main__":
distributor = ScraperDistributor.create("pages_to_scrape", REDIS_HOST, REDIS_PORT)
run_async(distributor.run())
def initdb():
run_async(init())
click.echo('Init Finished!')
log = logging.getLogger("uvicorn")
def init_db(app: FastAPI) -> None:
register_tortoise(
app,
db_url=os.environ.get("DATABASE_URL"),
modules={"models": ["app.models.tortoiseORM"]},
generate_schemas=False,
add_exception_handlers=False,
)
Tortoise.init_models(['app.models.tortoiseORM'], 'models')
async def generate_schema() -> None:
log.info("Initializing Tortoise...")
await Tortoise.init(
db_url=os.environ.get("DATABASE_URL"),
modules={"models": ["app.models.tortoiseORM"]},
)
log.info("Generating database schema via Tortoise...")
await Tortoise.generate_schemas()
await Tortoise.close_connections()
# run_async(generate_schema())
if __name__ == "__main__":
run_async(generate_schema())
def init_db():
run_async(_init_db(_create_db=True))
click.echo('数据库初始化成功!')
from discord import Embed, Intents
from discord.ext import commands
import config
from exceptions.exceptions import EntityExistsException, EntityNotFoundException
from model.models import *
from tortoise import run_async
run_async(init_db())
allowedRoles = [
'tBTC Contributors (Team)', 'Admin', 'relay admin',
':european_castle: keep team', ':european_castle: keep admins',
'NuCypher Admin'
]
intents = Intents.default()
intents.members = True
bot = commands.Bot(command_prefix="!relay.",
help_command=None,
intents=intents)
@commands.has_any_role(*allowedRoles)
@bot.command(name='help')
async def relay_help(ctx):
"""
Function displays list of all available commands for Bridge-Bot
:param ctx: Discord Context Object
"""
widget = Embed(description="Available commands for Bridge-Bot",
title = i.split(':')[1].strip().replace('"', '')
elif 'date:' in i:
date = i.split(':')[1].strip()
elif 'tags' in i:
i = i.split(':')[1].strip()[1:-1] if '[' in i else i.split(
':')[1] # noqa
tags = filter(None, map(lambda x: x.strip(), i.split(',')))
content = ''.join(f.readlines())
try:
await Post.create(title=title,
content=content,
tags=tags,
author_id=args.uid,
slug='',
summary='',
status=Post.STATUS_ONLINE,
created_at=date)
except IntegrityError:
...
async def main():
await init_db()
for f in files:
await write_post(f)
if __name__ == '__main__':
run_async(main())
"models": ["app.models.tortoise", "aerich.models"],
"default_connection": "default",
},
},
}
def init_db(app: FastAPI) -> None:
register_tortoise(
app,
config=TORTOISE_ORM,
add_exception_handlers=True,
generate_schemas=os.environ.get("GENERATE_SCHEMAS", default=False),
)
async def generate_test_schema() -> None:
log.info("Initializing Tortoise...")
await Tortoise.init(
db_url=os.environ.get("DATABASE_TEST_URL"),
modules={"models": ["models.tortoise"]},
)
log.info("Generating database schema via Tortoise...")
await Tortoise.generate_schemas()
await Tortoise.close_connections()
if __name__ == "__main__":
run_async(generate_test_schema())
id = fields.IntField(pk=True)
name = fields.CharField(max_length=100)
#: The date-time the Tournament record was created at
created_at = fields.DatetimeField(auto_now_add=True)
Tournament_Pydantic = pydantic_model_creator(Tournament)
# Print JSON-schema
print(Tournament_Pydantic.schema_json(indent=4))
async def run():
await Tortoise.init(db_url="sqlite://:memory:",
modules={"models": ["__main__"]})
await Tortoise.generate_schemas()
# Create object
tournament = await Tournament.create(name="New Tournament")
# Serialise it
tourpy = await Tournament_Pydantic.from_tortoise_orm(tournament)
# As Python dict with Python objects (e.g. datetime)
print(tourpy.dict())
# As serialised JSON (e.g. datetime is ISO8601 string representation)
print(tourpy.json(indent=4))
if __name__ == "__main__":
run_async(run())
# also specify the app name of "models"
# which contain models from "app.models"
await Tortoise.init(
db_url=db_url,
modules={'models': ['models']}
)
async def create_db():
# Generate the schema
await init()
await Tortoise.generate_schemas()
async def run_benchmarks():
await create_db()
await test_a.runtest(loopstr)
await test_b.runtest(loopstr)
await test_c.runtest(loopstr)
await test_d.runtest(loopstr)
await test_e.runtest(loopstr)
await test_f.runtest(loopstr)
await test_g.runtest(loopstr)
await test_h.runtest(loopstr)
await test_i.runtest(loopstr)
await test_j.runtest(loopstr)
await test_k.runtest(loopstr)
run_async(run_benchmarks())
