def init(app): print "starting db test..." db = SQLAlchemy(app) from app.models import User engine = create_engine(app.config['SQLALCHEMY_DATABASE_URI'], echo=False) # if not database_exists(engine.url): # print "Database not found, creating new..." # create_database(engine.url) # print "Done!" Session = sessionmaker(bind=engine) session = Session() db.create_all() print "creating user 'admin'..." admin = User("admin", "*****@*****.**") session.add(admin) session.commit() print "done!" print "Users found in database:" for instance in session.query(User): print instance.username print "destroying user..." session.delete(instance) session.commit() print "done!" print "db test done!"
class TestFSA(FlaskTestBase): """Tests which use models defined using Flask-SQLAlchemy instead of pure SQLAlchemy. """ def setup(self): """Creates the Flask application, the APIManager, the database, and the Flask-SQLAlchemy models. """ super(TestFSA, self).setup() self.db = SQLAlchemy(self.flaskapp) class Person(self.db.Model): id = self.db.Column(self.db.Integer, primary_key=True) self.Person = Person self.db.create_all() def teardown(self): """Drops all tables from the temporary database.""" self.db.drop_all() unregister_fsa_session_signals() def test_init_app(self): manager = APIManager(flask_sqlalchemy_db=self.db) manager.create_api(self.Person) manager.init_app(self.flaskapp) response = self.app.get('/api/person') assert response.status_code == 200
def display_queries(response): """Display database queries Prints out SQL queries, EXPLAINs for queries above slow_threshold, and a final count of queries after every HTTP request """ slow_threshold = 0.5 # EXPLAIN queries that ran for more than 0.5s queries = get_debug_queries() logger.info("Total queries: %s", len(queries)) if report_type == 'count': return response # We have to copy the queries list below otherwise queries executed # in the for loop will be appended causing an endless loop for query in queries[:]: if report_type == 'slow' and query.duration < slow_threshold: continue logger.info( "%.8f %s\n%s\n%s", query.duration, query.context, query.statement, query.parameters) is_select = bool(re.match('SELECT', query.statement, re.I)) if query.duration > slow_threshold and is_select: try: statement = "EXPLAIN " + query.statement engine = SQLAlchemy().get_engine(app) result = engine.execute(statement, query.parameters) logger.info(tabulate(result.fetchall(), headers=result.keys())) except: # pylint: disable=bare-except logger.warning("Statement failed: %s", statement, exc_info=True) return response
class FlaskSQLAlchemyTestBase(FlaskTestBase, DatabaseMixin): """Base class for tests that use Flask-SQLAlchemy (instead of plain old SQLAlchemy). If Flask-SQLAlchemy is not installed, the :meth:`.setup` method will raise :exc:`nose.SkipTest`, so that each test method will be skipped individually. """ def setup(self): super(FlaskSQLAlchemyTestBase, self).setup() if not has_flask_sqlalchemy: raise SkipTest('Flask-SQLAlchemy not found.') self.flaskapp.config['SQLALCHEMY_DATABASE_URI'] = self.database_uri() # This is to avoid a warning in earlier versions of # Flask-SQLAlchemy. self.flaskapp.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False # Store some attributes for convenience and so the test methods # read more like the tests for plain old SQLAlchemy. self.db = SQLAlchemy(self.flaskapp) self.session = self.db.session def teardown(self): """Drops all tables and unregisters Flask-SQLAlchemy session signals. """ self.db.drop_all() unregister_fsa_session_signals()
def sql_select(): statement = request.args['sql'] params = request.args['params'] # Validate hash hash = hashlib.sha1( current_app.config['SECRET_KEY'] + statement + params).hexdigest() if hash != request.args['hash']: return abort(406) # Make sure it is a select statement if not statement.lower().strip().startswith('select'): return abort(406) params = json.loads(params) engine = SQLAlchemy().get_engine(current_app) result = engine.execute(statement, params) return g.debug_toolbar.render('panels/sqlalchemy_select.html', { 'result': result.fetchall(), 'headers': result.keys(), 'sql': format_sql(statement, params), 'duration': float(request.args['duration']), })
def webapp(request): app = Flask(__name__) app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite://" app.config["PROPAGATE_EXCEPTIONS"] = True db = SQLAlchemy(app) class Object(db.Model): id = db.Column(db.Integer, primary_key=True) field1 = db.Column(db.Integer) field2 = db.Column(db.Integer) db.create_all() @app.route("/objects") @paginated_view @sorted_view(allowed_fields=["id", "field1"]) def view_objects(): return Object.query @app.route("/objects_different_renderer") @paginated_view(renderer=lambda obj: {"id_value": obj.id}) def view_objects_different_renderer(): return Object.query @app.route("/objects_limited_page_size") @paginated_view(max_page_size=10, default_page_size=5) def view_objects_limited_page_size(): return Object.query @app.route("/objects_no_count") @paginated_view(max_page_size=10, default_page_size=5, include_count=False) def view_objects_no_count(): return Object.query @app.route("/objects_by_field2") @paginated_view @sorted_view(default="-field2") def view_objects_by_field2(): return Object.query num_objects = 100 field1_values = list(range(num_objects)) random.shuffle(field1_values) field2_values = list(range(num_objects)) random.shuffle(field2_values) for field1_value, field2_value in zip(field1_values, field2_values): db.session.add(Object(field1=field1_value, field2=field2_value)) db.session.commit() returned = App(app) returned.num_objects = num_objects returned.activate() request.addfinalizer(returned.deactivate) return returned
def test_flask(self): app = Flask(__name__) db = SQLAlchemy(app) app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:' class Cities(db.Model): __tablename__ = 'users' id = Column(Integer, primary_key=True) name = Column(String) population = Column(Integer) def __init__(self, name, population): self.name = name self.population = population app.config['TESTING'] = True app = app.test_client() db.create_all() city = Cities("Cordoba", 1000000) db.session.add(city) city = Cities("Rafaela", 99000) db.session.add(city) db.session.commit() query_string = '{ "sort": { "population" : "desc" } }' results = elastic_query(Cities, query_string) assert(results[0].name == 'Cordoba')
def run(the_config): global base, app, config, db, cookie_serializer config = the_config app.secret_key = config['flask']['session_secret_key'] app.debug = config['flask']['debug'] # app.redis = redis.StrictRedis(host='localhost', port=6379, db=0) # Cookie serializer cookie_serializer = URLSafeTimedSerializer(app.secret_key) # Configure the database before importing any other packages that # use DB models. app.config['SQLALCHEMY_DATABASE_URI'] = config['db']['uri'] app.config['SQLALCHEMY_ECHO'] = config['db']['echo'] db = SQLAlchemy(app) # Import all models so SQLAlchemy knows about their relationships import siege.models # Create all models db.create_all() # Import the views to enable Flask handlers import siege.views populate_initial_data(config, db) gevent.spawn(game_management_greenlet) socketio.run(app, host=config['flask']['bind'])
class TestFlaskSqlalchemy(FlaskTestBase): """Tests for deleting resources defined as Flask-SQLAlchemy models instead of pure SQLAlchemy models. """ def setup(self): """Creates the Flask-SQLAlchemy database and models.""" super(TestFlaskSqlalchemy, self).setup() self.db = SQLAlchemy(self.flaskapp) self.session = self.db.session class Person(self.db.Model): id = self.db.Column(self.db.Integer, primary_key=True) self.Person = Person self.db.create_all() self.manager = APIManager(self.flaskapp, flask_sqlalchemy_db=self.db) self.manager.create_api(self.Person, methods=['DELETE']) def teardown(self): """Drops all tables and unregisters Flask-SQLAlchemy session signals. """ self.db.drop_all() unregister_fsa_session_signals() def test_delete(self): """Tests for deleting a resource.""" person = self.Person(id=1) self.session.add(person) self.session.commit() response = self.app.delete('/api/person/1') assert response.status_code == 204 assert self.Person.query.count() == 0
def sql_explain(): statement = request.args["sql"] params = request.args["params"] bind = request.args.get("bind") bind = bind if bind != "" else None # Validate hash hash = hashlib.sha1(current_app.config["SECRET_KEY"] + statement + params).hexdigest() if hash != request.args["hash"]: return abort(406) # Make sure it is a select statement if not statement.lower().strip().startswith("select"): return abort(406) params = json.loads(params) engine = SQLAlchemy().get_engine(current_app, bind) if engine.driver == "pysqlite": query = "EXPLAIN QUERY PLAN %s" % statement else: query = "EXPLAIN %s" % statement result = engine.execute(query, params) return g.debug_toolbar.render( "panels/sqlalchemy_explain.html", { "result": result.fetchall(), "headers": result.keys(), "sql": format_sql(statement, params), "duration": float(request.args["duration"]), }, )
def test_flask_sqlalchemy(): from flask.ext.sqlalchemy import SQLAlchemy as FlaskSQLAlchemy app = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' db = FlaskSQLAlchemy(app) class UserMixin(object): email = db.Column(db.Unicode(300)) def __init__(self, login, email): self.login = login self.email = email self.password = '******' class RoleMixin(object): description = db.Column(db.UnicodeText) auth = authcode.Auth(SECRET_KEY, db=db, UserMixin=UserMixin, RoleMixin=RoleMixin) authcode.setup_for_flask(auth, app) User = auth.User db.create_all() user = User(u'meh', u'*****@*****.**') db.session.add(user) db.session.commit() assert user.login == u'meh' assert user.email == u'*****@*****.**' assert hasattr(user, 'password') assert hasattr(user, 'last_sign_in') assert repr(user) == '<User meh>'
def connect(config, app): dbconfig = { 'user': config.DB_USERNAME, 'password': config.DB_PASSWORD, 'database': config.DB_DATABASE_NAME, 'host': config.DB_HOST, 'port': config.DB_PORT, } dbconfig.update(config.DB_OPTIONS) app.config['SQLALCHEMY_DATABASE_URI'] = "mysql://" + str(config.DB_USERNAME) + ":" + str(config.DB_PASSWORD) + "@127.0.0.1:" + str(config.DB_PORT) + "/" + config.DB_DATABASE_NAME for name, obj in inspect.getmembers(models): if inspect.isclass(obj): setattr(app, name, obj) db = SQLAlchemy(app) def _query_db(query, data=None): result = db.session.execute(text(query), data) if query[0:6].lower() != 'select': app.db.session.commit() return True else: return result def _get_one(query, data=None): result = db.session.execute(text(query), data).fetchone() return result db.query_db = _query_db db.get_one = _get_one return db
def create_app(): app = Flask(__name__) app.config.from_object('over_achiever.config') db = SQLAlchemy(app, metadata=models.metadata) db.create_all() resources.db = app.db = db oauth = OAuth(app) github = oauth.remote_app( 'github', consumer_key='507e57ab372adeb8051b', consumer_secret='08a7dbaa06ac16daab00fac53724ee742c8081c5', request_token_params={'scope': 'user:email'}, base_url='https://api.github.com/', request_token_url=None, access_token_method='POST', access_token_url='https://github.com/login/oauth/access_token', authorize_url='https://github.com/login/oauth/authorize' ) # set the token getter for the auth client github._tokengetter = lambda: session.get('github_token') resources.github = app.github = github api = Api(app) resource_map = ( (User, '/v1.0/users'), (Goal, '/v1.0/goals'), ) for resource, route in resource_map: api.add_resource(resource, route) return app
def createDB(): #sqliteDBPath = os.path.abspath(os.path.join(os.getcwd(), 'data', 't3.db')) #app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + sqliteDBPath app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://'+app.config['DATABASE']['user']+':'+app.config['DATABASE']['passwd']+'@'+app.config['DATABASE']['host']+':'+str(app.config['DATABASE']['port'] or '')+'/'+app.config['DATABASE']['schema'] db = SQLAlchemy(app, session_options={ #'autoflush': False, #'autocommit': False, 'expire_on_commit': False }) dbConfig = { 'mysql': { 'passive_updates': True, 'cascade_all': 'all, delete, delete-orphan' }, 'sqlite': { 'passive_updates': False, 'cascade_all': 'all, delete, delete-orphan' }, } dbConfigSet = app.config['SQLALCHEMY_DATABASE_URI'].split(':')[0] db._config = type('CustomConfiguration', (object,), dbConfig[dbConfigSet]) return db
class GangaAPI(unittest.TestCase): def setUp(self): app.config.from_object('settings') self.db = SQLAlchemy(app) self.db.create_all() self.client = app.test_client() def tearDown(self): self.db.session.remove() self.db.drop_all() def test_create_user_missing_password(self): data = { 'email': '*****@*****.**', } response = self.client.put('/user/', data=data) assert response.status_code, 200 def test_create_user_missing_email(self): data = { 'email': '', 'password': 123, } response = self.client.put('/user/', data=data) assert response.status_code, 200 def test_create_user_successfully(self): data = { 'email': '*****@*****.**', 'password': 123, } response = self.client.put('/user/', data=data) assert response.status_code, 200 def test_create_user_duplicate(self): data = { 'email': '*****@*****.**', 'password': 123, } response = self.client.put('/user/', data=data) assert response.status_code, 400
def initdatabase(): print("Initializing database. Please make sure all tables are deleted before executing this command.") db = SQLAlchemy() db.init_app(application) database_initialization()
def createHerokuDb(): """ Import this function and the database models into 'heroku run python' to create database on heroku """ app = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = os.environ['dbUrl'] db = SQLAlchemy(app) db.create_all()
def configure_database(app): "Database configuration should be set here" db = SQLAlchemy(app) #import web.models db.create_all() db.metadata.create_all(bind=db.engine)
def init(db_filename): """Initializes the database.""" app = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = db_filename app.config['SESSION_TYPE'] = 'filesystem' db = SQLAlchemy(app) db.create_all() return db
def setup(app): global db db = SQLAlchemy(app) import server.models.user import server.models.meeting db.create_all()
def init_db(app): global db db = SQLAlchemy(app) from models import User if app.config['DEBUG']: print 'Recreating all db' db.create_all() # I DO create everything
def init_db(app): global db, migrate db = SQLAlchemy(app) migrate = Migrate(app, db) from models import Component, Incident, Page, User, Update db.create_all() db.session.commit()
class TestCase(unittest.TestCase): def setUp(self): #app.config['TESTING'] = True #app.config['WTF_CSRF_ENABLED'] = False #app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:' #app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.join(basedir, 'test.db') #self.app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:' ''' self.app = Flask(__name__) self.app.config['TESTING'] = True self.app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.join(basedir, 'test.db') self.db = SQLAlchemy(self.app) with self.app.app_context(): self.db.session.remove() self.db.drop_all() self.db.create_all() ''' self.app = Flask(__name__) self.app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.join(basedir, 'test.db') self.app.config['TESTING'] = True #self.db = SQLAlchemy(self.app) self.db = SQLAlchemy() self.db.init_app(self.app) with self.app.app_context(): db.session.remove() db.drop_all() db.create_all() def tearDown(self): pass #self.db.session.remove() #self.db.drop_all() #os.unlink(os.path.join(basedir, 'test.db')) ''' self.app = Flask(__name__) self.db = SQLAlchemy(self.app) #db.init_app(self.app) with self.app.app_context(): self.db.drop_all() ''' #print 'tearDown' def test_user(self): u = Usuario() u.nome = 'Gold' u.login = '******' u.ativo = True u.email = '*****@*****.**' u.set_senha('gold') self.db.session.add(u) self.db.session.commit() gold = Usuario.query.filter_by(login='******').first()
def setUp(self): temp = tempfile.mkstemp() self.temp = temp self.db_fd = temp[0] app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///%s' % temp[1] app.config['TESTING'] = True self.app = app.test_client() SQLAlchemy.create_all(db)
def create_app(): app = Flask(__name__) app.config.from_object('config') global db db = SQLAlchemy(app) db.init_app(app) register_routes(app) register_error_handler(app) register_logger(app) return app
def apply_driver_hacks(self, app, info, options): SAExtension.apply_driver_hacks(self, app, info, options) if info.drivername == 'sqlite': connect_args = options.setdefault('connect_args', {}) if 'isolation_level' not in connect_args: # required to support savepoints/rollback without error. It disables # implicit BEGIN/COMMIT statements made by pysqlite (a COMMIT kills all # savepoints made). connect_args['isolation_level'] = None
def sql_select(): statement, params = load_query(request.args['query']) engine = SQLAlchemy().get_engine(current_app) result = engine.execute(statement, params) return g.debug_toolbar.render('panels/sqlalchemy_select.html', { 'result': result.fetchall(), 'headers': result.keys(), 'sql': format_sql(statement, params), 'duration': float(request.args['duration']), })
def init_app(self, app): SQLAlchemy.init_app(self, app) if app.testing: self.testing_scoped_session() @event.listens_for(Engine, "connect") def on_connect(dbapi_connection, connection_record): self.set_sqlite_pragma(dbapi_connection, connection_record) @testing_run_start.connect_via(ANY, weak=False) def on_testing_start(app): self.on_testing_start(app)
def create_app(self): app = Flask(__name__) app.debug = True app.secret_key = 'very secret' db = SQLAlchemy() db.init_app(app) class Model(db.Model): __tablename__ = 'model' id = db.Column(db.Integer, primary_key=True) self.Model = Model return app
class Config: def __init__(self,name="CR"): self.app = Flask(name) self.db = SQLAlchemy(self.app) pm.install_as_MySQLdb() self.app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://*****:*****@localhost/shuracr?charset=utf8' self.db.init_app(self.app) def get_current_db(self): return self.db def get_current_app(self): return self.app
'''------------------------------------------------------------------------------------------''' import os from flask import Flask, render_template, request from flask.ext.sqlalchemy import SQLAlchemy '''------------------------------------------------------------------------------------------''' '''------------------------------------------------------------------------------------------''' app = Flask(__name__) '''------------------------------------------------------------------------------------------''' '''------------------------------------------------------------------------------------------''' #conectarBaseDatos '''Realiza la conexion a la base de datos Este metodo se encarga de realizar la conexion a la base de datos''' app.config['SQLALCHEMY_DATABASE_URI'] = os.environ['DATABASE_URL'] app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False app.config['DEBUG'] = True bd = SQLAlchemy(app) '''------------------------------------------------------------------------------------------''' '''------------------------------------------------------------------------------------------''' class Maquina(bd.Model): id_so = bd.Column(bd.Integer, primary_key=True) kernel = bd.Column(bd.String(100), unique=True) release = bd.Column(bd.String(100), unique=True) nodename = bd.Column(bd.String(100), unique=True) kernelv = bd.Column(bd.String(100), unique=True) machine = bd.Column(bd.String(100), unique=True) processor = bd.Column(bd.String(100), unique=True) so = bd.Column(bd.String(100), unique=True) hardware = bd.Column(bd.String(100), unique=True) user_logged = bd.Column(bd.String(100), unique=True)
from flask.ext.sqlalchemy import SQLAlchemy from flask.ext import admin, wtf from flask.ext.admin.contrib import sqlamodel from flask.ext.admin.contrib.sqlamodel import filters # Create application app = Flask(__name__) # Create dummy secrey key so we can use sessions app.config['SECRET_KEY'] = '123456790' # Create in-memory database app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///test.sqlite' app.config['SQLALCHEMY_ECHO'] = True db = SQLAlchemy(app) # Create models class User(db.Model): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(80), unique=True) email = db.Column(db.String(120), unique=True) # Required for administrative interface def __unicode__(self): return self.username # Create M2M table post_tags_table = db.Table(
from flask.ext.sqlalchemy import SQLAlchemy from rootio.extensions import db #telephony_server = Flask("ResponseServer") #telephony_server.debug = True #telephony_server.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://*****:*****@localhost/rootio' db = SQLAlchemy('postgresql://*****:*****@localhost/rootio') lines = dq.query.all() print lines
#### config #### ################ application = Flask(__name__) application.config.from_object('config.ProductionConfig') #################### #### extensions #### #################### login_manager = LoginManager() login_manager.init_app(application) bcrypt = Bcrypt(application) mail = Mail(application) toolbar = DebugToolbarExtension(application) db = SQLAlchemy(application) #################### #### blueprints #### #################### with application.app_context(): from main.views import main_blueprint from user.views import user_blueprint application.register_blueprint(main_blueprint) application.register_blueprint(user_blueprint) #################### #### flask-login #### #################### from models import User
import os, gevent from psycogreen.gevent import patch_psycopg if os.fork is gevent.fork: patch_psycopg() from datetime import timedelta from sqlalchemy.orm import joinedload from flask.ext.sqlalchemy import SQLAlchemy from pager.config import config from pager.app import app from pager.libs import extend from pager.libs.timezone import now db = SQLAlchemy(app) class Mixins(object): id = db.Column(db.Integer, primary_key=True) created = db.Column(db.DateTime(True), default=now, nullable=False) updated = db.Column(db.DateTime(True), default=now, onupdate=now, nullable=False) @property def is_new(self): return id is None def to_json(self): created = self.created and self.created.isoformat() or None
# -*- coding: utf-8 -*- from flask.ext.sqlalchemy import SQLAlchemy import datetime from flask import Flask, request, render_template, redirect, Response from hashlib import sha256 import MySQLdb db = SQLAlchemy() class Exploit(db.Model): id = db.Column(db.Integer, primary_key=True) text = db.Column(db.Text) is_read = db.Column(db.Boolean) def __init__(self, text): self.text = text self.is_read = False class OneTimePassword(db.Model): id = db.Column(db.Integer, primary_key=True) password = db.Column(db.String(250), index=True, unique=True) def __init__(self, password): self.password = password app = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+mysqldb://honeypot@localhost/honeypot?charset=utf8&use_unicode=0' app.debug = False db.init_app(app) @app.route('/', methods=['GET', 'POST']) def index():
def create_app(test_config=None): # For automated tests # Setup Flask and read config from ConfigClass defined above app = Flask(__name__) app.config.from_object(__name__+'.ConfigClass') # Load local_settings.py if file exists # For automated tests try: app.config.from_object('local_settings') except: pass # Load optional test_config # For automated tests if test_config: app.config.update(test_config) # Initialize Flask extensions db = SQLAlchemy(app) # Initialize Flask-SQLAlchemy babel = Babel(app) # Initialize Flask-Babel mail = Mail(app) # Initialize Flask-Mail # Define the User data model. Make sure to add flask.ext.user UserMixin!! class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) # User authentication information username = db.Column(db.String(50), nullable=True, unique=True) password = db.Column(db.String(255), nullable=False, server_default='') reset_password_token = db.Column(db.String(100), nullable=False, server_default='') # User email information email = db.Column(db.String(255), nullable=True, unique=True) confirmed_at = db.Column(db.DateTime()) # User information active = db.Column('is_active', db.Boolean(), nullable=False, server_default='0') first_name = db.Column(db.String(100), nullable=False, server_default='') last_name = db.Column(db.String(100), nullable=False, server_default='') # Relationships roles = db.relationship('Role', secondary='user_roles', backref=db.backref('users', lazy='dynamic')) # Define UserEmail DataModel. class UserEmail(db.Model): id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey('user.id')) # User email information email = db.Column(db.String(255), nullable=True, unique=True) confirmed_at = db.Column(db.DateTime()) is_primary = db.Column(db.Boolean(), nullable=False, default=False) # Relationship user = db.relationship('User', uselist=False) class UserInvitation(db.Model): __tablename__ = 'user_invite' id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(255), nullable=False) # save the user of the invitee invited_by_user_id = db.Column(db.Integer, db.ForeignKey('user.id')) # token used for registration page to identify user registering token = db.Column(db.String(100), nullable=False, server_default='') # Define the Role data model class Role(db.Model): id = db.Column(db.Integer(), primary_key=True) name = db.Column(db.String(50), unique=True) # Define the UserRoles data model class UserRoles(db.Model): id = db.Column(db.Integer(), primary_key=True) user_id = db.Column(db.Integer(), db.ForeignKey('user.id', ondelete='CASCADE')) role_id = db.Column(db.Integer(), db.ForeignKey('role.id', ondelete='CASCADE')) # Reset all the database tables db.create_all() # Setup Flask-User db_adapter = SQLAlchemyAdapter(db, User, UserInvitationClass=UserInvitation) user_manager = UserManager(db_adapter, app) # Create regular 'member' user if not User.query.filter(User.username=='member').first(): user = User(username='******', email='*****@*****.**', active=True, password=user_manager.hash_password('Password1'), confirmed_at=datetime.datetime.utcnow()) db.session.add(user) db.session.commit() # Create 'user007' user with 'secret' and 'agent' roles if not User.query.filter(User.username=='user007').first(): user1 = User(username='******', email='*****@*****.**', active=True, password=user_manager.hash_password('Password1')) user1.roles.append(Role(name='secret')) user1.roles.append(Role(name='agent')) db.session.add(user1) db.session.commit() # The '/' page is accessible to anyone @app.route('/') def home_page(): # if current_user.is_authenticated(): # return user_profile_page() return render_template_string(""" {% extends "base.html" %} {% block content %} <h2>{%trans%}Home Page{%endtrans%}</h2> <p><a href="{{ url_for('user.login') }}">{%trans%}Sign in{%endtrans%}</a></p> {% endblock %} """) # The '/profile' page requires a logged-in user @app.route('/user/profile') @login_required # Use of @login_required decorator @confirm_email_required def user_profile_page(): return render_template_string(""" {% extends "base.html" %} {% block content %} <h2>{%trans%}Profile Page{%endtrans%}</h2> <p> {%trans%}Hello{%endtrans%} {{ current_user.username or current_user.email }},</p> <p> <a href="{{ url_for('user.change_username') }}"> {%trans%}Change username{%endtrans%}</a></p> <p> <a href="{{ url_for('user.change_password') }}"> {%trans%}Change password{%endtrans%}</a></p> <p> <a href="{{ url_for('user.invite') }}"> {%trans%}Invite User{%endtrans%}</a></p> <p> <a href="{{ url_for('user.logout') }}?next={{ url_for('user.login') }}"> {%trans%}Sign out{%endtrans%}</a></p> {% endblock %} """) # The '/special' page requires a user that has the 'special' AND ('sauce' OR 'agent') role. @app.route('/special') @roles_required('secret', ['sauce', 'agent']) # Use of @roles_required decorator def special_page(): return render_template_string(""" {% extends "base.html" %} {% block content %} <h2>{%trans%}Special Page{%endtrans%}</h2> {% endblock %} """) # For testing only app.db = db app.UserEmailClass = UserEmail return app
from serializers import ItemSerializer, PersonSerializer class Settings: DB_NAME = "inventory.db" # Put the db file in project root SQLALCHEMY_DATABASE_URI = "sqlite:///{0}".format(DB_NAME) DEBUG = True app = Flask(__name__) app.config.from_object(Settings) ### Models ### db = SQLAlchemy() db.init_app(app) class Person(db.Model): id = db.Column(db.Integer, primary_key=True) firstname = db.Column(db.String(80), nullable=False) lastname = db.Column(db.String(80), nullable=False) created = db.Column(db.DateTime, default=datetime.utcnow) @property def n_items(self): return len(self.items) def __repr__(self): return "<Person '{0} {1}'>".format(self.firstname, self.lastname)
from flask import Flask, render_template, request from flask.ext.sqlalchemy import SQLAlchemy import os import datetime app = Flask(__name__) app.config["SQLALCHEMY_DATABASE_URI"] = os.environ['DATABASE_URL'] db = SQLAlchemy(app) #http://blog.y3xz.com/blog/2012/08/16/flask-and-postgresql-on-heroku #hello class Logger(db.Model): id = db.Column(db.Integer, primary_key=True) ip_address = db.Column(db.String(400)) timestamp = db.Column(db.DateTime, default=datetime.datetime.now) def __init__(self, ip_address): self.ip_address = ip_address def __repr__(self): return '<ip_addr %r>' % self.ip_address @app.route("/index") @app.route("/") def index(): if request.headers.getlist("X-Forwarded-For"): ip = request.headers.getlist("X-Forwarded-For")[0] elif request.access_route:
from automated_survey_flask.config import config_env_files from flask import Flask from flask.ext.sqlalchemy import SQLAlchemy db = SQLAlchemy() app = Flask(__name__) def prepare_app(environment='development', p_db=db): app.config.from_object(config_env_files[environment]) p_db.init_app(app) # load views by importing them from . import views return app def save_and_commit(item): db.session.add(item) db.session.commit() db.save = save_and_commit
from flask.ext.sqlalchemy import SQLAlchemy import datetime db = SQLAlchemy() class Carrier(db.Model): """ This stores information about the various phone carrier providers. carrier_name: the string of the name domain: the domain used for emailing users: the users who use this carrier """ __tablename__ = 'cellCarrierInfo' __table_args__ = {'mysql_engine': 'InnoDB'} id = db.Column(db.Integer, primary_key=True, autoincrement=True) carrier_name = db.Column(db.Text, nullable=False) domain = db.Column(db.Text, nullable=False) users = db.relationship('User', backref='carrier') def __init__(self, name, domain): self.carrier_name = name self.domain = domain def __str__(self): return str(self.id) + ") " + self.carrier_name + ", " + self.domain class User(db.Model): """ Holds notify users' information
import os from flask import Flask, Blueprint, render_template, g from flask import jsonify, redirect, request, url_for from flask.ext.sqlalchemy import SQLAlchemy from config import SETUP, APP, API, PREFERRED_URL_SCHEME from yams_api.utils.logger import logfile API_HOST = "%s://%s:%s" % (PREFERRED_URL_SCHEME, API.LISTEN_HOST, API.LISTEN_PORT) app = Flask(__name__) app.config.from_object(os.environ.get("FLASK_CONFIG") or "config") # this should only be used for db operations related to the web interface. # if you are associating models with this, you more than likely want the API DB. app_db = SQLAlchemy(app) db = SQLAlchemy(app) navigation_dictionary_list = [{ "link": "/", "text": "/index" }, { "link": API_HOST, "text": "api" }] # blueprint routes from yams.core.dev import core_dev_blueprints for bp in core_dev_blueprints: if bp.url_prefix == '/' or not bp.url_prefix:
def get_db(): # noqa """Get modified db object.""" database = SQLAlchemy() class String(database.String): """Simple subclass of sqlalchemy.orm.String which provides a default length for `String` types to satisfy MySQL """ # pylint: disable=too-few-public-methods # this class is just to set the default string length and is not meant to # do anything else, so it does not need any other public methods. def __init__(self, length=None, *args, **kwargs): # TODO: Check for MySQL and only apply when needed if length is None: length = 250 super(String, self).__init__(length, *args, **kwargs) database.String = String database.session.plain_commit = database.session.commit database.session.commit_hooks_enable_flag = CommitHooksEnableFlag() def pre_commit_hooks(): """All pre commit hooks handler.""" with benchmark("pre commit hooks"): if not database.session.commit_hooks_enable_flag: return database.session.flush() if hasattr(database.session, "reindex_set"): database.session.reindex_set.indexing_hook() def post_commit_hooks(): """All post commit hooks handler.""" with benchmark("post commit hooks"): if not database.session.commit_hooks_enable_flag: return # delete flask caches in order to avoid # using cached instances after commit if hasattr(flask.g, "user_cache"): del flask.g.user_cache if hasattr(flask.g, "user_creator_roles_cache"): del flask.g.user_creator_roles_cache from ggrc.models.hooks import acl acl.after_commit() database.session.post_commit_hooks = post_commit_hooks database.session.pre_commit_hooks = pre_commit_hooks def hooked_commit(*args, **kwargs): """Commit override function. This function is meant for a single after commit hook that should only be used for ACL propagation. """ database.session.pre_commit_hooks() with benchmark("plain commit"): database.session.plain_commit(*args, **kwargs) database.session.post_commit_hooks() database.session.commit = hooked_commit return database
from flask import Flask, render_template, url_for from flask.ext.admin import Admin, BaseView, expose from flask.ext.sqlalchemy import SQLAlchemy from flask.ext.admin.contrib.sqla import ModelView from flask.ext.admin.contrib.fileadmin import FileAdmin from flask.ext.login import LoginManager from flask.ext.openid import OpenID SERVER_NAME = '0.0.0.0' SERVER_PORT = 5000 app = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///soundboardtags.sqlite' app.config['SECRET_KEY'] = '123456790' db = SQLAlchemy(app) lm = LoginManager() lm.init_app(app) oid = OpenID(app, os.path.join(basedir, 'tmp')) pygame.mixer.init() sound_tags_table = db.Table( 'sound_tags', db.Model.metadata, db.Column('sound_id', db.Integer, db.ForeignKey('sound.id')), db.Column('tag_id', db.Integer, db.ForeignKey('tag.id'))) class Tag(db.Model): id = db.Column(db.Integer, primary_key=True)
from flask import * from flask.ext.sqlalchemy import SQLAlchemy from forms import * from md5 import md5 import json app = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///test.db' app.secret_key = "T\xd6\\p\xf9\x8e\xd6\xc0TL\xdf\x92\x080Q\xbf\xf0)\xd1&'\xeb\xb0\x05" db = SQLAlchemy(app) library = db.Table( 'library', db.Column('author_id', db.Integer, db.ForeignKey('author.id')), db.Column('book_id', db.Integer, db.ForeignKey('book.id'))) class Author(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(30)) def __init__(self, name): self.name = name def __repr__(self): return '<Author %r>' % self.name class Book(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(50)) authors = db.relationship('Author',
from datetime import timedelta import sqlalchemy.orm.exc from flask import Flask, redirect, render_template, request, url_for from flask.ext.sqlalchemy import SQLAlchemy from flask.ext.wtf import Form from flask_admin import Admin from flask_admin.contrib.sqla import ModelView from wtforms import TextField, validators from wtforms.fields.html5 import DateField from wtforms.ext.sqlalchemy.fields import QuerySelectField, QuerySelectMultipleField app = Flask(__name__) app.config.from_object("config") app.config.from_envvar('SOOKIE_SETTINGS', silent=True) db = SQLAlchemy(app) admin = Admin(app, name='sookie', template_mode='bootstrap3') class Category(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(50), unique=True) def __init__(self, name=None): self.name = name def __str__(self): return self.name def __repr__(self): return '<Category({!r})>'.format(self.name)
from flask import Flask from flask.ext.sqlalchemy import SQLAlchemy app_tests = Flask(__name__) app_tests.config[ 'SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://api2k15:@127.0.0.1:3306/nba_flask_test' app_tests.config['WHOOSH_BASE'] = 'path_tests/to/whoosh/base' db_tests = SQLAlchemy(app_tests)
from flask import Flask, request, Response from flask import render_template, send_from_directory, url_for from flask.ext.sqlalchemy import SQLAlchemy from flask.ext.mobility import Mobility from logging import StreamHandler, DEBUG import utility import config basedir = config.basedir baseurl = config.baseurl flask_app = Flask(__name__, template_folder='public/template') flask_app.config.from_object('config') db = SQLAlchemy(flask_app) Mobility(flask_app) file_handler = StreamHandler() flask_app.logger.setLevel(DEBUG) # set the desired logging level here flask_app.logger.addHandler(file_handler) import models import controllers import scripts
# ------------------ # Init application # ------------------ from flask import Flask from flask.ext.sqlalchemy import SQLAlchemy import os app_instance = Flask(__name__, static_url_path='') app_instance.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True app_instance.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False app_instance.config['SQLALCHEMY_DATABASE_URI'] = os.getenv('GGMATE_DB') db = SQLAlchemy(app_instance) import ggmate
from flask import Flask from flask.ext.sqlalchemy import SQLAlchemy app = Flask(__name__) # 配置数据库链接地址 app.config[ "SQLALCHEMY_DATABASE_URI"] = "mysql://*****:*****@127.0.0.1:3306/manytomany9" # 是否跟踪数据库的修改 app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False # 初始化数据库操作对象 db = SQLAlchemy(app) # 学生与课程的对应表关系 # 一张表里面可以有多个主键,表示多个主键联结起来在当前这张表里面不能有重复数据,定义方式就是在多个字段后面添加 primary_key=True tb_student_course = db.Table( "tb_student_course", db.Column("student_id", db.Integer, db.ForeignKey("student.id")), db.Column("course_id", db.Integer, db.ForeignKey("course.id"))) # 定义学生的模型 class Student(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(64)) # 表示当前学生选择的所有课程 # secondary 指定多对多关联关系中的中间表 courses = db.relationship("Course", lazy="dynamic",
from datetime import datetime from sqlalchemy.orm.exc import NoResultFound from kvoter.app import app from flask.ext.sqlalchemy import SQLAlchemy from flask.ext.login import UserMixin import hashlib from random import choice from string import ascii_letters, digits app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///kvoter.db" db = SQLAlchemy(app) roles_users = db.Table( 'user_roles', db.Column('user_id', db.Integer(), db.ForeignKey('users.id')), db.Column('role_id', db.Integer(), db.ForeignKey('roles.id')) ) class Candidate(db.Model): __tablename__ = 'candidates' id = db.Column(db.Integer(), primary_key=True) user_id = db.Column(db.Integer(), db.ForeignKey('users.id')) election_id = db.Column(db.Integer(), db.ForeignKey('elections.id')) def __init__(self, user_id, election_id): self.user_id = user_id self.election_id = election_id
def __call__(self, environ, start_response): if self.script_name: environ['SCRIPT_NAME'] = self.script_name path_info = environ['PATH_INFO'] if path_info.startswith(self.script_name): environ['PATH_INFO'] = path_info[len(self.script_name):] scheme = environ.get('HTTP_X_SCHEME', '') if scheme: environ['wsgi.url_scheme'] = scheme return self.app(environ, start_response) app = Flask(__name__) app.secret_key = "V=7Km+XXkg:}>4dT0('cV>Rp1TG82QEjah+X'v;^w:)a']y)^%" db = app.db = SQLAlchemy(app) models.register_base(db) opts = app.opts = None contest = app.contest = None app.context_processor(context_processor) app.register_blueprint(default) app.register_blueprint(judge, url_prefix="/judge") @app.before_request def before_request(): g.request_start_time = time.time() g.request_time = lambda: time.time() - g.request_start_time
basedir, 'data.sqlite') # 指定数据库URI app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True app.config['MAIL_SERVER'] = 'smtp.qq.com' app.config['MAIL_PORT'] = 587 # 465 app.config['MAIL_USE_TLS'] = True app.config['MAIL_USERNAME'] = os.environ.get('MAIL_USERNAME') app.config['MAIL_PASSWORD'] = os.environ.get('MAIL_PASSWORD') app.config['FLASKY_MAIL_SUBJECT_PREFIX'] = '[Flasky]' app.config['FLASKY_MAIL_SENDER'] = 'Flasky Admin <' + app.config[ 'MAIL_USERNAME'] + '>' app.config['FLASKY_ADMIN'] = os.environ.get('FLASKY_ADMIN') manager = Manager(app) # 命令行解析功能 bootstrap = Bootstrap(app) # 集成Bootstrap框架 moment = Moment(app) # 渲染日期和时间 db = SQLAlchemy(app) # 创建数据库 mail = Mail(app) # 初始化Flask-Mail migrate = Migrate(app, db) manager.add_command('db', MigrateCommand) class NameForm(Form): name = StringField('What is your name?', validators=[Required()]) submit = SubmitField('Submit') class Role(db.Model): __tablename__ = 'roles' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(64), unique=True)
# -*- coding: utf-8 -*- from flask import Flask from flask.ext.sqlalchemy import SQLAlchemy asem = Flask(__name__) asem.config.from_object('config') db = SQLAlchemy(asem) from views import views asem.debug = True
import sys import os import hashlib import random import time from datetime import datetime print "importing sha3" import sha3 from flask.ext.sqlalchemy import SQLAlchemy sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) from apper import * user_db = SQLAlchemy(app) #https://github.com/mrjoes/flask-admin/blob/master/examples/auth/app.py class User(user_db.Model): id = user_db.Column(user_db.Integer, primary_key=True) first_name = user_db.Column(user_db.String(100)) last_name = user_db.Column(user_db.String(100)) login = user_db.Column(user_db.String(80), unique=True) email = user_db.Column(user_db.String(120)) password = user_db.Column(user_db.String(400)) salt = user_db.Column(user_db.String(400)) # Flask-Login integration def is_authenticated(self): return True
# app.model import datetime from flask.ext.sqlalchemy import SQLAlchemy from app.utils import escapeDatetime db = SQLAlchemy() owner_event_association = db.Table('owner_event_association', db.Column('user_id', db.Integer, db.ForeignKey('user.id')), db.Column('event_id', db.Integer, db.ForeignKey('event.id')) ) applicant_event_association = db.Table('applicant_event_association', db.Column('user_id', db.Integer, db.ForeignKey('user.id')), db.Column('event_id', db.Integer, db.ForeignKey('event.id')) ) participant_event_association = db.Table('participant_event_association', db.Column('user_id', db.Integer, db.ForeignKey('user.id')), db.Column('event_id', db.Integer, db.ForeignKey('event.id')) ) class User(db.Model): __tablename__ = 'user' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(80), unique=True) email = db.Column(db.String(120), unique=True) password = db.Column(db.String(20), default='') status = db.Column(db.String(50), default='') description = db.Column(db.String(500), default='')
from datetime import datetime from flask.ext.login import UserMixin from flask.ext.sqlalchemy import SQLAlchemy from sqlalchemy.dialects.postgresql import JSON import uuid64 from finance.exceptions import (AssetValueUnavailableException, InvalidTargetAssetException) db = SQLAlchemy() JsonType = db.String().with_variant(JSON(), 'postgresql') class CRUDMixin(object): """Copied from https://realpython.com/blog/python/python-web-applications-with-flask-part-ii/ """ # noqa __table_args__ = {'extend_existing': True} id = db.Column(db.BigInteger, primary_key=True, autoincrement=False, default=uuid64.issue()) @classmethod def create(cls, commit=True, **kwargs): if 'id' not in kwargs: kwargs.update(dict(id=uuid64.issue())) instance = cls(**kwargs)
class TestFSA(FlaskTestBase): """Tests which use models defined using Flask-SQLAlchemy instead of pure SQLAlchemy. """ def setUp(self): """Creates the Flask application, the APIManager, the database, and the Flask-SQLAlchemy models. """ super(TestFSA, self).setUp() # initialize SQLAlchemy and Flask-Restless self.db = SQLAlchemy(self.flaskapp) # for the sake of brevity... db = self.db # declare the models class Computer(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.Unicode, unique=True) vendor = db.Column(db.Unicode) buy_date = db.Column(db.DateTime) owner_id = db.Column(db.Integer, db.ForeignKey('person.id')) owner = db.relationship('Person', backref=db.backref('computers', lazy='dynamic')) class Person(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.Unicode, unique=True) age = db.Column(db.Float) other = db.Column(db.Float) birth_date = db.Column(db.Date) self.Person = Person self.Computer = Computer # create all the tables required for the models self.db.create_all() def tearDown(self): """Drops all tables from the temporary database.""" self.db.drop_all() unregister_fsa_session_signals() def test_flask_sqlalchemy(self): """Tests that :class:`flask.ext.restless.APIManager` correctly exposes models defined using Flask-SQLAlchemy. """ manager = APIManager(self.flaskapp, flask_sqlalchemy_db=self.db) # create three different APIs for the same model manager.create_api(self.Person, methods=['GET', 'POST']) manager.create_api(self.Person, methods=['PATCH'], url_prefix='/api2') manager.create_api(self.Person, methods=['GET'], url_prefix='/readonly') # test that specified endpoints exist response = self.app.post('/api/person', data=dumps(dict(name='foo'))) assert response.status_code == 201 assert loads(response.data)['id'] == 1 response = self.app.get('/api/person') assert response.status_code == 200 assert len(loads(response.data)['objects']) == 1 assert loads(response.data)['objects'][0]['id'] == 1 response = self.app.patch('/api2/person/1', data=dumps(dict(name='bar'))) assert response.status_code == 200 assert loads(response.data)['id'] == 1 assert loads(response.data)['name'] == 'bar' # test that the model is the same as before response = self.app.get('/readonly/person') assert response.status_code == 200 assert len(loads(response.data)['objects']) == 1 assert loads(response.data)['objects'][0]['id'] == 1 assert loads(response.data)['objects'][0]['name'] == 'bar' def test_init_app(self): manager = APIManager() manager.init_app(self.flaskapp, flask_sqlalchemy_db=self.db) manager.create_api(self.Person, app=self.flaskapp) response = self.app.get('/api/person') assert response.status_code == 200 def test_init_app_split_initialization(self): manager = APIManager(flask_sqlalchemy_db=self.db) manager.init_app(self.flaskapp) manager.create_api(self.Person, app=self.flaskapp) response = self.app.get('/api/person') assert response.status_code == 200
from flask import Flask, render_template, jsonify, abort, request from flask.ext.restless import APIManager from flask.ext.sqlalchemy import SQLAlchemy app = Flask(__name__) app.config.from_pyfile('config.py') db = SQLAlchemy(app) class Developer(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Colum(db.String(20)) hireDate = db.Colum(db.Date) focus = db.Colum(db.String(50)) def __init__(self, name, hireDate, focus) self.name = name self.hireDate = datetime.datetime.strptime(hireDate, %d%m%y).date() self.focus = focus db.createAll() @app.route('/dev/', methods=['GET']) def index(): return jsonify({ 'Developers': Developer.querry.get(id)})
from flask.ext.sqlalchemy import SQLAlchemy from werkzeug import generate_password_hash, check_password_hash from flaskblog import app from config import WHOOSH_ENABLED from math import ceil db = SQLAlchemy(app) class Admin(db.Model): __tablename__ = 'admin' id = db.Column(db.Integer, primary_key=True) userd = db.Column(db.String(100)) def __init__(self, user): self.user = user def __repr__(self): return "<User: %s>" % (self.userd) def is_authenticated(self): return True def is_active(self): return True def is_anonymous(self): return False def get_id(self): return unicode(self.id)