def make_app():
parse_config_file('./config.py')
assert options.db_url, "Need a database URL"
session_factory = make_session_factory(options.db_url)
# group is named (?P<name>group)
handlers = [
url(r"/", MainHandler),
url(r"/api/v1", InfoView, name='api'),
url(r'/api/v1/assets', AssetListView),
url(r'/api/v1/assets/(?P<asset_id>[0-9]+)', AssetView, name='asset'),
url(r'/api/v1/layers', LayerListView),
url(r'/api/v1/wells', WellListView),
url(r'/api/v1/intersection', IntersectionListView),
]
settings = {
'session_factory': session_factory,
'debug': options.debug,
'template_path': './template/',
'static_path': './static/',
'static_url_prefix': '/static/'
}
return Application(handlers, **settings )
def __init__(self, *args, **kwargs):
super(RequestHandlersTestCase, self).__init__(*args, **kwargs)
class WithoutMixinRequestHandler(RequestHandler):
def get(h_self):
with h_self.make_session() as session:
count = session.query(User).count()
h_self.write(str(count))
class WithMixinRequestHandler(RequestHandler, SessionMixin):
def get(h_self):
with h_self.make_session() as session:
count = session.query(User).count()
h_self.write(str(count))
class AsyncRequestHandler(RequestHandler, SessionMixin):
@coroutine
def get(h_self):
with h_self.make_session() as session:
count = yield as_future(session.query(User).count)
h_self.write(str(count))
handlers = (
(r'/async', AsyncRequestHandler),
(r'/with-mixin', WithMixinRequestHandler),
(r'/without-mixin', WithoutMixinRequestHandler),
)
self._factory = make_session_factory(postgres_url)
self._application = Application(handlers,
session_factory=self._factory)
def __init__(self):
handlers = [
(r'/', Main),
(r'/mens', Mens),
(r'/womens', Womens),
(r'/trending', Trending),
(r'/api/products', Products),
(r'/api/product/([^/]+)?', Product),
(r'/api/brands', Brands),
(r'/api/brand/([^/]+)?', Brand),
(r'/api/outfits', Outfits),
(r'/api/outfit/([^/]+)?', Outfit),
(r'/api/orders', Orders),
(r'/api/order/([^/]+)?', Order),
(r'/api/images', ImageHandler),
(r'/admin', AdminHandler),
(r'/admin/brands', AdminBrands),
(r'/admin/products', AdminProducts),
(r'/admin/outfits', AdminOutfits),
(r'/admin/orders', AdminOrders)
]
settings = dict(
static_path=os.path.join(os.path.dirname(__file__), "static"),
debug=True,
session_factory=make_session_factory('mysql+mysqldb://store:store@localhost/store')
)
super(Application, self).__init__(handlers, **settings)
def __init__(self):
database_url = os.environ['DATABASE_URL']
tornado.web.Application.__init__(
self,
url_patterns,
session_factory=make_session_factory(database_url),
**settings)
def main():
Collector(define, 'def_base', 'def_secrets') # pick options
fake_tlc = Collector(None, 'def_kwargs', update_id=None)
global item_update_id
item_update_id = Item(fake_tlc, 'update_id')
tornado.options.parse_command_line()
print("Server listening on port " + str(options.port))
logging.getLogger().setLevel(logging.DEBUG)
factory = make_session_factory(options.dburl)
app = Application(session_factory=factory)
http_server = tornado.httpserver.HTTPServer(app)
http_server.listen(options.port)
# im-send-btn im-chat-input--send _im_send im-send-btn_send
# im_chat-input--buttons
loop = tornado.ioloop.IOLoop.instance()
# period_cbk = tornado.ioloop.PeriodicCallback(
# app.update_tg_bot_message,
# 10 * 1000, # раз в 10 секунд
# )
# period_cbk.start()
loop.start()
def make_app():
config = inject.instance(Config)
debug = config.get('debug')
database_url = config.get('database_url')
factory = make_session_factory(database_url)
return Application([
('/status/?', StatusHandler),
('/auth/login/?', LoginHandler),
('/auth/logout/?', LogoutHandler),
('/whoami/?', WhoAmIHandler),
('/users/?', UsersHandler),
('/users/({})/?'.format(uuid_regex), UserHandler),
('/users/({})/station/?'.format(uuid_regex), SubscribeHandler),
('/stations/?', StationsHandler),
('/stations/({})/?'.format(uuid_regex), StationHandler),
('/stations/subscribe/?', SubscribeHandler),
('/messages/?', MessagesHandler),
('/messages/({})/?'.format(uuid_regex), ChatMessagesHandler),
('/messages/unreads/reset/?', UnreadMessagesHandler),
('/push-notifications/check/?', PushCheckHandler),
('/push-notifications/subscribe/?', PushSubscribeHandler),
('/push-notifications/unsubscribe/?', PushUnsubscribeHandler),
('/websocket/?', MessageWebSocketHandler),
('/presign/upload/?', S3PresignUploadHandler),
('/images/?', ImagesHandler),
],
default_handler_class=DefaultHandler,
session_factory=factory,
debug=debug)
def __init__(self):
options.parse_config_file('settings.py')
handlers = [('/', ChatHandler)]
factory = make_session_factory(options.DB_URL)
super().__init__(session_factory=factory,
handlers=handlers,
debug=True)
def __init__(self, config):
tornado.ioloop.IOLoop.configure(
'tornado.platform.asyncio.AsyncIOMainLoop')
handlers = [(r"/", MainHandler), (r"/api", ApiHandler),
(r"/doc", DocHandler)]
session_factory = make_session_factory(
config.get('db_connection') or 'sqlite:///cities.db')
super().__init__(handlers, session_factory=session_factory, debug=True)
def make_sqlalchemy_app():
from TwitterDatabase.DatabaseAccessObjects.DataConnections import MySqlConnection
from tornado_sqlalchemy import make_session_factory
print("Starting sqlalchemy app")
# We are just going to need the dsn
conn = MySqlConnection(environment.CREDENTIAL_FILE, create_engine=False)
dsn = conn.make_dsn()
print(dsn)
factory = make_session_factory(dsn)
return tornado.web.Application(route_handlers, session_factory=factory)
def main(argv):
tornado.options.parse_command_line(args=argv)
session_factory = make_session_factory(options.dbname)
Base.metadata.create_all(session_factory._engine)
for HardwareIoClass in (HydrometerPooler, RelayController):
tornado.ioloop.IOLoop.current().spawn_callback(hardware_io_loop,
HardwareIoClass,
session_factory)
settings['session_factory'] = session_factory
app = TornadoApplication()
app.listen(options.port)
tornado.ioloop.IOLoop.current().start()
async def test_concurrent_requests_using_async(self):
factory = make_session_factory(postgres_url, pool_size=1)
sessions = [factory.make_session() for _ in range(self.session_count)]
for session in sessions:
await as_future(lambda: session.execute(
'SELECT pg_sleep(:duration)',
{'duration': self.sleep_duration},
))
for session in sessions:
session.close()
def main():
tornado.options.parse_command_line()
application = tornado.web.Application([
(r"/receipt/(.*)", MainHandler),
], session_factory=make_session_factory(mysql_engine_path))
http_server = tornado.httpserver.HTTPServer(application)
http_server.listen(options.port)
try:
tornado.ioloop.IOLoop.current().start()
except KeyboardInterrupt:
tornado_logger.debug('Shutting down...')
tornado.ioloop.IOLoop.current().stop()
def __init__(self, *args, **kwargs):
super(RequestHandlersTestCase, self).__init__(*args, **kwargs)
class WithoutMixinRequestHandler(RequestHandler):
def get(h_self):
with h_self.make_session() as session:
count = session.query(User).count()
h_self.write(str(count))
class WithMixinRequestHandler(SessionMixin, RequestHandler):
def get(h_self):
with h_self.make_session() as session:
session.add(User('hunter2'))
session.flush()
count = session.query(User).count()
h_self.write(str(count))
class GenCoroutinesRequestHandler(SessionMixin, RequestHandler):
@coroutine
def get(h_self):
with h_self.make_session() as session:
count = yield as_future(session.query(User).count)
h_self.write(str(count))
class NativeCoroutinesRequestHandler(SessionMixin, RequestHandler):
async def get(h_self):
with h_self.make_session() as session:
count = await as_future(session.query(User).count)
h_self.write(str(count))
class UsesSelfSessionRequestHandler(SessionMixin, RequestHandler):
def get(h_self):
h_self.write(str(h_self.session.query(User).count()))
handlers = (
(r'/gen-coroutines', GenCoroutinesRequestHandler),
(r'/native-coroutines', NativeCoroutinesRequestHandler),
(r'/uses-self-session', UsesSelfSessionRequestHandler),
(r'/with-mixin', WithMixinRequestHandler),
(r'/without-mixin', WithoutMixinRequestHandler),
)
self._factory = make_session_factory(postgres_url)
self._application = Application(
handlers, session_factory=self._factory
)
def create_db_closures(
sqlalchemy_db_uri=None,
default_schema=None,
show_sql=None
):
# 读取配置文件
echo = (show_sql == str(True))
session_factory = make_session_factory(sqlalchemy_db_uri,
connect_args={'options': '-csearch_path={}'.format(default_schema)},
echo=echo)
# 初始化数据库
engine = sqla.create_engine(
sqlalchemy_db_uri,
connect_args={'options': '-csearch_path={}'.format(default_schema)},
echo=echo)
BaseModel.metadata.bind = engine
BaseModel.metadata.create_all()
return session_factory
def make_app():
session_factory = make_session_factory("postgresql://*****:*****@127.0.0.1/blog")
return tornado.web.Application([
(r"/",MainHandler),
(r"/style/(.*)",tornado.web.StaticFileHandler, {"path": "./static/style"},),
(r"/javascript/(.*)",tornado.web.StaticFileHandler, {"path": "./static/javascript"},),
(r"/about",AboutHandler),
(r"/register",RegisterHandler),
(r"/login",LoginHandler),
(r"/logout",LogoutHandler),
(r"/dashboard",BoardHandler),
(r"/addarticles",AddArticlesHandler),
(r"/registered",RecordArticleHandler),
(r"/delete",DeleteArticleHandler),
(r"/update",UpdateArticleHandler),
(r"/(.*)",ContentHandler),
],debug=True,session_factory=session_factory)
def __init__(self, mysqluser, mysqlpassword, mysqlhost, mysqldatabase):
mysql_connection_str = 'mysql+mysqldb://{0}:{1}@{2}/{3}'.format(
mysqluser, mysqlpassword, mysqlhost, mysqldatabase)
logging.info(mysql_connection_str)
factory = make_session_factory(mysql_connection_str)
# need pool_recycle option if connecting for longer than 8 hours
# so would need to update tornado_sqlalchemy (ie fork and contribute)
# pool_recycle=3600
# NOT FOR PRODUCTION
settings = dict(debug=True,
cookie_secret="gB9jYwVv0aodH51judoGwroWP",
template_path=os.path.join(os.path.dirname(__file__),
"templates"),
static_path=os.path.join(os.path.dirname(__file__),
"static"),
xsrf_cookies=False,
session_factory=factory,
autoreload=True)
super(URLWordCloudApplication, self).__init__(url_patterns, **settings)
def make_app():
# generate database schema
engine = create_engine(os.environ.get('DATABASE_URL'))
Base.metadata.create_all(engine)
logger.info(':: STARTING UP TORNADO SERVER ::')
# async sessions with tornado-sqlalchemy!
factory = make_session_factory(os.environ.get('DATABASE_URL'))
return tornado.web.Application(
[
(r"/", MainHandler),
(r"/test/?", TestHandler),
(r"/users/?", UsersHandler),
(r"/meals/([0-9]+)", MealsHandler),
(r"/meals/?", MealsHandler),
(r"/mealEntry/?", MealEntriesHandler),
(r"/mealEntry/([0-9]+)", MealEntriesHandler),
# TODO: combine user handlers?
(r"/user/?", UserHandler),
(r"/user/([^/]+)?", UserHandler),
(r"/login/?", LoginHandler),
],
session_factory=factory)
id = Column(BigInteger, primary_key=True)
username = Column(String(255), unique=True)
class SyncWebRequestHandler(RequestHandler, SessionMixin):
def get(self):
with self.make_session() as session:
count = session.query(User).count()
self.write('{} users so far!'.format(count))
class AsyncWebRequestHandler(RequestHandler, SessionMixin):
@coroutine
def get(self):
with self.make_session() as session:
count = yield as_future(session.query(User).count)
self.write('{} users so far!'.format(count))
if __name__ == '__main__':
session_factory = make_session_factory(options.database_url)
Application([
(r'/sync', SyncWebRequestHandler)
(r'/async', AsyncWebRequestHandler)
], session_factory=session_factory).listen(8888)
IOLoop.current().start()
raise Exception('No engine for OS')
engine_path = os.path.join(engine_path, engine_paths[system])
environment = os.environ[
'ENVIRONMENT'] if 'ENVIRONMENT' in os.environ else 'PRODUCTION'
port = 5000
debug = True
if environment != 'development':
port = os.environ.get('PORT', 5000)
debug = False
define('port', default=port, help='run on the given port', type=int)
define('debug', default=debug, help='run in debug mode')
define('path-to-engine',
default=engine_path,
help='the location of the chess engine')
if __name__ == '__main__':
setup()
from app import Application
from tornado_sqlalchemy import make_session_factory
factory = make_session_factory(DB_ENGINE_URL)
http_server = tornado.httpserver.HTTPServer(
Application(session_factory=factory))
http_server.listen(options.port)
print('Listening on port %s' % options.port)
tornado.ioloop.IOLoop.current().start()
def test_make_postgres_factory(self):
self._test_with_factory(make_session_factory(postgres_url))
from views.auth import AuthCreateHandler, AuthLoginHandler, GoogleOAuth2LoginHandler, GithubLoginHandler
from views.dashboard import DashboardHandler, UserPanelHandler, TaskHandler, TaskPageHandler
from upload import FileHandler, YouTubeHandler
from api import APIHandler, APIUploadFileHandler, APIAddTaskHandler, APITaskHandler
from tornado_sqlalchemy import make_session_factory
from tornado.web import StaticFileHandler
import os
import asyncio
from tornado.platform.asyncio import AnyThreadEventLoopPolicy
import tornado.options
tornado.options.parse_command_line()
import pymongo
import motor
factory = make_session_factory("mysql://*****:*****@localhost:3306/rekognition?charset=utf8mb4", pool_size = 1)
mongo_db = motor.motor_tornado.MotorClient().pmr
absFilePath = os.path.abspath(__file__)
fileDir = os.path.dirname(os.path.abspath(__file__))
parentDir = os.path.dirname(fileDir)
def make_app():
urls = [
(r"/", DashboardHandler),
(r"/user", UserPanelHandler),
(r"/login", AuthLoginHandler),
(r"/register", AuthCreateHandler),
(r"/login_google", GoogleOAuth2LoginHandler),
(r"/login_github", GithubLoginHandler),
import os
from tornado_sqlalchemy import make_session_factory
from tornado.options import define, options
from tornado.httpserver import HTTPServer
from tornado.web import Application
from tornado.ioloop import IOLoop
from todo.views import HelloWorld, ListRoutesView, TaskListView
define('port', default=8888, help='This is the port to listen on.')
factory = make_session_factory(
os.environ.get('DATABASE_URL', 'postgres://localhost:5432/tornado_todo'))
def main():
"""
Construct and serve the tornado application.
"""
app = Application([('/', ListRoutesView), ('/hi', HelloWorld),
(r'/tasks/([^/]+)?', TaskListView)],
session_factory=factory)
http_server = HTTPServer(app)
http_server.listen(options.port)
print(f"Listening on http://127.0.0.1:{options.port}/")
IOLoop.current().start()
# __init__.py
from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
from tornado.options import define, options
from tornado.web import Application
from todo.views import InfoView
# add these
import os
from tornado_sqlalchemy import make_session_factory
define('port', default=8888, help='port to listen on')
factory = make_session_factory(os.environ.get('DATABASE_URL', ''))
def main():
"""Construct and serve the tornado application."""
app = Application([('/', InfoView)], session_factory=factory)
http_server = HTTPServer(app)
http_server.listen(options.port)
print('Listening on http://localhost:%i' % options.port)
IOLoop.current().start()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
tornado application
"""
from tornado.web import Application
from tornado_sqlalchemy import make_session_factory
from config import CONFIG
from url_mapping import ROUTES
from app.models import *
session_factory = make_session_factory(CONFIG.MYSQL_URI)
def init_data():
session = session_factory.make_session()
init_users = User.gen_users()
for user in User.gen_users():
session.add(user)
try:
session.commit()
print('generate users successfully')
except IntegrityError:
session.rollback()
print('faill to generate users')
class App(Application):
def __init__(self, config):
tornado_settings = config.TORNADO_SETTINGS
import tornado.ioloop
import tornado.web
from rekognition.web.views import DashboardHandler, TaskHandler, AuthCreateHandler, AuthLoginHandler
from tornado_sqlalchemy import make_session_factory
from tornado.web import StaticFileHandler
import os
import numpy as np
factory = make_session_factory(
"mysql://*****:*****@localhost:3306/rekognition")
absFilePath = os.path.abspath(__file__)
fileDir = os.path.dirname(os.path.abspath(__file__))
parentDir = os.path.dirname(fileDir)
def make_app():
urls = [(r"/", DashboardHandler), (r"/login", AuthLoginHandler),
(r"/register", AuthCreateHandler), (r"/addtask", TaskHandler),
(r"/output/(.*)", StaticFileHandler, {
'path': "output/"
})]
app = tornado.web.Application(
urls,
template_path=os.path.join(fileDir, "rekognition/web/templates"),
static_path=os.path.join(fileDir, "rekognition/web/assets"),
session_factory=factory,
cookie_secret="random")
return app
def test_make_mysql_factoy(self):
self._test_with_factory(make_session_factory(mysql_url))
def __init__(self, *args, **kwargs):
super(RequestHandlersTestCase, self).__init__(*args, **kwargs)
self._factory = make_session_factory(sqlite_url)
self._application = build_app()
def test_make_sqlite_factory(self):
self._test_with_factory(make_session_factory(sqlite_url))
def get_app( self ):
factory = make_session_factory( 'sqlite://' )
return tornado.web.Application( [ (r'/', TweetSaveHandler) ], session_factory=factory )
def __init__(self):
self._session_factory = make_session_factory(
'sqlite:///{}'.format(DB_FILE))
self.settings = {'session_factory': self._session_factory}
BASE_MODEL.metadata.create_all(self._session_factory.engine)
def make_db(db_uri):
session_factory = make_session_factory(db_uri)
fill_db_if_empty(session_factory.engine)
return session_factory
