import enum
import flask_sqlalchemy
database = flask_sqlalchemy.SQLAlchemy()
class Privacy(enum.IntEnum):
PUBLIC = 0
UNLISTED = 1
PRIVATE = 2
class BlogPost(database.Model):
__tablename__ = "blogposts"
post_id = database.Column(database.String, primary_key=True)
author = database.Column(database.String, nullable=False)
content = database.Column(database.Text, nullable=False)
timestamp = database.Column(database.DateTime, nullable=False)
privacy = database.Column(database.Enum(Privacy), nullable=False)
def as_dict(self):
return {
"id": self.post_id,
"author": self.author,
"content": self.content,
"timestamp": self.timestamp
}
class Redirect(database.Model):
def test_pool_class_with_pool_size_zero(self, m_create_engine, app_nr, recwarn):
app_nr.config['SQLALCHEMY_POOL_SIZE'] = 0
with pytest.raises(RuntimeError) as exc_info:
fsa.SQLAlchemy(app_nr).get_engine()
expected = 'SQLite in memory database with an empty queue not possible due to data loss.'
assert exc_info.value.args[0] == expected
import flask_bcrypt as _fb
import flask_migrate as _fm
import flask_sqlalchemy as _fs
db = _fs.SQLAlchemy()
migrate = _fm.Migrate(db=db)
bcrypt = _fb.Bcrypt()
def init_app(app, **kwargs):
db.app = app
migrate.init_app(app)
db.init_app(app)
from .signup import Signup_Request, SignupSchema
from .user import User
from .revoked_token import RevokedToken
from .history_pass_change import HistoryPassChange
from .history_wrong_password import HistoryWrongPass
from .user_action import UserAction
from .role import Role, user_role_table, RoleSchema
from .category import Category, UserCategoryAction, LogAction, category_book_table
from .book import Book, UserBookAction
from .social_login import SocialLogin, SocialName
def test_convert_unicode_default_sa_13(self, m_sqlalchemy, m_create_engine, app_nr):
m_sqlalchemy.__version__ = '1.3'
fsa.SQLAlchemy(app_nr).get_engine()
args, options = m_create_engine.call_args
assert 'convert_unicode' not in options
def test_config_from_init(self, m_create_engine, app_nr):
fsa.SQLAlchemy(app_nr, engine_options={'bar': 'baz'}).get_engine()
args, options = m_create_engine.call_args
assert options['bar'] == 'baz'
from flask import Flask
from flask import jsonify
from flask import make_response
import flask_jsonschema
import flask_sqlalchemy
import os
from sqlalchemy.exc import IntegrityError
app = Flask(__name__)
# Registering flask extensions
app.config['JSONSCHEMA_DIR'] = os.path.join(app.root_path, 'schemas')
flask_jsonschema.JsonSchema(app)
db = flask_sqlalchemy.SQLAlchemy(app, session_options={'autocommit': True})
# Registering blueprints
from collector.api.resources.action_logs import bp as action_logs_bp
from collector.api.resources.ping import bp as ping_bp
app.register_blueprint(action_logs_bp)
app.register_blueprint(ping_bp)
# Registering error handlers
@app.errorhandler(400)
def bad_request(error):
app.logger.error("Bad request: {}".format(error))
return make_response(
jsonify({
'status': 'error',
def test_engine_echo_default(self, m_create_engine, app_nr):
fsa.SQLAlchemy(app_nr).get_engine()
args, options = m_create_engine.call_args
assert 'echo' not in options
def createApp():
app = flask.Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = os.environ['DATABASE_URL']
app.register_blueprint(page_blueprint)
db = flask_sqlalchemy.SQLAlchemy(app)
return app
import flask
import flask_bcrypt
import flask_login
import flask_mail
import flask_sqlalchemy as flask_sqa
import flaskblog.config as flaskblog_cf
db = flask_sqa.SQLAlchemy()
bcrypt = flask_bcrypt.Bcrypt()
login_manager = flask_login.LoginManager()
login_manager.login_view = "users.login"
login_manager.login_message_category = "info"
mail = flask_mail.Mail()
def create_app(config_class=flaskblog_cf.Config):
"""Creates the app and initializes the config of the app
Parameters
----------
config_class : Object, optional
Manage the app setup settings, by default Config
"""
app = flask.Flask(__name__)
app.config.from_object(flaskblog_cf.Config)
db.init_app(app)
bcrypt.init_app(app)
import flask_sqlalchemy
from sqlalchemy import MetaData
from flask_jwt_extended.jwt_manager import JWTManager
naming_convention = {
"ix": 'ix_%(column_0_label)s',
"uq": "uq_%(table_name)s_%(column_0_name)s",
"ck": "ck_%(table_name)s_%(column_0_name)s",
"fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s",
"pk": "pk_%(table_name)s"
}
db = flask_sqlalchemy.SQLAlchemy(metadata=MetaData(
naming_convention=naming_convention))
jwt = JWTManager()
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import flask_sqlalchemy
from datetime import datetime
db = flask_sqlalchemy.SQLAlchemy(session_options={"expire_on_commit": False})
class Forecast(db.Model):
__tablename__ = "forecast"
id = db.Column(db.Integer,
nullable=False,
unique=True,
autoincrement=True,
primary_key=True)
city_name = db.Column(db.String(50), nullable=False, index=True)
country_code = db.Column(db.String(5), nullable=False)
timestamp = db.Column(db.Float, index=True)
temp_max = db.Column(db.Float)
temp_min = db.Column(db.Float)
temp_day = db.Column(db.Float)
feels_like_day = db.Column(db.Float)
humidity = db.Column(db.Float)
weather_id = db.Column(db.Integer)
weather_description = db.Column(db.String(50))
def save(self):
db.session.add(self)
db.session.commit()
import flask_sqlalchemy
from flask import Flask
from flask_socketio import SocketIO
app = Flask(__name__)
app.config.from_pyfile('settings.py')
db = flask_sqlalchemy.SQLAlchemy(
app
) #settings.py: SQLALCHEMY_DATABASE_URI = 'sqlite:///QA.db' #models.py: (cant be empty, must have elements and atraburtes)db.create_all(app=app) #run manage.py, then QA.db will eventryaly appear #left click QA.db the click 'As Data Source...'
socketio = SocketIO(app)
from zeeguu_core.configuration.configuration import load_configuration_or_abort
# If zeeguu_core.app is already defined we use that object
# as the app for the db_init that we do later. If not,
# we create the app here and load the corresponding configuration
if not hasattr(zeeguu_core, "app"):
zeeguu_core.app = Flask("Zeeguu-Core")
load_configuration_or_abort(zeeguu_core.app, 'ZEEGUU_CORE_CONFIG',
['MAX_SESSION',
'SQLALCHEMY_DATABASE_URI',
'SQLALCHEMY_TRACK_MODIFICATIONS'])
# Create the zeeguu_core.db object, which will be the superclass
# of all the model classes
zeeguu_core.db = flask_sqlalchemy.SQLAlchemy(zeeguu_core.app)
# Note, that if we pass the app here, then we don't need later
# to push the app context
# the core model
from .language import Language
from .url import Url
from .domain_name import DomainName
from .article import Article
from .bookmark import Bookmark
from .text import Text
from .user import User
from .user_word import UserWord
from .user_preference import UserPreference
from .session import Session
from .unique_code import UniqueCode
session = self()
return getattr(session, name)
webapp = flask.Flask('sql')
webapp.debug = True
webapp.config['SQLALCHEMY_DATABASE_URI'] \
= 'mysql+pymysql://[email protected]/ops'
webapp.config['SQLALCHEMY_BINDS'] = {
'default': 'mysql+pymysql://[email protected]/ops',
'local': 'mysql+pymysql://[email protected]/ops',
}
db = flask_sqlalchemy.SQLAlchemy(webapp)
db.session = SessionHolder(webapp, db)
def index():
row = db.session.execute('show variables like "version"').fetchone()
print(row)
row = db.session('local').execute(
'show variables like "version"').fetchone()
print(row)
return ''
webapp.route('/')(index)
webapp.run('0.0.0.0', port=3000, threaded=True)
from flask import Flask, jsonify, request
from flask_cors import CORS
import flask_sqlalchemy as sqlalchemy
from werkzeug.security import generate_password_hash, check_password_hash
from sqlalchemy import desc, distinct
import datetime
import json
app = Flask(__name__)
CORS(app)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///database.db'
db = sqlalchemy.SQLAlchemy(app)
# creates a table for the student information
class courses(db.Model):
courseId = db.Column(db.Integer, primary_key=True)
courseNumber = db.Column(db.String(100))
courseTitle = db.Column(db.String(100))
offeredQuarter = db.Column(db.String(100))
description = db.Column(db.String(1000))
link = db.Column(db.String(1000))
class links(db.Model):
linkId = db.Column(db.Integer, primary_key=True)
linkName = db.Column(db.String(100))
linkLocation = db.Column(db.String(5000))
# from flask import Flask
# from flask_sqlalchemy import SQLAlchemy
# from flask_redis import FlaskRedis
convention = {
"ix": 'ix_%(column_0_label)s',
"uq": "uq_%(table_name)s_%(column_0_name)s",
"ck": "ck_%(table_name)s_%(column_0_name)s",
"fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s",
"pk": "pk_%(table_name)s"
}
metadata = MetaData(naming_convention=convention)
# Globally accessible libraries
db = flask_sqlalchemy.SQLAlchemy(metadata=metadata)
guard = flask_praetorian.Praetorian()
cors = flask_cors.CORS()
migrate = flask_migrate.Migrate()
swag = Swagger(template={
"swagger": "2.0",
"info": {
"title": "Simulator APP",
"version": "1.0",
},
"consumes": [
"application/json",
],
"produces": [
"application/json",
],
from flask import Flask
import flask_login
import flask_sqlalchemy
app = Flask(__name__)
app.config.from_object('flask_config')
db = flask_sqlalchemy.SQLAlchemy(app,
session_options={
'expire_on_commit': False,
})
session = db.session
login_manager = flask_login.LoginManager()
login_manager.init_app(app)
import models
from views import *
if __name__ == '__main__':
app.run(host='0.0.0.0',
debug=config.BUILD_ENVIRONMENT == constants.build_environment.DEV)
DOTENV_PATH = join(dirname(__file__), "redirect.env")
load_dotenv(DOTENV_PATH)
DOTENV_PATH = join(dirname(__file__), "twilio.env")
load_dotenv(DOTENV_PATH)
TWILIO_ACCOUNT_SID = os.environ["TWILIO_ACCOUNT_SID"]
TWILIO_AUTH_TOKEN = os.environ["TWILIO_AUTH_TOKEN"]
CLIENT = Client(TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN)
GOOGLE_URI_HTTP = os.environ["GOOGLE_URI_HTTP"]
GOOGLE_URI_HTTPS = os.environ["GOOGLE_URI_HTTPS"]
DATABASE_URI = os.environ["DATABASE_URL"]
APP.config["SQLALCHEMY_DATABASE_URI"] = DATABASE_URI
DB = flask_sqlalchemy.SQLAlchemy(APP)
import models
def init_db(APP):
''' initialize the database '''
DB.init_app(APP)
DB.APP = APP
DB.session.commit()
def update_calendar_event(incoming_msg, email, message):
''' Update google calendar event given an event summary or date tag '''
person = get_person_object(email)
cred = person.cred
__author__ = 'Aleksandr Vavilin'
from flask import Blueprint, render_template, request, Response, current_app, session, jsonify
import flask_sqlalchemy
from tbdd_pdm_core.api import users, exceptions
db = flask_sqlalchemy.SQLAlchemy(current_app)
node = Blueprint('auth', __name__)
@node.route('/login', methods=['POST'])
def login():
user_login = request.json.get('login')
user_password_hash = request.json.get('password_hash')
try:
if users.login_user_by_password_hash(db.session, user_login,
user_password_hash):
session['login'] = user_login
return jsonify({'result': 'OK'}), 200
except exceptions.LoginFailedException:
return jsonify({'result': 'login failed'}), 200
@node.route('/logout')
def logout():
session.pop('login')
return jsonify({'result': 'OK'}), 200
@node.route('/loggedin')
def loggedin():
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
import models # noqa: E402
import utils # noqa: E402
from utils import DictTree # noqa: E402
DEBUG = False
# logging.basicConfig()
# logging.getLogger('sqlalchemy.engine').setLevel(logging.INFO)
app_name = 'HIL-MT'
app = flask.Flask(app_name)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///hilmt/hilmt.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.json_encoder = DictTree.JSONEncoder
db = sql.SQLAlchemy(app)
MIN_VALID_DATA = 2
NUM_FOLDS = 20
EPSILON = 1e-6
class SubSkill(db.Model):
__tablename__ = 'sub_skills'
domain_name = db.Column(db.String, db.ForeignKey('agent_skills.domain_name'), primary_key=True)
agent_name = db.Column(db.String, db.ForeignKey('agent_skills.agent_name'), primary_key=True)
skill_name = db.Column(db.String, db.ForeignKey('agent_skills.skill_name'), primary_key=True)
sub_skill_index = db.Column(db.Integer, primary_key=True)
sub_skill_name = db.Column(db.String, db.ForeignKey('agent_skills.skill_name'))
def test_engine_echo_true(self, m_create_engine, app_nr):
app_nr.config['SQLALCHEMY_ECHO'] = True
fsa.SQLAlchemy(app_nr).get_engine()
args, options = m_create_engine.call_args
assert options['echo'] is True
import flask_marshmallow import flask_sqlalchemy import minesweeper.models.base db = flask_sqlalchemy.SQLAlchemy(model_class=minesweeper.models.base.BaseModel) marshmallow = flask_marshmallow.Marshmallow()
def test_config_from_engine_options(self, m_create_engine, app_nr):
app_nr.config['SQLALCHEMY_ENGINE_OPTIONS'] = {'foo': 'bar'}
fsa.SQLAlchemy(app_nr).get_engine()
args, options = m_create_engine.call_args
assert options['foo'] == 'bar'
def db(app):
return fsa.SQLAlchemy(app)
def test_pool_class_default(self, m_create_engine, app_nr):
fsa.SQLAlchemy(app_nr).get_engine()
args, options = m_create_engine.call_args
assert options['poolclass'].__name__ == 'StaticPool'
def test_basic_binds(self):
import tempfile
_, db1 = tempfile.mkstemp()
_, db2 = tempfile.mkstemp()
def _remove_files():
import os
try:
os.remove(db1)
os.remove(db2)
except IOError:
pass
atexit.register(_remove_files)
app = flask.Flask(__name__)
app.config['SQLALCHEMY_ENGINE'] = 'sqlite://'
app.config['SQLALCHEMY_BINDS'] = {
'foo': 'sqlite:///' + db1,
'bar': 'sqlite:///' + db2
}
db = sqlalchemy.SQLAlchemy(app)
class Foo(db.Model):
__bind_key__ = 'foo'
__table_args__ = {"info": {"bind_key": "foo"}}
id = db.Column(db.Integer, primary_key=True)
class Bar(db.Model):
__bind_key__ = 'bar'
id = db.Column(db.Integer, primary_key=True)
class Baz(db.Model):
id = db.Column(db.Integer, primary_key=True)
db.create_all()
# simple way to check if the engines are looked up properly
self.assertEqual(db.get_engine(app, None), db.engine)
for key in 'foo', 'bar':
engine = db.get_engine(app, key)
connector = app.extensions['sqlalchemy'].connectors[key]
self.assertEqual(engine, connector.get_engine())
self.assertEqual(str(engine.url),
app.config['SQLALCHEMY_BINDS'][key])
# do the models have the correct engines?
self.assertEqual(db.metadata.tables['foo'].info['bind_key'], 'foo')
self.assertEqual(db.metadata.tables['bar'].info['bind_key'], 'bar')
self.assertEqual(db.metadata.tables['baz'].info.get('bind_key'), None)
# see the tables created in an engine
metadata = db.MetaData()
metadata.reflect(bind=db.get_engine(app, 'foo'))
self.assertEqual(len(metadata.tables), 1)
self.assertTrue('foo' in metadata.tables)
metadata = db.MetaData()
metadata.reflect(bind=db.get_engine(app, 'bar'))
self.assertEqual(len(metadata.tables), 1)
self.assertTrue('bar' in metadata.tables)
metadata = db.MetaData()
metadata.reflect(bind=db.get_engine(app))
self.assertEqual(len(metadata.tables), 1)
self.assertTrue('baz' in metadata.tables)
# do the session have the right binds set?
self.assertEqual(
db.get_binds(app), {
Foo.__table__: db.get_engine(app, 'foo'),
Bar.__table__: db.get_engine(app, 'bar'),
Baz.__table__: db.get_engine(app, None)
})
from ntg_common.config import args, init_logging
from ntg_common import db_tools
from ntg_common.exceptions import EditException
import login
import main
import info
import static
import textflow
import comparison
import editor
import set_cover
import checks
dba = flask_sqlalchemy.SQLAlchemy()
user, _role, _roles_users = login.declare_user_model_on(dba)
db_adapter = flask_user.SQLAlchemyAdapter(dba, user)
login_manager = flask_login.LoginManager()
login_manager.anonymous_user = login.AnonymousUserMixin
user_manager = flask_user.UserManager(db_adapter)
mail = flask_mail.Mail()
class Config():
""" Default configuration object. """
APPLICATION_HOST = 'localhost'
APPLICATION_PORT = 5000
APPLICATION_DESCRIPTION = ''
CONFIG_FILE = '_global.conf' # default = ./instance/_global.conf
def test_connection_binds(self):
app = flask.Flask(__name__)
db = sqlalchemy.SQLAlchemy(app)
assert db.session.connection()
import flask_sqlalchemy from .app import app db = flask_sqlalchemy.SQLAlchemy(app)
# If zeeguu.app is already defined we use that object
# as the app for the db_init that we do later. If not,
# we create the app and load the corresponding configuration
if not hasattr(zeeguu, "app"):
zeeguu.app = Flask("Zeeguu-Core")
load_configuration_or_abort(zeeguu.app, 'ZEEGUU_CORE_CONFIG')
# Either local, or injected our app config should have at least these
assert_configs(zeeguu.app.config, [
'SQLALCHEMY_DATABASE_URI', 'MAX_SESSION', 'SQLALCHEMY_TRACK_MODIFICATIONS'
])
# Create the zeeguu.db object, which will be the superclass
# of all the model classes
zeeguu.db = flask_sqlalchemy.SQLAlchemy(zeeguu.app)
# Note, that if we pass the app here, then we don't need later
# to push the app context
from .bookmark import Bookmark
from .domain_name import DomainName
from .user import User
from .exercise import Exercise
from .exercise_outcome import ExerciseOutcome
from .exercise_source import ExerciseSource
from .feed import RSSFeed
from .feed_registrations import RSSFeedRegistration
from .knowledge_estimator import SimpleKnowledgeEstimator
from .language import Language
from .session import Session
from .text import Text
