async def init(argv=None):
# app = web.Application()
loop = asyncio.get_event_loop()
app = web.Application(loop=loop)
# app = web.Application(loop=loop, middlewares=[toolbar_middleware_factory])
# aiohttp_debugtoolbar.setup(app)
#http://127.0.0.1:9000/_debugtoolbar
app['settings'] = Settings
# create db connection on startup, shutdown on exit
app.on_startup.append(init_pg)
app.on_cleanup.append(close_pg)
# setup views and routes
setup_routes(app)
setup_static_routes(app)
setup_templates_routes(app)
# set up
setup_middlewares(app)
setup_sessions(app)
return app
async def get_application(self):
app = web.Application()
setup_routes(app)
setup_middlewares(app)
setup_db(app, self.dsn)
self.app = app
return app
def init():
app = web.Application()
app.remotes = {}
app.cache = {}
for fn in 'head.html', 'tail.html', 'video.html':
logging.info('Loading {} to cache'.format(fn))
with open('static/{}'.format(fn), 'rb') as f:
app.cache[fn] = f.read()
setup_templates(app)
setup_routes(app)
setup_middlewares(app)
setup_chats(app)
app.clients = Clients(app)
async def on_shutdown(app):
for client in app.clients.values():
try:
await client.close()
except:
pass
app.on_shutdown.append(on_shutdown)
return app
async def make_app():
app = web.Application()
app['config'] = config
app['session_name'] = 'VODOMAT_SESSION'
app.on_startup.extend([init_db, init_db_redis])
app.on_cleanup.extend([close_db, close_db_redis])
app.add_routes(routes)
db_pool = await init_db(app)
redis_pool = await init_db_redis(app)
setup_session(
app,
RedisStorage(redis_pool, cookie_name=app['session_name'],
max_age=3600))
setup_security(app, SessionIdentityPolicy(),
DBAuthorizationPolicy(db_pool))
aiohttp_jinja2.setup(
app,
loader=jinja2.FileSystemLoader('{}/templates'.format(
os.path.dirname(__file__))),
filters={'datetime_from_timestamp': datetime_from_timestamp_filter},
context_processors=[current_user_context_processor],
)
setup_middlewares(app)
aiojobs.aiohttp.setup(app)
return app
def init(loop, argv):
ap = argparse.ArgumentParser()
commandline.standard_argparse_options(ap, default_config='./config/polls.yaml')
#
# define your command-line arguments here
#
options = ap.parse_args(argv)
config = commandline.config_from_options(options, TRAFARET)
# setup application and extensions
app = web.Application(loop=loop)
# load config from yaml file in current dir
app['config'] = config
# setup Jinja2 template renderer
print(jinja2.FileSystemLoader('./templates').list_templates())
aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader('./templates'))
# create connection to the database
app.on_startup.append(init_db)
# shutdown db connection on exit
app.on_cleanup.append(close_db)
# setup views and routes
myargs = {'path': {'client_id' : 1 }}
asd = str('/pool/{client_id}').format_map(myargs['path'])
setup_routes(app)
setup_middlewares(app)
return app
async def init(loop):
# Redis
redis_opts = (config['redis']['host'], config['redis']['port'])
redis_pool = await create_pool(redis_opts)
# SQLAlchemy
sa_cfg = config['postgres']
dbengine = await create_engine(database=sa_cfg.get('database', 'aiohttp_security'),
user=sa_cfg.get('user', 'admin'))
app = web.Application()
app.db_engine = dbengine
# Auth
setup_session(app, RedisStorage(redis_pool))
setup_security(app,
SessionIdentityPolicy(),
DBAuthorizationPolicy(dbengine))
aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader('./templates'))
setup_routes(app)
setup_middlewares(app)
handler = app._make_handler()
app_conf = config['app']
srv = await loop.create_server(handler,
app_conf['host'],
app_conf['port'])
print('Server started at http://{}:{}'.format(str(app_conf['host']), str(app_conf['port'])))
return srv, app, handler
def define_middlewares(app):
try:
from middlewares import setup_middlewares
setup_middlewares(app)
_logger.info("Middlewares defined by external file")
except:
_logger.info("No external defined middlewares")
pass
def setup_app() -> web.Application:
loop = asyncio.get_event_loop()
app = web.Application(router=routing.ResourceRouter())
db = loop.run_until_complete(setup_db())
app['db'] = db
app['config'] = config
setup_routes(app.router)
setup_middlewares(app.middlewares)
return app
def create_example_app():
app = web.Application()
template_dir = os.path.join(BASE_DIR, "user_processing", "templates")
aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader(template_dir))
setup_routes(app)
setup_middlewares(app)
app.on_startup.append(init_mysql)
app.on_cleanup.append(close_mysql)
return app
async def on_startup(dispatcher: Dispatcher):
setup_logger()
logger.info("Установка обработчиков...")
# Установка обработчиков производится посредством декораторов. Для этого достаточно просто импортировать модуль
import handlers
setup_middlewares(dispatcher)
await on_startup_notify(dispatcher)
await set_default_commands(dispatcher)
logger.info(f"Бот успешно запущен...")
async def init_app(config):
app = web.Application()
app['config'] = config
app.on_startup.append(init_cb)
app.on_cleanup.append(close_cb)
setup_routes(app)
setup_cors(app)
setup_middlewares(app)
return app
def web_server(loop):
app = web.Application(loop=loop)
app['config'] = config
aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader('./templates'))
setup_routes(app)
setup_static(app)
setup_middlewares(app)
print('[INFO] Ready')
return app
async def init_app():
app = web.Application()
app['database'] = database
# create db connection on startup, shutdown on exit
app.on_startup.append(init_mysql)
app.on_cleanup.append(close_mysql)
# setup views and routes
setup_routes(app)
setup_middlewares(app)
return app
async def init_app(argv=None):
app = web.Application()
setup_routes(app)
setup_jinja2(app, loader=FileSystemLoader(BASE_PATH / 'templates'))
setup_swagger(app, swagger_url="/api/v1/doc", ui_version=2)
setup_aiohttp_apispec(app=app,
title="Profiles documentation",
version="v1",
url="/api/docs/swagger.json",
swagger_path="/api/docs",
static_path="/api/static")
setup_middlewares(app)
setup_db(app, dsn=dsn)
return app
async def init_app():
app = web.Application()
app['config'] = get_config()
# setup Jinja2 template renderer
aiohttp_jinja2.setup(app, loader=jinja2.PackageLoader('templates'))
# create db connection on startup, shutdown on exit
app.on_startup.append(init_pg)
app.on_cleanup.append(close_pg)
# setup routes and middlewares
setup_routes(app)
setup_middlewares(app)
return app
async def init_app():
app = web.Application()
app['config'] = config
# setup Jinja2 template renderer
aiohttp_jinja2.setup(app,
loader=jinja2.FileSystemLoader(
str(BASE_DIR / 'app' / 'templates')))
# create db connection on startup, shutdown on exit
app.on_startup.append(init_db)
app.on_cleanup.append(close_db)
# setup views and routes
setup_routes(app)
setup_middlewares(app)
return app
def create_app(config_path, loop):
""" Setups aiohttp web application instance
"""
# Load configuration from path
config = load_config(config_path)
# Debug mode
debug_mode = config.get('app', {}).get('debug', False)
app = web.Application(loop=loop,
debug=debug_mode)
# registering middlewares
setup_middlewares(app)
app['config'] = config
cors = aiohttp_cors.setup(app)
# setup_routes(app)
setup_routes_cors(app, cors)
setup_database(app)
return app
def main():
# config
args = parse_args()
config = load_config(args.config)
# database
# print('SQLite {}'.format(sql('select sqlite_version()')[0][0]))
# bot
# threading.Thread(target=bot).start()
# webapp
app = web.Application()
app.on_response_prepare.append(on_response_prepare)
setup_static_routes(app)
setup_routes(app)
setup_middlewares(app)
aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader('app/templates'))
web.run_app(app,
host=config['host'],
port=config['port'],
ssl_context=tls(config))
async def init_app(argv=None): # argv, is ??
app = web.Application(
) # aiohttp.web.Application object supports dict interface.
app['config'] = get_config(argv)
# setup jinja2 template renderer
# aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader('/path/to/templates/folder'))
_templates_path = os.path.join(os.path.dirname(os.path.abspath(__file__)),
'templates')
aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader(_templates_path))
# create db connection on startup, shutdown on exit.
app.on_startup.append(init_pg)
app.on_cleanup.append(close_pg)
# setup routes; routes direct to handlers (i.e. views.py in this demo).
setup_routes(app)
# setup middlewares
setup_middlewares(app)
return app
async def init(_loop):
"""
初始化
:param _loop:
:return:
"""
app = web.Application(loop=_loop)
# 初始化数据库
init_db(_loop)
# 配置路由
setup_routes(_loop, app)
# 配置页面跳转中间件
setup_middlewares(app)
# 配置静态资源
setup_static_routes(app)
# 配置静态资源模板
setup_templates(app)
# 启动服务
# noinspection PyDeprecation
srv = await _loop.create_server(app.make_handler(), '0.0.0.0',
conf.server["port"])
logger.info("http://0.0.0.0:8000")
return srv
async def init_app(argv=None):
# app = web.Application()
loop = asyncio.get_event_loop()
app = web.Application(loop=loop)
app['config'] = get_config(argv)
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
app['BASE_DIR'] = BASE_DIR
# create db connection on startup, shutdown on exit
app.on_startup.append(init_pg)
app.on_cleanup.append(close_pg)
# setup views and routes
setup_routes(app)
setup_static_routes(app)
setup_templates_routes(app)
# set up
setup_middlewares(app)
setup_sessions(app)
return app
async def get_application(self):
app = web.Application(router=routing.ResourceRouter())
app['db'] = MockedDB()
setup_routes(app.router)
setup_middlewares(app.middlewares)
return app
# aiohttpdemo_polls/main.py
from aiohttp import web #Framework
import aiohttp_jinja2 #para poder poner jinja
import jinja2 #El web engine
from settings import config, BASE_DIR #importa la configuracion y el directorioa base
from routes import setup_routes #importa las rutas
from db import close_pg, init_pg #Importa los metodos de la base de datos
from middlewares import setup_middlewares #Importa los middlewares
app = web.Application() #application
app['config'] = config #Pone la configuracion
#setea el engine para la pagina
aiohttp_jinja2.setup(app,
loader=jinja2.FileSystemLoader(str(BASE_DIR / 'aiohttpdemo_polls' / 'templates')))
setup_routes(app) #pone las rutas
setup_middlewares(app) #Pone los middlewares
app.on_startup.append(init_pg) #Inicia la base de datos
app.on_cleanup.append(close_pg) #Cierra la base de datos cuando se cierra la app
web.run_app(app) #Corre la app
import jinja2
import aiohttp_jinja2
from aiohttp import web
from routes import setup_routes
from settings import close_pg, on_startup
from middlewares import setup_middlewares
app = web.Application()
setup_routes(app)
aiohttp_jinja2.setup(app, loader=jinja2.PackageLoader('main', 'templates'))
on_startup(app)
app.on_cleanup.append(close_pg)
setup_middlewares(app)
web.run_app(app)
