def __init__(self, db_url):
if db_url:
self.db = connect(db_url)
self.mgr = peewee_async.Manager(database_proxy)
database_proxy.initialize(self.db)
else:
self.db = None
async def create_app():
""" Prepare application """
redis_pool = await aioredis.create_pool(settings.REDIS_CON)
middlewares = [
session_middleware(RedisStorage(redis_pool)), request_user_middleware
]
if settings.DEBUG:
middlewares.append(aiohttp_debugtoolbar.middleware)
# init application
app = web.Application(middlewares=middlewares)
app.redis_pool = redis_pool
app.ws_list = {}
jinja_env = aiohttp_jinja2.setup(
app,
loader=jinja2.FileSystemLoader(settings.TEMPLATE_DIR),
context_processors=[aiohttp_jinja2.request_processor],
)
jinja_env.globals.update(tags)
if settings.DEBUG:
aiohttp_debugtoolbar.setup(app, intercept_redirects=False)
# db conn
database.init(**settings.DATABASE)
app.database = database
app.database.set_allow_sync(False)
app.objects = peewee_async.Manager(app.database)
# make routes
from urls import routes
for route in routes:
app.router.add_route(**route)
app.router.add_static('/static', settings.STATIC_DIR, name='static')
app.logger = logger
return app
def __init__(self,
dbname,
dbuser,
dbpassword,
dbhost,
custom_driver=None,
**kwargs):
"""Adds self to messages and event's `data` field.
Through this instance you can access peewee_async.Manager instance (data["peewee_async"].manager).
This plugin should be included first!
"""
super().__init__()
# You can replace PostgresqlDatabase with MysqlDatabase or pass driver you want tot use in custom_driver argument
if custom_driver is None:
driver = peewee_async.PostgresqlDatabase
else:
driver = custom_driver
self.database = driver(dbname,
user=dbuser,
password=dbpassword,
host=dbhost,
**kwagrs)
self.models = []
self.create_models()
self.manager = peewee_async.Manager(self.database)
database.set_allow_sync(False)
def create_app(loop):
app = web.Application(middlewares=(auth_middleware, ))
app.update(name='adev-server', settings=settings)
cors = aiohttp_cors.setup(app,
defaults={
"*":
aiohttp_cors.ResourceOptions(
allow_credentials=True,
expose_headers="*",
allow_headers="*",
)
})
jinja2_loader = jinja2.FileSystemLoader(str(THIS_DIR / 'templates'))
aiohttp_jinja2.setup(app, loader=jinja2_loader, app_key=JINJA2_APP_KEY)
app[JINJA2_APP_KEY].filters.update(
url=reverse_url,
static=static_url,
)
# db conn
database.init(**DATABASE)
app.database = database
app.database.set_allow_sync(False)
app.objects = peewee_async.Manager(app.database)
for route in routes:
for method in ('get', 'post', 'delete', 'put'):
handler = getattr(route['handler'], method, None)
if not handler:
continue
cors.add(
app.router.add_route(method, route['path'], route['handler']))
return app
async def create_app(loop):
""" Prepare application """
redis_pool = await aioredis.create_pool(settings.REDIS_CON, loop=loop)
middlewares = [
session_middleware(RedisStorage(redis_pool)), json_response,
status_initial, request_checker, request_user_middleware
]
# init application
app = web.Application(loop=loop, middlewares=middlewares)
app.redis_pool = redis_pool
app.wslist = {}
jinja_env = aiohttp_jinja2.setup(
app,
loader=jinja2.FileSystemLoader(settings.TEMPLATE_DIR),
context_processors=[aiohttp_jinja2.request_processor],
)
jinja_env.globals.update(tags)
# db conn
database.init(**settings.DATABASE)
app.database = database
app.database.set_allow_sync(False)
app.objects = peewee_async.Manager(app.database)
app.database.connect()
# make routes
setup_routes(app)
app.router.add_static('/static', settings.STATIC_DIR, name='static')
app.logger = logger
handler = app.make_handler(access_log=logger)
serv_generator = loop.create_server(handler, settings.HOST, settings.PORT)
return serv_generator, handler, app
def init_db(drop=False):
if drop:
drop_tables()
create_tables()
add_fixtures()
async_db = peewee_async.Manager(db)
async_db.allow_sync = False
return async_db
def load_managers(*, managers=None, loop=None, only=None):
config = dict(defaults)
for k in list(config.keys()):
if only and k not in only:
continue
config[k].update(overrides.get(k, {}))
database = db_classes[k](**config[k])
managers[k] = peewee_async.Manager(database, loop=loop)
def setup_pg(app, database, **settings):
pg_db = peewee_async.PooledPostgresqlDatabase(database, **settings)
_BaseModel.set_database(pg_db)
pg_db.set_allow_sync(False)
app.pg = peewee_async.Manager(pg_db)
_BaseModel.manager = app.pg
app.pg.get_or_none = types.MethodType(_get_or_none, app.pg)
return app.pg
def app(async_db):
"""
Application fixture.
Required by pytest-tornado.
"""
application = Application()
application.objects = peewee_async.Manager(async_db)
return application
class Test(JSONModel_async):
class Meta:
database = config.pool_async
manager = peewee_async.Manager(config.pool_async)
id = IntegerField(primary_key=True)
name = CharField()
date = TimestampField(utc=True, null=True)
def create_database(app: App) -> None:
config = get_config(app)
database = peewee_asyncext.PooledPostgresqlExtDatabase(
**parse(config.postgres_url))
database_proxy.initialize(database)
app.ctx['database'] = database_proxy
objects = peewee_async.Manager(database_proxy)
database.set_allow_sync(False)
app.ctx['objects'] = objects
def setUp(self):
super().setUp()
self.manager = peewee_async.Manager(self.database, loop=self.loop)
for m in self.models:
m._meta.database = self.database
m.objects = self.manager
self.database.create_tables(self.models, safe=True)
self.create_fixtures()
def load_managers(*, loop, only):
managers = {}
for key in DB_CLASSES:
if only and key not in only:
continue
params = DB_DEFAULTS.get(key) or {}
params.update(DB_OVERRIDES.get(key) or {})
database = DB_CLASSES[key](**params)
managers[key] = peewee_async.Manager(database, loop=loop)
return managers
async def create_app(_loop):
_app = web.Application(loop=_loop)
# db conn
database.init(**DATABASE)
_app.database = database
_app.database.set_allow_sync(False)
_app.objects = peewee_async.Manager(database)
return _app
def create_pool(self):
_mysql_pools = {}
mysql_conf = ConfEntity().mysql
for alias, cnf in mysql_conf.items():
conf = cnf.copy()
db = conf.pop('db')
# 自动重新建立链接
db_conn = RetryMySQLDatabase(db, **conf)
manager = peewee_async.Manager(db_conn)
# 每个链接对象有两个属性：.db_conn .manager
_mysql_pools[alias] = dict2obj(
dict(db_conn=db_conn, manager=manager))
self.mysql_pools = _mysql_pools
def make_app():
loop = asyncio.get_event_loop()
manager = SubscriptionManager()
loop.run_until_complete(manager.connect())
app = tornado.web.Application([
(r"/api/v1/streaming/user", SSEHandler, dict(manager=manager)),
],
debug=True)
# Set database
app.objects = peewee_async.Manager(db)
app.listen(4000)
loop.run_forever()
def main():
app = tornado.web.Application(handlers=[
(r'/alex', 'test_peewee.RootHandler'),
],
debug=True)
# Set up database and manager
app.objects = peewee_async.Manager(database)
# Run loop
server = httpserver.HTTPServer(app, xheaders=True)
server.listen(8880)
tornado.ioloop.IOLoop.instance().start()
async def db_without_data(database, loop):
database.set_allow_sync(True)
Post._meta.database = database
db = peewee_async.Manager(database, loop=loop)
Post.truncate_table(True)
database.set_allow_sync(False)
yield db
await db.close()
database.set_allow_sync(True)
Post.truncate_table(True)
def bind_db(dburl: str, loop: asyncio.BaseEventLoop = None):
"""指定数据库的url初始化代理对象并创建表.
Args:
dburl (str): 支持peewee所支持的数据库url写法
loop (asyncio.BaseEventLoop, optional): Defaults to None. 指定事件循环
"""
database = connect(dburl)
db.initialize(database)
loop = loop or asyncio.get_event_loop()
db.create_tables(list(Tables.values()), safe=True)
db_manager = peewee_async.Manager(db)
return db_manager
def __new__(cls, *args, **kwargs):
if not hasattr(cls, "_instance"):
db_dic = dict(
host=options['SQL_HOST'],
port=options['SQL_POST'],
user=options['SQL_USER'],
password=options['SQL_PWD'],
max_connections=options['SQL_MAX_CONN'],
database=options['SQL_DB_NAME'],
)
cls.conn = peewee_async.PooledMySQLDatabase(**db_dic,
charset='utf8mb4')
cls.manager = peewee_async.Manager(cls.conn)
cls._instance = super().__new__(cls)
return cls._instance
def create_pool(self):
_mysql_pools = {}
mysql_conf = Config().mysql
for alias, cnf in mysql_conf.items():
db = cnf.pop('db')
is_async = cnf.pop('is_async', False)
db_conn = peewee_async.PooledMySQLDatabase(db, **cnf)
# 是否异步操作
if not bool(is_async):
db_conn.set_allow_sync(False)
manager = peewee_async.Manager(db_conn)
# 每个链接对象有两个属性：.db_conn .manager
_mysql_pools[alias] = dict2obj(
dict(db_conn=db_conn, manager=manager))
self.mysql_pools = _mysql_pools
def init_db(db_name: str, db_user: str, db_pass: str, host: str, port: int):
db = peewee_async.PostgresqlDatabase(db_name,
user=db_user,
password=db_pass,
host=host,
port=port)
db_proxy.initialize(db)
Ticker.create_table(True)
Price.create_table(True)
Insider.create_table(True)
Trade.create_table(True)
objects = peewee_async.Manager(db_proxy)
return objects
def main():
app = tornado.web.Application(handlers=[
(r'/alex', 'demo.RootHandler'),
],
debug=True)
# Set up database and manager
app.objects = peewee_async.Manager(database)
# Run loop
print("""Run application server http://127.0.0.1:8888s
Try GET urls:
http://127.0.0.1:8888?id=1
^C to stop server""")
server = httpserver.HTTPServer(app, xheaders=True)
server.listen(8888)
tornado.ioloop.IOLoop.instance().start()
async def db_with_10_posts(database, loop):
Post._meta.database = database
Post.create_table(True)
db = peewee_async.Manager(database, loop=loop)
Post.truncate_table(True)
database.set_allow_sync(False)
for test_post in TEST_POSTS:
await db.create(Post, **test_post)
yield db
await db.close()
database.set_allow_sync(True)
Post.drop_table(True)
def __init__(self,
dbhost,
dbname,
dbuser,
dbpassword,
dbport=None,
custom_driver=None,
set_manager=True,
**kwargs):
"""Adds self to messages and event's `data` field.
Through this instance you can access peewee_async.Manager instance (data["peewee_async"].manager).
This plugin should be included first!
"""
super().__init__()
self.set_manager = set_manager
if custom_driver is None or custom_driver == "PostgreSQL":
driver = peewee_async.PostgresqlDatabase
if dbport is None: dbport = 5432
elif custom_driver == "MySQL":
driver = peewee_async.MySQLDatabase
if dbport is None: dbport = 13306
else:
driver = custom_driver
if isinstance(dbport, str):
try:
dbport = int(dbport)
except ValueError:
raise ValueError("Port is wrong!")
self.database = driver(dbname,
user=dbuser,
password=dbpassword,
host=dbhost,
port=dbport,
**kwargs)
self.manager = peewee_async.Manager(self.database)
self.database.set_allow_sync(False)
def __init__(self, dbname, dbuser, dbpassword, dbhost):
"""Adds self to messages and event's `data` field.
Through this instance you can access peewee_async.Manager instance (data["peewee_async"].manager).
This plugin should be included first!
"""
super().__init__()
self.database = peewee_async.PostgresqlDatabase(dbname,
user=dbuser,
password=dbpassword,
host=dbhost)
self.models = []
self.create_models()
self.manager = peewee_async.Manager(self.database)
database.set_allow_sync(False)
async def load():
if store.config.get("UseDB", False):
import peewee_async
DBSettings = store.config.DBSettings
driver = peewee_async.PostgresqlDatabase if DBSettings[
'DBDriver'] == "psql" else peewee_async.MySQLDatabase
db = driver(DBSettings['DBName'],
user=DBSettings['DBUser'],
password=DBSettings['DBPassword'],
host=DBSettings['DBHost'],
port=DBSettings['DBPort'])
manager = peewee_async.Manager(db)
db.set_allow_sync(False)
store.config.db = manager
import db.Models
created_model = db.Models.BaseModel.__subclasses__()
for x in created_model:
with manager.allow_sync():
x.create_table(True)
if store.config.get("UseRedis", False):
import asyncio_redis
loop = asyncio.get_event_loop()
RedisSettings = store.config.DBRedis
transport, protocol = await loop.create_connection(
asyncio_redis.RedisProtocol, RedisSettings['DBHost'],
RedisSettings['DBPort'])
await protocol.auth(password=RedisSettings['DBPass'])
await protocol.select(RedisSettings['DB'])
store.config.redis = protocol
return True
def test_proxy_database(self):
loop = asyncio.new_event_loop()
database = peewee.Proxy()
TestModel._meta.database = database
objects = peewee_async.Manager(database, loop=loop)
@asyncio.coroutine
def test(objects):
text = "Test %s" % uuid.uuid4()
yield from objects.create(TestModel, text=text)
config = dict(defaults)
for k in list(config.keys()):
config[k].update(overrides.get(k, {}))
database.initialize(db_classes[k](**config[k]))
TestModel.create_table(True)
loop.run_until_complete(test(objects))
loop.run_until_complete(objects.close())
TestModel.drop_table(True)
loop.close()
def test_proxy_database(self):
loop = asyncio.new_event_loop()
database = peewee.Proxy()
TestModel._meta.database = database
objects = peewee_async.Manager(database, loop=loop)
async def test(objects):
text = "Test %s" % uuid.uuid4()
await objects.create(TestModel, text=text)
await objects.get(TestModel, text=text)
for key in DB_CLASSES:
params = DB_DEFAULTS.get(key) or {}
params.update(DB_OVERRIDES.get(key) or {})
database.initialize(DB_CLASSES[key](**params))
TestModel.create_table(True)
loop.run_until_complete(test(objects))
loop.run_until_complete(objects.close())
TestModel.drop_table(True)
loop.close()
def __init__(self, engine_cls, instance, *args, **kwargs):
"""
Initiate database.
:param engine_cls: Engine class
:param instance: Instance of the app.
:param args: *
:param kwargs: **
:type instance: pyplanet.core.instance.Instance
"""
self.engine = engine_cls(*args, **kwargs)
self.instance = instance
self.migrator = Migrator(self.instance, self)
self.registry = Registry(self.instance, self)
self.objects = peewee_async.Manager(self.engine,
loop=self.instance.loop)
# Don't allow any sync code.
if hasattr(self.engine, 'allow_sync'):
self.engine.allow_sync = False
Proxy.initialize(self.engine)
