async def _test_client(config):
from aiohttp.test_utils import TestServer, TestClient
db = Gino()
app = web.Application(middlewares=[db])
app['config'] = dict(gino=config)
db.init_app(app)
class User(db.Model):
__tablename__ = 'gino_users'
id = db.Column(db.BigInteger(), primary_key=True)
nickname = db.Column('name', db.Unicode(), default='noname')
routes = web.RouteTableDef()
@routes.get('/')
async def root(request):
return web.Response(text='Hello, world!')
@routes.get('/users/{uid}')
async def get_user(request):
uid = int(request.match_info['uid'])
method = request.query.get('method')
q = User.query.where(User.id == uid)
if method == '1':
return web.json_response((await q.gino.first_or_404()).to_dict())
elif method == '2':
return web.json_response(
(await request['connection'].first_or_404(q)).to_dict())
elif method == '3':
return web.json_response((await db.bind.first_or_404(q)).to_dict())
elif method == '4':
return web.json_response(
(await request.app['db'].first_or_404(q)).to_dict())
else:
return web.json_response((await User.get_or_404(uid)).to_dict())
@routes.post('/users')
async def add_user(request):
form = await request.post()
u = await User.create(nickname=form.get('name'))
await u.query.gino.first_or_404()
await db.first_or_404(u.query)
await db.bind.first_or_404(u.query)
await request['connection'].first_or_404(u.query)
return web.json_response(u.to_dict())
app.router.add_routes(routes)
e = await gino.create_engine(PG_URL)
try:
try:
await db.gino.create_all(e)
async with TestClient(TestServer(app)) as rv:
await yield_(rv)
finally:
await db.gino.drop_all(e)
finally:
await e.close()
def __init__(self, config):
db = Gino(model_classes=tuple(gtfs_model.tables))
app = web.Application(middlewares=[db])
# I don't quite get why aiohttp says I shouldn't just use self.config
# for this, but whatever
app["config"] = config
app["aiocache"] = SimpleMemoryCache()
app["ansiconv"] = ansi2html.converter.Ansi2HTMLConverter(linkify=True,
title="curlbus",
font_size='16px')
app['siriclient'] = SIRIClient(config["mot"]["url"],
config["mot"]["user_id"])
db.init_app(app)
app.router.add_static("/static/", os.path.join(os.path.dirname(__file__), '..', "static"))
app.add_routes([web.get('/{stop_code:\d+}{tail:/*}', self.handle_station),
web.get('/operators{tail:/*}', self.handle_operator_index),
web.get('/nearby', self.handle_nearby),
web.get('/{operator:\w+}{tail:/*}', self.handle_operator),
web.get('/rail/stations{tail:/*}', self.handle_rail_stations),
web.get('/rail/map{tail:/*}', self.handle_rail_map),
web.get('/operators/{operator}/{route_number}{tail:/*}', self.handle_route),
web.get('/operators/{operator}/{route_number}/{alternative}{tail:/*}', self.handle_route),
web.get('/operators/{operator}{tail:/*}', self.handle_operator),
web.get('/{operator}/{route_number}{tail:/*}', self.handle_route),
web.get('/{operator}/{route_number}/{alternative}{tail:/*}', self.handle_route),
web.get('/{tail:/*}', self.handle_index)])
self._app = app
def __init__(self, config):
db = Gino(model_classes=tuple(gtfs_model.tables))
app = web.Application(middlewares=[db])
# I don't quite get why aiohttp says I shouldn't just use self.config
# for this, but whatever
app["config"] = config
app["aiocache"] = SimpleMemoryCache()
app["ansiconv"] = ansi2html.converter.Ansi2HTMLConverter(
linkify=True, title="curlbus", font_size='16px')
app['siriclient'] = SIRIClient(config["mot"]["url"],
config["mot"]["user_id"])
db.init_app(app)
app.router.add_static(
"/static/", os.path.join(os.path.dirname(__file__), '..',
"static"))
app.add_routes([
web.get('/{stop_code:\d+}{tail:/*}', self.handle_station),
web.get('/operators{tail:/*}', self.handle_operator_index),
web.get('/nearby', self.handle_nearby),
web.get('/{operator:\w+}{tail:/*}', self.handle_operator),
web.get('/rail/stations{tail:/*}', self.handle_rail_stations),
web.get('/rail/map{tail:/*}', self.handle_rail_map),
web.get('/operators/{operator}/{route_number}{tail:/*}',
self.handle_route),
web.get(
'/operators/{operator}/{route_number}/{alternative}{tail:/*}',
self.handle_route),
web.get('/operators/{operator}{tail:/*}', self.handle_operator),
web.get('/{operator}/{route_number}{tail:/*}', self.handle_route),
web.get('/{operator}/{route_number}/{alternative}{tail:/*}',
self.handle_route),
web.get('/{tail:/*}', self.handle_index)
])
self._app = app
async def init(loop):
# Setup app.
app = web.Application()
# Setup routes
for route in api.routes.routes:
app.router.add_route(*route)
# Setup DB connection
await init_db()
db = Gino()
db.init_app(
app,
config={
"user": "******",
"password": "",
"database": "gino",
"host": "postgres"})
# Setup middlewares
middlewares = [
db, validation_middleware, auth_middleware]
app.middlewares.extend(middlewares)
# Setup api_spec
setup_aiohttp_apispec(
app=app,
title="Joke's API documentation",
version='v1',
url="/api/v1/docs/swagger.json",
swagger_path="/api/v1/docs/")
host = "0.0.0.0"
port = 80
return app, host, port
def __init__(self, config):
db = Gino(model_classes=tuple(gtfs_model.tables))
app = web.Application(middlewares=[db])
app["config"] = config
db.init_app(app)
app.add_routes([web.post('/{tail:.*}', self.handle_request)])
self._app = app
def __init__(self, config):
db = Gino(model_classes=tuple(gtfs_model.tables))
app = web.Application(middlewares=[db])
app["config"] = config
db.init_app(app)
app.add_routes([web.post('/{tail:.*}', self.handle_request)])
self._app = app
async def main(loop):
await init_db()
db = Gino()
app = Application(middlewares=[db])
db.init_app(app, config={'dsn': DB_ADDRESS})
for model in models_collection:
resource = GenericResource(model.__table__.name, model)
resource.register(app.router)
return app
async def client(aiohttp_client, loop):
app, _, _ = await init(loop)
db = Gino()
db.init_app(app,
config={
"user": "******",
"password": "",
"database": "gino",
"host": "postgres-test"
})
async with db.with_bind('postgresql://postgres@postgres-test/gino'):
await db.gino.create_all()
return await aiohttp_client(app)
async def cli(loop, aiohttp_client):
await init_db()
db = Gino()
app = Application(middlewares=[db])
db.init_app(app, config={'dsn': DB_ADDRESS})
authors = GenericResource('authors', Author)
books = GenericResource('books', Book)
countries = GenericResource('countries', Country)
authors.register(app.router)
books.register(app.router)
countries.register(app.router)
await _create_model_instances()
yield await aiohttp_client(app)
await teardown_db()
async def _test_client(config, in_app_config=True):
from aiohttp.test_utils import TestServer, TestClient
db = Gino()
app = web.Application(middlewares=[db])
db_attr_name = "gino_db"
config.update({
"kwargs":
dict(
max_inactive_connection_lifetime=_MAX_INACTIVE_CONNECTION_LIFETIME,
),
})
if in_app_config:
app["config"] = dict(gino=config)
db.init_app(app, db_attr_name=db_attr_name)
else:
db.init_app(app, config, db_attr_name=db_attr_name)
class User(db.Model):
__tablename__ = "gino_users"
id = db.Column(db.BigInteger(), primary_key=True)
nickname = db.Column("name", db.Unicode(), default="unnamed")
routes = web.RouteTableDef()
@routes.get("/")
async def root(request):
conn = await request["connection"].get_raw_connection()
# noinspection PyProtectedMember
assert (conn._holder._max_inactive_time ==
_MAX_INACTIVE_CONNECTION_LIFETIME)
return web.Response(text="Hello, world!")
@routes.get("/users/{uid}")
async def get_user(request):
uid = int(request.match_info["uid"])
method = request.query.get("method")
q = User.query.where(User.id == uid)
if method == "1":
return web.json_response((await q.gino.first_or_404()).to_dict())
elif method == "2":
return web.json_response(
(await request["connection"].first_or_404(q)).to_dict())
elif method == "3":
return web.json_response((await db.bind.first_or_404(q)).to_dict())
elif method == "4":
return web.json_response(
(await request.app[db_attr_name].first_or_404(q)).to_dict())
else:
return web.json_response((await User.get_or_404(uid)).to_dict())
@routes.post("/users")
async def add_user(request):
form = await request.post()
u = await User.create(nickname=form.get("name"))
await u.query.gino.first_or_404()
await db.first_or_404(u.query)
await db.bind.first_or_404(u.query)
await request["connection"].first_or_404(u.query)
return web.json_response(u.to_dict())
app.router.add_routes(routes)
e = await gino.create_engine(PG_URL)
try:
try:
await db.gino.create_all(e)
async with TestClient(TestServer(app)) as rv:
await yield_(rv)
finally:
await db.gino.drop_all(e)
finally:
await e.close()
# Database Configuration
PG_URL = "postgresql://{user}:{password}@{host}:{port}/{database}".format(
host=os.getenv("DB_HOST", "db"),
port=os.getenv("DB_PORT", 5432),
user=os.getenv("DB_USER", "postgres"),
password=os.getenv("DB_PASSWORD", ""),
database=os.getenv("DB_DATABASE", "postgres"),
)
# Initialize Gino instance
db = Gino()
# Initialize aiohttp app
app = web.Application(middlewares=[db])
db.init_app(app, dict(dsn=PG_URL))
# Definition of table
class Message(db.Model):
__tablename__ = "messages"
id = db.Column(db.BigInteger(), primary_key=True)
recipient = db.Column(db.Unicode())
source = db.Column(db.Integer())
status = db.Column(db.Unicode(), default="new")
body = db.Column(db.Unicode())
# Definition of routes
routes = web.RouteTableDef()
async def _app(config, in_app_config=True, db_delayed=False):
db = Gino()
app = web.Application(middlewares=[db])
db_attr_name = "gino_db"
config.update({
"kwargs":
dict(
max_inactive_connection_lifetime=_MAX_INACTIVE_CONNECTION_LIFETIME,
),
})
if db_delayed:
async def start_proxy(_port):
loop = asyncio.get_event_loop()
app.db_proxy = await loop.create_server(
lambda: ProxyServerProtocol(loop, DB_ARGS["host"], DB_ARGS[
"port"]),
"localhost",
_port,
reuse_address=True,
reuse_port=True,
)
return app.db_proxy
server = await start_proxy(0)
for s in server.sockets:
try:
host, port = s.getsockname()
break
except ValueError:
pass
server.close()
await server.wait_closed()
app.start_proxy = lambda: start_proxy(port)
config["host"] = host
config["port"] = port
config["retry_limit"] = 4
config["retry_interval"] = 0.5
if in_app_config:
app["config"] = dict(gino=config)
db.init_app(app, db_attr_name=db_attr_name)
else:
db.init_app(app, config, db_attr_name=db_attr_name)
class User(db.Model):
__tablename__ = "gino_users"
id = db.Column(db.BigInteger(), primary_key=True)
nickname = db.Column("name", db.Unicode(), default="noname")
routes = web.RouteTableDef()
@routes.get("/")
async def root(request):
conn = await request["connection"].get_raw_connection()
# noinspection PyProtectedMember
assert conn._holder._max_inactive_time == _MAX_INACTIVE_CONNECTION_LIFETIME
return web.Response(text="Hello, world!")
@routes.get("/users/{uid}")
async def get_user(request):
uid = int(request.match_info["uid"])
method = request.query.get("method")
q = User.query.where(User.id == uid)
if method == "1":
return web.json_response((await q.gino.first_or_404()).to_dict())
elif method == "2":
return web.json_response(
(await request["connection"].first_or_404(q)).to_dict())
elif method == "3":
return web.json_response((await db.bind.first_or_404(q)).to_dict())
elif method == "4":
return web.json_response(
(await request.app[db_attr_name].first_or_404(q)).to_dict())
else:
return web.json_response((await User.get_or_404(uid)).to_dict())
@routes.post("/users")
async def add_user(request):
form = await request.post()
u = await User.create(nickname=form.get("name"))
await u.query.gino.first_or_404()
await db.first_or_404(u.query)
await db.bind.first_or_404(u.query)
await request["connection"].first_or_404(u.query)
return web.json_response(u.to_dict())
app.router.add_routes(routes)
e = await gino.create_engine(PG_URL)
try:
try:
await db.gino.create_all(e)
await yield_(app)
finally:
await db.gino.drop_all(e)
finally:
await e.close()
from gino.ext.aiohttp import Gino
DB_ARGS = dict(
host=os.getenv("DB_HOST", "localhost"),
port=os.getenv("DB_PORT", 5432),
user=os.getenv("DB_USER", "postgres"),
password=os.getenv("DB_PASS", ""),
database=os.getenv("DB_NAME", "postgres"),
)
PG_URL = "postgresql://{user}:{password}@{host}:{port}/{database}".format(
**DB_ARGS)
db = Gino()
app = web.Application(middlewares=[db])
config = {"dsn": PG_URL}
db.init_app(app, config=config)
class User(db.Model):
__tablename__ = "gino_users"
id = db.Column(db.BigInteger(), primary_key=True)
nickname = db.Column("name", db.Unicode(), default="unnamed")
routes = web.RouteTableDef()
@routes.get("/")
async def root(request):
return web.Response(text="Hello, world!")