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)