¿Cómo accedo a mis funciones de nivel de base de datos dentro de otras clases/archivos en Tornado?

Question

Soy nuevo en Tornado, y actualmente estoy tratando de superar este reciente obstáculo. Actualmente tengo definidas algunas variables de la base de datos, e instanciando los manejadores, las configuraciones y la información de conexión de la base de datos cuando inicio la clase de la Aplicación. También tengo una clase de controlador base (llamada BaseHandler) que proporciona una interfaz de base de datos simple para otras clases. Me gustaría dividir algunas de mis clases en otros archivos, y tener la mayor parte de la lógica de mi base de datos en esos otros métodos de clase, y mantener application.py para las rutas e instanciar estas otras clases cuando sea necesario, y pasar los datos necesarios a ellos para la base de datos. ¿Cómo accedería a esta función self.db desde estos otros archivos/clases?

application.py:

import tornado.database 
import tornado.httpserver 
import tornado.ioloop 
import tornado.options 
import tornado.web 

from tornado.options import define, options 
from user import User 

# Define some startup settings, can be changed through the command line 
define("port", default=8888, help="Run on the given HTTP port", type=int) 
define("db_host", default="localhost:3306", help="Database host") 
define("db_name", default="database_name", help="Database name") 
define("db_user", default="user", help="Database username") 
define("db_pass", default="password", help="Database password") 

class Application(tornado.web.Application): 
    def __init__(self): 
     handlers = [ 
      (r"/", MainHandler) 
     ] 
     settings = dict(
      application_title = u"Test Application", 
      template_path = os.path.join(os.path.dirname(__file__), "templates"), 
      static_path = os.path.join(os.path.dirname(__file__), "static"), 
      autoescape = None 
     ) 
     tornado.web.Application.__init__(self, handlers, **settings) 

     self.db = tornado.database.Connection(
      host=options.db_host, database=options.db_name, 
      user=options.db_user, password=options.db_pass) 

class BaseHandler(tornado.web.RequestHandler): 
    @property 
    def db(self): 
     return self.application.db 

class MainHandler(BaseHandler): 
    def get(self): 
     u = User() 
     self.write(tornado.escape.json_encode(u.get_user("test@test.com))) 

user.py:

class User(object): 
    def get_user(self, email): 
     result = self.db.get("SELECT first_name, last_name FROM users WHERE email = %s", email) 
     if not result: return False 
     return True, result 

Esta lógica funciona bien cuando no se han separado de la lógica a cabo en un archivo separado, por lo Claramente estoy haciendo algo mal/extrañando algo.

Answer 1

Me encuentro con la misma situación en este momento, luego veo algunos ejemplos en github e hice eso.

separo mis archivos como:

• server.py: app plazo
• urls.py: definir zurdos y ui_modules
• da.py: definir métodos útiles para el acceso a datos

Los siguientes son algunos resúmenes de cada archivo, creo que esto puede ayudarlo a resolver su problema.

urls.py

import main 
import topic 

handlers=[] 
handlers.extend(main.handlers) 
handlers.extend(topic.handlers) 

ui_modules={} 

da.py

importación tornado.database

from tornado.options import define,options 
define("mysql_host", default="127.0.0.1:3306", help="database host") 
define("mysql_database", default="forum", help="database name") 
define("mysql_user", default="root", help="database user") 
define("mysql_password", default="111111", help="database password") 

db = tornado.database.Connection(
    host=options.mysql_host, database=options.mysql_database, 
    user=options.mysql_user, password=options.mysql_password) 

server.py

import os 
import tornado.database 
import tornado.httpserver 
import tornado.ioloop 
import tornado.web 

from tornado.options import define, options 
define("port", default=8888, help="run on the given port", type=int) 

import da 

class Application(tornado.web.Application): 
    def __init__(self): 
     from urls import handlers,ui_modules 
     settings = dict(
      template_path=os.path.join(os.path.dirname(__file__), "templates"), 
      static_path=os.path.join(os.path.dirname(__file__), "static"), 
      xsrf_cookies=True, 
      cookie_secret="11oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=", 
      login_url="/signin", 
      ui_modules=ui_modules, 
      debug=True, 
     ) 
     super(Application,self).__init__(handlers,**settings) 
#  tornado.web.Application.__init__(self, handlers, **settings) 
     # Have one global connection to the blog DB across all handlers 
     self.db = da.db 

def runserver(): 
    tornado.options.parse_command_line() 
    http_server = tornado.httpserver.HTTPServer(Application()) 
    http_server.listen(options.port) 
    tornado.ioloop.IOLoop.instance().start() 

if __name__ == "__main__": 
    runserver() 

Se puede utilizar solo db 'de da import * 'y luego todo se va así, o puede escribir un BaseHandler extiende tornado.web.RequestHandler y definir una propiedad:

class BaseHandler(tornado.web.RequestHandler): 
    @property 
    def db(self): 
     return self.application.db 

Cada controlador que se extiende BaseHandler puede utilizar self.db hacer operaciones de base de datos a continuación.