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