{{ post['title'] }}
by {{ post.author.username }} on {{ post.created.strftime('%Y-%m-%d') }}
{{ post['body'] }}
{{ message }}
{% endfor %}
{% block content %}{% endblock %}
hK
cf{p;EHV#ݕI\
gR{qwC>f*m!>
M%LK4W3r4='WNs~x AH[DI0E a` 9e@\)">'4HkgN4/Jn V
IFla";*뼵oٶS %ui%˶FGpSlҿfymL\+7+׀Fn]r`*!DعuwlۅBmnmkKgiOL;W)*@\<`BN7{aOOx?9gI{ybC!mU&,LNhb{IԸKr>MP -2Hu7- X9wp3Yq݀KR
\U6M\ Em
8 m K#ȱ wnL9##DmgEu2ѡ6M(2h6t#&b!~2~loٶ
P/
#흷MZEoHwߤ<>,a&E>U8 0-ȶ[گxXۼ'GhK3[{B #TB vBF[D8xHU^ 63UȮWiMU'"ly4U=PopRap+͡;^̸p,@3*klEI}vY*a[c/If
eʱƮq;$Ql!q;@ϲ/JӬ8~Gژd8´A6$IS3=rN
k+cFF%ʔ$dV FEi seX jP>>1`BNIF mg&4{} cyiZxLS]Ѥf&Zx,p^v pvڻ+boc{2sz4amidvyc} 5&ݏK˲4Kp/[+}ٞp~rx<6z= ;I± GܛT$oZ$[+!" !B]JH7U=?u6V(릴!BMOүŕ4q-PG^_LGYN"NDEd's3H $,ӗu6Y=6gx?$uIqNX>LЀ9ַW:'sLRqD.s]?MUX_;XDƙԑzU=? |N(z++Hb ={D(%cʜXSoBKb+ͫR\Pi:$G Y:F\\gL!܇eMa>lBxBffx3: #$c 0UD:?`X܃왊!-ilJ&̚
KOӈ6S[wB `4*clJ\`) ȥe pJ|d1j~}ʾ)x$agfƽIU0sAFXf_6OdoKxWsl=/-3!62 sc)nE Ӗlcτgljm@8T[w"{ ж&E ,"Ǘ, pO~]lm3=]$" UC.5a5)h2rKDa<HJ5tpD"PU@B>bH˽hyz%~\wIהq֩NJPbI̲UE`ۦ:3ܯl|%!pFqL,߽]#Y 8停eTޥWCz⁺Iĥ$"#cH~>כ!zr5z+^0Q52)(x7"x4D\pBL6nlj6 \Mi\T6vw/"{%equ3^P/)RO QN5:?6$[}e_Lj5"ה -WI\LNK65
DZ[v$A\dh\qNJL!?4!$**ў3flܜ}٥ff|>eU
ZBǡf9X¨"c^WDz &T9
h{nFS$)h2'AjX!-6l E䄄HIS48`7zM jic! bp.SV\c dvkC/fU= N\BZG&8O [it f4y eVAN7 >.lY
qYxh%H/ w%-"[6AW%v \F' %8y ⲏDUBp7b ,0_g fNƅNae8w߇fF:I~ CJkt_;KptYVZյP3^^5&^6;b NL
}bqṲM-4
F۪:
ϒE\m B86$ḍqA>?cfj Bٶ6a21-g1)2%؆<vQ L⼑Z0ѿRLb VMpxм7XJj]se
ڻLM
_jF%kc %x3, ᴂj2m;I!M qeL
8g39_Z% sղR<0<VZr}}52LE1B* SMrW"T&2FVaئp&q%歌G |mߠ!~TK FZGsBzTKU=̐%t$~ Ql <$"^/wߢkmgcdI,2)"g XI<&LLi
I+hHǘvRܒa8&#*cgv8 *0!.oseh1D`3& e:}fh?f.M]~ E{M?mְm_ѾXeM
aiO)aWQKDvE4 }I|LZL3L(LW}jŪi?#EA9&<:_o$t |eH;=Bnʾmh 7"
U}wS{qo5WvRg qli g}i暐iMU0R,ƍ˦Qq:Zô_$n"ԨDXEo4tA0;}!([?CKHD'= vUҰFq3bZ"LX
.Q\LxMZFc(Kլ[x'lp&15iK*$8,Tb pQtVUǫ6o
"r VD,FTflg[LX8ynV D_ٚ][k_)Hb Nzu^X $Re=9+S2rwTy GgNB`""rkk~2^'f!U/e _EV/7t"Nj"D9%>Q(2ӈ=3q%.C)?흼OpSD!cJ1J7`١eqjq /"-Lm Sm3>|F[dio4aKYc%J[JyUB#ބxm" {{ post['body'] }} {{
"Error: " if category == 'error' }}{{ message }}{% block title %}Log In{% endblock %}
{% endblock %}
{% block content %}
{% endblock %}
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1590591119.0
Flask-SQLAlchemy-2.5.1/examples/flaskr/flaskr/templates/auth/register.html 0000644 0001750 0001750 00000000654 00000000000 025520 0 ustar 00david david {% extends 'base.html' %}
{% block header %}
{% block title %}Register{% endblock %}
{% endblock %}
{% block content %}
{% endblock %}
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1590591119.0
Flask-SQLAlchemy-2.5.1/examples/flaskr/flaskr/templates/base.html 0000644 0001750 0001750 00000001360 00000000000 023640 0 ustar 00david david
{{ message }}
{% endfor %}
{% block content %}{% endblock %}
{% block title %}New Post{% endblock %}
{% endblock %}
{% block content %}
{% endblock %}
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1590591119.0
Flask-SQLAlchemy-2.5.1/examples/flaskr/flaskr/templates/blog/index.html 0000644 0001750 0001750 00000001401 00000000000 024754 0 ustar 00david david {% extends 'base.html' %}
{% block header %}
{% block title %}Posts{% endblock %}
{% if g.user %}
New
{% endif %}
{% endblock %}
{% block content %}
{% for post in posts %}
{% if g.user['id'] == post['author_id'] %}
Edit
{% endif %}
{{ post['title'] }}
by {{ post.author.username }} on {{ post.created.strftime('%Y-%m-%d') }}
{% endif %}
{% endfor %}
{% endblock %}
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1590591119.0
Flask-SQLAlchemy-2.5.1/examples/flaskr/flaskr/templates/blog/update.html 0000644 0001750 0001750 00000001234 00000000000 025133 0 ustar 00david david {% extends 'base.html' %}
{% block header %}
{% block title %}Edit "{{ post['title'] }}"{% endblock %}
{% endblock %}
{% block content %}
{% endblock %}
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1590591119.0
Flask-SQLAlchemy-2.5.1/examples/flaskr/setup.cfg 0000644 0001750 0001750 00000001111 00000000000 020373 0 ustar 00david david [metadata]
name = flaskr
version = attr: flaskr.__version__
url = https://flask-sqlalchemy.palletsprojects.com/
author = Pallets
author_email = contact@palletsprojects.com
license = BSD-3-Clause
license_file = LICENSE.rst
description = A basic blog app built with Flask-SQLAlchemy.
long_description = file: README.rst
[options]
packages = find:
include_package_data = true
python_requires = >= 3.6
install_requires =
Flask
Flask-SQLAlchemy
[options.extras_require]
test =
pytest
coverage
[tool:pytest]
testpaths = tests
[coverage:run]
branch = True
source = flaskr
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1590591119.0
Flask-SQLAlchemy-2.5.1/examples/flaskr/setup.py 0000644 0001750 0001750 00000000046 00000000000 020272 0 ustar 00david david from setuptools import setup
setup()
././@PaxHeader 0000000 0000000 0000000 00000000033 00000000000 010211 x ustar 00 27 mtime=1616094138.032466
Flask-SQLAlchemy-2.5.1/examples/flaskr/tests/ 0000755 0001750 0001750 00000000000 00000000000 017722 5 ustar 00david david ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1616093781.0
Flask-SQLAlchemy-2.5.1/examples/flaskr/tests/conftest.py 0000644 0001750 0001750 00000003445 00000000000 022127 0 ustar 00david david from datetime import datetime
import pytest
from werkzeug.security import generate_password_hash
from flaskr import create_app
from flaskr import db
from flaskr import init_db
from flaskr.auth.models import User
from flaskr.blog.models import Post
_user1_pass = generate_password_hash("test")
_user2_pass = generate_password_hash("other")
@pytest.fixture
def app():
"""Create and configure a new app instance for each test."""
# create the app with common test config
app = create_app({"TESTING": True, "SQLALCHEMY_DATABASE_URI": "sqlite:///:memory:"})
# create the database and load test data
# set _password to pre-generated hashes, since hashing for each test is slow
with app.app_context():
init_db()
user = User(username="test", _password=_user1_pass)
db.session.add_all(
(
user,
User(username="other", _password=_user2_pass),
Post(
title="test title",
body="test\nbody",
author=user,
created=datetime(2018, 1, 1),
),
)
)
db.session.commit()
yield app
@pytest.fixture
def client(app):
"""A test client for the app."""
return app.test_client()
@pytest.fixture
def runner(app):
"""A test runner for the app's Click commands."""
return app.test_cli_runner()
class AuthActions(object):
def __init__(self, client):
self._client = client
def login(self, username="test", password="test"):
return self._client.post(
"/auth/login", data={"username": username, "password": password}
)
def logout(self):
return self._client.get("/auth/logout")
@pytest.fixture
def auth(client):
return AuthActions(client)
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1590591119.0
Flask-SQLAlchemy-2.5.1/examples/flaskr/tests/test_auth.py 0000644 0001750 0001750 00000004211 00000000000 022272 0 ustar 00david david import pytest
from flask import g
from flask import session
from flaskr.auth.models import User
def test_register(client, app):
# test that viewing the page renders without template errors
assert client.get("/auth/register").status_code == 200
# test that successful registration redirects to the login page
response = client.post("/auth/register", data={"username": "a", "password": "a"})
assert "http://localhost/auth/login" == response.headers["Location"]
# test that the user was inserted into the database
with app.app_context():
assert User.query.filter_by(username="a").first() is not None
def test_user_password(app):
user = User(username="a", password="a")
assert user.password != "a"
assert user.check_password("a")
@pytest.mark.parametrize(
("username", "password", "message"),
(
("", "", b"Username is required."),
("a", "", b"Password is required."),
("test", "test", b"already registered"),
),
)
def test_register_validate_input(client, username, password, message):
response = client.post(
"/auth/register", data={"username": username, "password": password}
)
assert message in response.data
def test_login(client, auth):
# test that viewing the page renders without template errors
assert client.get("/auth/login").status_code == 200
# test that successful login redirects to the index page
response = auth.login()
assert response.headers["Location"] == "http://localhost/"
# login request set the user_id in the session
# check that the user is loaded from the session
with client:
client.get("/")
assert session["user_id"] == 1
assert g.user.username == "test"
@pytest.mark.parametrize(
("username", "password", "message"),
(("a", "test", b"Incorrect username."), ("test", "a", b"Incorrect password.")),
)
def test_login_validate_input(auth, username, password, message):
response = auth.login(username, password)
assert message in response.data
def test_logout(client, auth):
auth.login()
with client:
auth.logout()
assert "user_id" not in session
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1590591119.0
Flask-SQLAlchemy-2.5.1/examples/flaskr/tests/test_blog.py 0000644 0001750 0001750 00000004431 00000000000 022260 0 ustar 00david david import pytest
from flaskr import db
from flaskr.auth.models import User
from flaskr.blog.models import Post
def test_index(client, auth):
response = client.get("/")
assert b"Log In" in response.data
assert b"Register" in response.data
auth.login()
response = client.get("/")
assert b"test title" in response.data
assert b"by test on 2018-01-01" in response.data
assert b"test\nbody" in response.data
assert b'href="/1/update"' in response.data
@pytest.mark.parametrize("path", ("/create", "/1/update", "/1/delete"))
def test_login_required(client, path):
response = client.post(path)
assert response.headers["Location"] == "http://localhost/auth/login"
def test_author_required(app, client, auth):
# change the post author to another user
with app.app_context():
Post.query.get(1).author = User.query.get(2)
db.session.commit()
auth.login()
# current user can't modify other user's post
assert client.post("/1/update").status_code == 403
assert client.post("/1/delete").status_code == 403
# current user doesn't see edit link
assert b'href="/1/update"' not in client.get("/").data
@pytest.mark.parametrize("path", ("/2/update", "/2/delete"))
def test_exists_required(client, auth, path):
auth.login()
assert client.post(path).status_code == 404
def test_create(client, auth, app):
auth.login()
assert client.get("/create").status_code == 200
client.post("/create", data={"title": "created", "body": ""})
with app.app_context():
assert Post.query.count() == 2
def test_update(client, auth, app):
auth.login()
assert client.get("/1/update").status_code == 200
client.post("/1/update", data={"title": "updated", "body": ""})
with app.app_context():
assert Post.query.get(1).title == "updated"
@pytest.mark.parametrize("path", ("/create", "/1/update"))
def test_create_update_validate(client, auth, path):
auth.login()
response = client.post(path, data={"title": "", "body": ""})
assert b"Title is required." in response.data
def test_delete(client, auth, app):
auth.login()
response = client.post("/1/delete")
assert response.headers["Location"] == "http://localhost/"
with app.app_context():
assert Post.query.get(1) is None
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1616093781.0
Flask-SQLAlchemy-2.5.1/examples/flaskr/tests/test_init.py 0000644 0001750 0001750 00000001373 00000000000 022302 0 ustar 00david david from flaskr import create_app
def test_config():
"""Test create_app without passing test config."""
assert not create_app().testing
assert create_app({"TESTING": True}).testing
def test_db_url_environ(monkeypatch):
"""Test DATABASE_URL environment variable."""
monkeypatch.setenv("DATABASE_URL", "sqlite:///environ")
app = create_app()
assert app.config["SQLALCHEMY_DATABASE_URI"] == "sqlite:///environ"
def test_init_db_command(runner, monkeypatch):
class Recorder(object):
called = False
def fake_init_db():
Recorder.called = True
monkeypatch.setattr("flaskr.init_db", fake_init_db)
result = runner.invoke(args=["init-db"])
assert "Initialized" in result.output
assert Recorder.called
././@PaxHeader 0000000 0000000 0000000 00000000033 00000000000 010211 x ustar 00 27 mtime=1616094138.032466
Flask-SQLAlchemy-2.5.1/examples/hello/ 0000755 0001750 0001750 00000000000 00000000000 016401 5 ustar 00david david ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1590591119.0
Flask-SQLAlchemy-2.5.1/examples/hello/hello.cfg 0000644 0001750 0001750 00000000243 00000000000 020164 0 ustar 00david david SQLALCHEMY_DATABASE_URI = 'sqlite:////tmp/test.db'
SQLALCHEMY_ECHO = False
SECRET_KEY = '\xfb\x12\xdf\xa1@i\xd6>V\xc0\xbb\x8fp\x16#Z\x0b\x81\xeb\x16'
DEBUG = True
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1616093781.0
Flask-SQLAlchemy-2.5.1/examples/hello/hello.py 0000644 0001750 0001750 00000003151 00000000000 020056 0 ustar 00david david from datetime import datetime
from flask import Flask, request, flash, url_for, redirect, \
render_template, abort
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
app.config.from_pyfile('hello.cfg')
db = SQLAlchemy(app)
class Todo(db.Model):
__tablename__ = 'todos'
id = db.Column('todo_id', db.Integer, primary_key=True)
title = db.Column(db.String(60))
text = db.Column(db.String)
done = db.Column(db.Boolean)
pub_date = db.Column(db.DateTime)
def __init__(self, title, text):
self.title = title
self.text = text
self.done = False
self.pub_date = datetime.utcnow()
@app.route('/')
def show_all():
return render_template('show_all.html',
todos=Todo.query.order_by(Todo.pub_date.desc()).all()
)
@app.route('/new', methods=['GET', 'POST'])
def new():
if request.method == 'POST':
if not request.form['title']:
flash('Title is required', 'error')
elif not request.form['text']:
flash('Text is required', 'error')
else:
todo = Todo(request.form['title'], request.form['text'])
db.session.add(todo)
db.session.commit()
flash(u'Todo item was successfully created')
return redirect(url_for('show_all'))
return render_template('new.html')
@app.route('/update', methods=['POST'])
def update_done():
for todo in Todo.query.all():
todo.done = ('done.%d' % todo.id) in request.form
flash('Updated status')
db.session.commit()
return redirect(url_for('show_all'))
if __name__ == '__main__':
app.run()
././@PaxHeader 0000000 0000000 0000000 00000000033 00000000000 010211 x ustar 00 27 mtime=1616094138.032466
Flask-SQLAlchemy-2.5.1/examples/hello/templates/ 0000755 0001750 0001750 00000000000 00000000000 020377 5 ustar 00david david ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1590591119.0
Flask-SQLAlchemy-2.5.1/examples/hello/templates/layout.html 0000644 0001750 0001750 00000000552 00000000000 022604 0 ustar 00david david
SQLAlchemy Todo
{%- for category, message in get_flashed_messages(with_categories=true) %}
SQLAlchemy and Flask powered todo application
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1590591119.0
Flask-SQLAlchemy-2.5.1/examples/hello/templates/new.html 0000644 0001750 0001750 00000000644 00000000000 022062 0 ustar 00david david {% extends "layout.html" %}
{% block body %}
New Todo Item
{% endblock %}
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1590591119.0
Flask-SQLAlchemy-2.5.1/examples/hello/templates/show_all.html 0000644 0001750 0001750 00000001300 00000000000 023067 0 ustar 00david david {% extends "layout.html" %}
{% block body %}
All Items
{% endblock %}
././@PaxHeader 0000000 0000000 0000000 00000000033 00000000000 010211 x ustar 00 27 mtime=1616094138.032466
Flask-SQLAlchemy-2.5.1/flask_sqlalchemy/ 0000755 0001750 0001750 00000000000 00000000000 017002 5 ustar 00david david ././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1616094064.0
Flask-SQLAlchemy-2.5.1/flask_sqlalchemy/__init__.py 0000644 0001750 0001750 00000117442 00000000000 021124 0 ustar 00david david # -*- coding: utf-8 -*-
from __future__ import absolute_import
import functools
import os
import sys
import time
import warnings
from math import ceil
from operator import itemgetter
from threading import Lock
import sqlalchemy
from flask import _app_ctx_stack, abort, current_app, request
from flask.signals import Namespace
from sqlalchemy import event, inspect, orm
from sqlalchemy.engine.url import make_url
from sqlalchemy.orm.exc import UnmappedClassError
from sqlalchemy.orm.session import Session as SessionBase
from ._compat import itervalues, string_types, xrange
from .model import DefaultMeta
from .model import Model
from . import utils
try:
from sqlalchemy.orm import declarative_base
from sqlalchemy.orm import DeclarativeMeta
except ImportError:
# SQLAlchemy <= 1.3
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.ext.declarative import DeclarativeMeta
# Scope the session to the current greenlet if greenlet is available,
# otherwise fall back to the current thread.
try:
from greenlet import getcurrent as _ident_func
except ImportError:
try:
from threading import get_ident as _ident_func
except ImportError:
# Python 2.7
from thread import get_ident as _ident_func
__version__ = "2.5.1"
# the best timer function for the platform
if sys.platform == 'win32':
if sys.version_info >= (3, 3):
_timer = time.perf_counter
else:
_timer = time.clock
else:
_timer = time.time
_signals = Namespace()
models_committed = _signals.signal('models-committed')
before_models_committed = _signals.signal('before-models-committed')
def _sa_url_set(url, **kwargs):
try:
url = url.set(**kwargs)
except AttributeError:
# SQLAlchemy <= 1.3
for key, value in kwargs.items():
setattr(url, key, value)
return url
def _sa_url_query_setdefault(url, **kwargs):
query = dict(url.query)
for key, value in kwargs.items():
query.setdefault(key, value)
return _sa_url_set(url, query=query)
def _make_table(db):
def _make_table(*args, **kwargs):
if len(args) > 1 and isinstance(args[1], db.Column):
args = (args[0], db.metadata) + args[1:]
info = kwargs.pop('info', None) or {}
info.setdefault('bind_key', None)
kwargs['info'] = info
return sqlalchemy.Table(*args, **kwargs)
return _make_table
def _set_default_query_class(d, cls):
if 'query_class' not in d:
d['query_class'] = cls
def _wrap_with_default_query_class(fn, cls):
@functools.wraps(fn)
def newfn(*args, **kwargs):
_set_default_query_class(kwargs, cls)
if "backref" in kwargs:
backref = kwargs['backref']
if isinstance(backref, string_types):
backref = (backref, {})
_set_default_query_class(backref[1], cls)
return fn(*args, **kwargs)
return newfn
def _include_sqlalchemy(obj, cls):
for module in sqlalchemy, sqlalchemy.orm:
for key in module.__all__:
if not hasattr(obj, key):
setattr(obj, key, getattr(module, key))
# Note: obj.Table does not attempt to be a SQLAlchemy Table class.
obj.Table = _make_table(obj)
obj.relationship = _wrap_with_default_query_class(obj.relationship, cls)
obj.relation = _wrap_with_default_query_class(obj.relation, cls)
obj.dynamic_loader = _wrap_with_default_query_class(obj.dynamic_loader, cls)
obj.event = event
class _DebugQueryTuple(tuple):
statement = property(itemgetter(0))
parameters = property(itemgetter(1))
start_time = property(itemgetter(2))
end_time = property(itemgetter(3))
context = property(itemgetter(4))
@property
def duration(self):
return self.end_time - self.start_time
def __repr__(self):
return '
{%- for page in pagination.iter_pages() %}
{% if page %}
{% if page != pagination.page %}
{{ page }}
{% else %}
{{ page }}
{% endif %}
{% else %}
…
{% endif %}
{%- endfor %}
{% endmacro %}
"""
last = 0
for num in xrange(1, self.pages + 1):
if num <= left_edge or \
(num > self.page - left_current - 1 and
num < self.page + right_current) or \
num > self.pages - right_edge:
if last + 1 != num:
yield None
yield num
last = num
class BaseQuery(orm.Query):
"""SQLAlchemy :class:`~sqlalchemy.orm.query.Query` subclass with convenience methods for querying in a web application.
This is the default :attr:`~Model.query` object used for models, and exposed as :attr:`~SQLAlchemy.Query`.
Override the query class for an individual model by subclassing this and setting :attr:`~Model.query_class`.
"""
def get_or_404(self, ident, description=None):
"""Like :meth:`get` but aborts with 404 if not found instead of returning ``None``."""
rv = self.get(ident)
if rv is None:
abort(404, description=description)
return rv
def first_or_404(self, description=None):
"""Like :meth:`first` but aborts with 404 if not found instead of returning ``None``."""
rv = self.first()
if rv is None:
abort(404, description=description)
return rv
def paginate(self, page=None, per_page=None, error_out=True, max_per_page=None):
"""Returns ``per_page`` items from page ``page``.
If ``page`` or ``per_page`` are ``None``, they will be retrieved from
the request query. If ``max_per_page`` is specified, ``per_page`` will
be limited to that value. If there is no request or they aren't in the
query, they default to 1 and 20 respectively.
When ``error_out`` is ``True`` (default), the following rules will
cause a 404 response:
* No items are found and ``page`` is not 1.
* ``page`` is less than 1, or ``per_page`` is negative.
* ``page`` or ``per_page`` are not ints.
When ``error_out`` is ``False``, ``page`` and ``per_page`` default to
1 and 20 respectively.
Returns a :class:`Pagination` object.
"""
if request:
if page is None:
try:
page = int(request.args.get('page', 1))
except (TypeError, ValueError):
if error_out:
abort(404)
page = 1
if per_page is None:
try:
per_page = int(request.args.get('per_page', 20))
except (TypeError, ValueError):
if error_out:
abort(404)
per_page = 20
else:
if page is None:
page = 1
if per_page is None:
per_page = 20
if max_per_page is not None:
per_page = min(per_page, max_per_page)
if page < 1:
if error_out:
abort(404)
else:
page = 1
if per_page < 0:
if error_out:
abort(404)
else:
per_page = 20
items = self.limit(per_page).offset((page - 1) * per_page).all()
if not items and page != 1 and error_out:
abort(404)
total = self.order_by(None).count()
return Pagination(self, page, per_page, total, items)
class _QueryProperty(object):
def __init__(self, sa):
self.sa = sa
def __get__(self, obj, type):
try:
mapper = orm.class_mapper(type)
if mapper:
return type.query_class(mapper, session=self.sa.session())
except UnmappedClassError:
return None
def _record_queries(app):
if app.debug:
return True
rq = app.config['SQLALCHEMY_RECORD_QUERIES']
if rq is not None:
return rq
return bool(app.config.get('TESTING'))
class _EngineConnector(object):
def __init__(self, sa, app, bind=None):
self._sa = sa
self._app = app
self._engine = None
self._connected_for = None
self._bind = bind
self._lock = Lock()
def get_uri(self):
if self._bind is None:
return self._app.config['SQLALCHEMY_DATABASE_URI']
binds = self._app.config.get('SQLALCHEMY_BINDS') or ()
assert self._bind in binds, \
'Bind %r is not specified. Set it in the SQLALCHEMY_BINDS ' \
'configuration variable' % self._bind
return binds[self._bind]
def get_engine(self):
with self._lock:
uri = self.get_uri()
echo = self._app.config['SQLALCHEMY_ECHO']
if (uri, echo) == self._connected_for:
return self._engine
sa_url = make_url(uri)
sa_url, options = self.get_options(sa_url, echo)
self._engine = rv = self._sa.create_engine(sa_url, options)
if _record_queries(self._app):
_EngineDebuggingSignalEvents(self._engine,
self._app.import_name).register()
self._connected_for = (uri, echo)
return rv
def get_options(self, sa_url, echo):
options = {}
options = self._sa.apply_pool_defaults(self._app, options)
sa_url, options = self._sa.apply_driver_hacks(self._app, sa_url, options)
if echo:
options['echo'] = echo
# Give the config options set by a developer explicitly priority
# over decisions FSA makes.
options.update(self._app.config['SQLALCHEMY_ENGINE_OPTIONS'])
# Give options set in SQLAlchemy.__init__() ultimate priority
options.update(self._sa._engine_options)
return sa_url, options
def get_state(app):
"""Gets the state for the application"""
assert 'sqlalchemy' in app.extensions, \
'The sqlalchemy extension was not registered to the current ' \
'application. Please make sure to call init_app() first.'
return app.extensions['sqlalchemy']
class _SQLAlchemyState(object):
"""Remembers configuration for the (db, app) tuple."""
def __init__(self, db):
self.db = db
self.connectors = {}
class SQLAlchemy(object):
"""This class is used to control the SQLAlchemy integration to one
or more Flask applications. Depending on how you initialize the
object it is usable right away or will attach as needed to a
Flask application.
There are two usage modes which work very similarly. One is binding
the instance to a very specific Flask application::
app = Flask(__name__)
db = SQLAlchemy(app)
The second possibility is to create the object once and configure the
application later to support it::
db = SQLAlchemy()
def create_app():
app = Flask(__name__)
db.init_app(app)
return app
The difference between the two is that in the first case methods like
:meth:`create_all` and :meth:`drop_all` will work all the time but in
the second case a :meth:`flask.Flask.app_context` has to exist.
By default Flask-SQLAlchemy will apply some backend-specific settings
to improve your experience with them.
As of SQLAlchemy 0.6 SQLAlchemy
will probe the library for native unicode support. If it detects
unicode it will let the library handle that, otherwise do that itself.
Sometimes this detection can fail in which case you might want to set
``use_native_unicode`` (or the ``SQLALCHEMY_NATIVE_UNICODE`` configuration
key) to ``False``. Note that the configuration key overrides the
value you pass to the constructor. Direct support for ``use_native_unicode``
and SQLALCHEMY_NATIVE_UNICODE are deprecated as of v2.4 and will be removed
in v3.0. ``engine_options`` and ``SQLALCHEMY_ENGINE_OPTIONS`` may be used
instead.
This class also provides access to all the SQLAlchemy functions and classes
from the :mod:`sqlalchemy` and :mod:`sqlalchemy.orm` modules. So you can
declare models like this::
class User(db.Model):
username = db.Column(db.String(80), unique=True)
pw_hash = db.Column(db.String(80))
You can still use :mod:`sqlalchemy` and :mod:`sqlalchemy.orm` directly, but
note that Flask-SQLAlchemy customizations are available only through an
instance of this :class:`SQLAlchemy` class. Query classes default to
:class:`BaseQuery` for `db.Query`, `db.Model.query_class`, and the default
query_class for `db.relationship` and `db.backref`. If you use these
interfaces through :mod:`sqlalchemy` and :mod:`sqlalchemy.orm` directly,
the default query class will be that of :mod:`sqlalchemy`.
.. admonition:: Check types carefully
Don't perform type or `isinstance` checks against `db.Table`, which
emulates `Table` behavior but is not a class. `db.Table` exposes the
`Table` interface, but is a function which allows omission of metadata.
The ``session_options`` parameter, if provided, is a dict of parameters
to be passed to the session constructor. See :class:`~sqlalchemy.orm.session.Session`
for the standard options.
The ``engine_options`` parameter, if provided, is a dict of parameters
to be passed to create engine. See :func:`~sqlalchemy.create_engine`
for the standard options. The values given here will be merged with and
override anything set in the ``'SQLALCHEMY_ENGINE_OPTIONS'`` config
variable or othewise set by this library.
.. versionadded:: 0.10
The `session_options` parameter was added.
.. versionadded:: 0.16
`scopefunc` is now accepted on `session_options`. It allows specifying
a custom function which will define the SQLAlchemy session's scoping.
.. versionadded:: 2.1
The `metadata` parameter was added. This allows for setting custom
naming conventions among other, non-trivial things.
The `query_class` parameter was added, to allow customisation
of the query class, in place of the default of :class:`BaseQuery`.
The `model_class` parameter was added, which allows a custom model
class to be used in place of :class:`Model`.
.. versionchanged:: 2.1
Utilise the same query class across `session`, `Model.query` and `Query`.
.. versionadded:: 2.4
The `engine_options` parameter was added.
.. versionchanged:: 2.4
The `use_native_unicode` parameter was deprecated.
.. versionchanged:: 2.4.3
``COMMIT_ON_TEARDOWN`` is deprecated and will be removed in
version 3.1. Call ``db.session.commit()`` directly instead.
"""
#: Default query class used by :attr:`Model.query` and other queries.
#: Customize this by passing ``query_class`` to :func:`SQLAlchemy`.
#: Defaults to :class:`BaseQuery`.
Query = None
def __init__(self, app=None, use_native_unicode=True, session_options=None,
metadata=None, query_class=BaseQuery, model_class=Model,
engine_options=None):
self.use_native_unicode = use_native_unicode
self.Query = query_class
self.session = self.create_scoped_session(session_options)
self.Model = self.make_declarative_base(model_class, metadata)
self._engine_lock = Lock()
self.app = app
self._engine_options = engine_options or {}
_include_sqlalchemy(self, query_class)
if app is not None:
self.init_app(app)
@property
def metadata(self):
"""The metadata associated with ``db.Model``."""
return self.Model.metadata
def create_scoped_session(self, options=None):
"""Create a :class:`~sqlalchemy.orm.scoping.scoped_session`
on the factory from :meth:`create_session`.
An extra key ``'scopefunc'`` can be set on the ``options`` dict to
specify a custom scope function. If it's not provided, Flask's app
context stack identity is used. This will ensure that sessions are
created and removed with the request/response cycle, and should be fine
in most cases.
:param options: dict of keyword arguments passed to session class in
``create_session``
"""
if options is None:
options = {}
scopefunc = options.pop('scopefunc', _ident_func)
options.setdefault('query_cls', self.Query)
return orm.scoped_session(
self.create_session(options), scopefunc=scopefunc
)
def create_session(self, options):
"""Create the session factory used by :meth:`create_scoped_session`.
The factory **must** return an object that SQLAlchemy recognizes as a session,
or registering session events may raise an exception.
Valid factories include a :class:`~sqlalchemy.orm.session.Session`
class or a :class:`~sqlalchemy.orm.session.sessionmaker`.
The default implementation creates a ``sessionmaker`` for :class:`SignallingSession`.
:param options: dict of keyword arguments passed to session class
"""
return orm.sessionmaker(class_=SignallingSession, db=self, **options)
def make_declarative_base(self, model, metadata=None):
"""Creates the declarative base that all models will inherit from.
:param model: base model class (or a tuple of base classes) to pass
to :func:`~sqlalchemy.ext.declarative.declarative_base`. Or a class
returned from ``declarative_base``, in which case a new base class
is not created.
:param metadata: :class:`~sqlalchemy.MetaData` instance to use, or
none to use SQLAlchemy's default.
.. versionchanged 2.3.0::
``model`` can be an existing declarative base in order to support
complex customization such as changing the metaclass.
"""
if not isinstance(model, DeclarativeMeta):
model = declarative_base(
cls=model,
name='Model',
metadata=metadata,
metaclass=DefaultMeta
)
# if user passed in a declarative base and a metaclass for some reason,
# make sure the base uses the metaclass
if metadata is not None and model.metadata is not metadata:
model.metadata = metadata
if not getattr(model, 'query_class', None):
model.query_class = self.Query
model.query = _QueryProperty(self)
return model
def init_app(self, app):
"""This callback can be used to initialize an application for the
use with this database setup. Never use a database in the context
of an application not initialized that way or connections will
leak.
"""
if (
'SQLALCHEMY_DATABASE_URI' not in app.config and
'SQLALCHEMY_BINDS' not in app.config
):
warnings.warn(
'Neither SQLALCHEMY_DATABASE_URI nor SQLALCHEMY_BINDS is set. '
'Defaulting SQLALCHEMY_DATABASE_URI to "sqlite:///:memory:".'
)
app.config.setdefault('SQLALCHEMY_DATABASE_URI', 'sqlite:///:memory:')
app.config.setdefault('SQLALCHEMY_BINDS', None)
app.config.setdefault('SQLALCHEMY_NATIVE_UNICODE', None)
app.config.setdefault('SQLALCHEMY_ECHO', False)
app.config.setdefault('SQLALCHEMY_RECORD_QUERIES', None)
app.config.setdefault('SQLALCHEMY_POOL_SIZE', None)
app.config.setdefault('SQLALCHEMY_POOL_TIMEOUT', None)
app.config.setdefault('SQLALCHEMY_POOL_RECYCLE', None)
app.config.setdefault('SQLALCHEMY_MAX_OVERFLOW', None)
app.config.setdefault('SQLALCHEMY_COMMIT_ON_TEARDOWN', False)
track_modifications = app.config.setdefault(
'SQLALCHEMY_TRACK_MODIFICATIONS', None
)
app.config.setdefault('SQLALCHEMY_ENGINE_OPTIONS', {})
if track_modifications is None:
warnings.warn(FSADeprecationWarning(
'SQLALCHEMY_TRACK_MODIFICATIONS adds significant overhead and '
'will be disabled by default in the future. Set it to True '
'or False to suppress this warning.'
))
# Deprecation warnings for config keys that should be replaced by SQLALCHEMY_ENGINE_OPTIONS.
utils.engine_config_warning(app.config, '3.0', 'SQLALCHEMY_POOL_SIZE', 'pool_size')
utils.engine_config_warning(app.config, '3.0', 'SQLALCHEMY_POOL_TIMEOUT', 'pool_timeout')
utils.engine_config_warning(app.config, '3.0', 'SQLALCHEMY_POOL_RECYCLE', 'pool_recycle')
utils.engine_config_warning(app.config, '3.0', 'SQLALCHEMY_MAX_OVERFLOW', 'max_overflow')
app.extensions['sqlalchemy'] = _SQLAlchemyState(self)
@app.teardown_appcontext
def shutdown_session(response_or_exc):
if app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN']:
warnings.warn(
"'COMMIT_ON_TEARDOWN' is deprecated and will be"
" removed in version 3.1. Call"
" 'db.session.commit()'` directly instead.",
DeprecationWarning,
)
if response_or_exc is None:
self.session.commit()
self.session.remove()
return response_or_exc
def apply_pool_defaults(self, app, options):
"""
.. versionchanged:: 2.5
Returns the ``options`` dict, for consistency with
:meth:`apply_driver_hacks`.
"""
def _setdefault(optionkey, configkey):
value = app.config[configkey]
if value is not None:
options[optionkey] = value
_setdefault('pool_size', 'SQLALCHEMY_POOL_SIZE')
_setdefault('pool_timeout', 'SQLALCHEMY_POOL_TIMEOUT')
_setdefault('pool_recycle', 'SQLALCHEMY_POOL_RECYCLE')
_setdefault('max_overflow', 'SQLALCHEMY_MAX_OVERFLOW')
return options
def apply_driver_hacks(self, app, sa_url, options):
"""This method is called before engine creation and used to inject
driver specific hacks into the options. The `options` parameter is
a dictionary of keyword arguments that will then be used to call
the :func:`sqlalchemy.create_engine` function.
The default implementation provides some saner defaults for things
like pool sizes for MySQL and sqlite. Also it injects the setting of
`SQLALCHEMY_NATIVE_UNICODE`.
.. versionchanged:: 2.5
Returns ``(sa_url, options)``. SQLAlchemy 1.4 made the URL
immutable, so any changes to it must now be passed back up
to the original caller.
"""
if sa_url.drivername.startswith('mysql'):
sa_url = _sa_url_query_setdefault(sa_url, charset="utf8")
if sa_url.drivername != 'mysql+gaerdbms':
options.setdefault('pool_size', 10)
options.setdefault('pool_recycle', 7200)
elif sa_url.drivername == 'sqlite':
pool_size = options.get('pool_size')
detected_in_memory = False
if sa_url.database in (None, '', ':memory:'):
detected_in_memory = True
from sqlalchemy.pool import StaticPool
options['poolclass'] = StaticPool
if 'connect_args' not in options:
options['connect_args'] = {}
options['connect_args']['check_same_thread'] = False
# we go to memory and the pool size was explicitly set
# to 0 which is fail. Let the user know that
if pool_size == 0:
raise RuntimeError('SQLite in memory database with an '
'empty queue not possible due to data '
'loss.')
# if pool size is None or explicitly set to 0 we assume the
# user did not want a queue for this sqlite connection and
# hook in the null pool.
elif not pool_size:
from sqlalchemy.pool import NullPool
options['poolclass'] = NullPool
# if it's not an in memory database we make the path absolute.
if not detected_in_memory:
sa_url = _sa_url_set(
sa_url, database=os.path.join(app.root_path, sa_url.database)
)
unu = app.config['SQLALCHEMY_NATIVE_UNICODE']
if unu is None:
unu = self.use_native_unicode
if not unu:
options['use_native_unicode'] = False
if app.config['SQLALCHEMY_NATIVE_UNICODE'] is not None:
warnings.warn(
"The 'SQLALCHEMY_NATIVE_UNICODE' config option is deprecated and will be removed in"
" v3.0. Use 'SQLALCHEMY_ENGINE_OPTIONS' instead.",
DeprecationWarning
)
if not self.use_native_unicode:
warnings.warn(
"'use_native_unicode' is deprecated and will be removed in v3.0."
" Use the 'engine_options' parameter instead.",
DeprecationWarning
)
return sa_url, options
@property
def engine(self):
"""Gives access to the engine. If the database configuration is bound
to a specific application (initialized with an application) this will
always return a database connection. If however the current application
is used this might raise a :exc:`RuntimeError` if no application is
active at the moment.
"""
return self.get_engine()
def make_connector(self, app=None, bind=None):
"""Creates the connector for a given state and bind."""
return _EngineConnector(self, self.get_app(app), bind)
def get_engine(self, app=None, bind=None):
"""Returns a specific engine."""
app = self.get_app(app)
state = get_state(app)
with self._engine_lock:
connector = state.connectors.get(bind)
if connector is None:
connector = self.make_connector(app, bind)
state.connectors[bind] = connector
return connector.get_engine()
def create_engine(self, sa_url, engine_opts):
"""
Override this method to have final say over how the SQLAlchemy engine
is created.
In most cases, you will want to use ``'SQLALCHEMY_ENGINE_OPTIONS'``
config variable or set ``engine_options`` for :func:`SQLAlchemy`.
"""
return sqlalchemy.create_engine(sa_url, **engine_opts)
def get_app(self, reference_app=None):
"""Helper method that implements the logic to look up an
application."""
if reference_app is not None:
return reference_app
if current_app:
return current_app._get_current_object()
if self.app is not None:
return self.app
raise RuntimeError(
'No application found. Either work inside a view function or push'
' an application context. See'
' http://flask-sqlalchemy.pocoo.org/contexts/.'
)
def get_tables_for_bind(self, bind=None):
"""Returns a list of all tables relevant for a bind."""
result = []
for table in itervalues(self.Model.metadata.tables):
if table.info.get('bind_key') == bind:
result.append(table)
return result
def get_binds(self, app=None):
"""Returns a dictionary with a table->engine mapping.
This is suitable for use of sessionmaker(binds=db.get_binds(app)).
"""
app = self.get_app(app)
binds = [None] + list(app.config.get('SQLALCHEMY_BINDS') or ())
retval = {}
for bind in binds:
engine = self.get_engine(app, bind)
tables = self.get_tables_for_bind(bind)
retval.update(dict((table, engine) for table in tables))
return retval
def _execute_for_all_tables(self, app, bind, operation, skip_tables=False):
app = self.get_app(app)
if bind == '__all__':
binds = [None] + list(app.config.get('SQLALCHEMY_BINDS') or ())
elif isinstance(bind, string_types) or bind is None:
binds = [bind]
else:
binds = bind
for bind in binds:
extra = {}
if not skip_tables:
tables = self.get_tables_for_bind(bind)
extra['tables'] = tables
op = getattr(self.Model.metadata, operation)
op(bind=self.get_engine(app, bind), **extra)
def create_all(self, bind='__all__', app=None):
"""Creates all tables.
.. versionchanged:: 0.12
Parameters were added
"""
self._execute_for_all_tables(app, bind, 'create_all')
def drop_all(self, bind='__all__', app=None):
"""Drops all tables.
.. versionchanged:: 0.12
Parameters were added
"""
self._execute_for_all_tables(app, bind, 'drop_all')
def reflect(self, bind='__all__', app=None):
"""Reflects tables from the database.
.. versionchanged:: 0.12
Parameters were added
"""
self._execute_for_all_tables(app, bind, 'reflect', skip_tables=True)
def __repr__(self):
return '<%s engine=%r>' % (
self.__class__.__name__,
self.engine.url if self.app or current_app else None
)
class _BoundDeclarativeMeta(DefaultMeta):
def __init__(cls, name, bases, d):
warnings.warn(FSADeprecationWarning(
'"_BoundDeclarativeMeta" has been renamed to "DefaultMeta". The'
' old name will be removed in 3.0.'
), stacklevel=3)
super(_BoundDeclarativeMeta, cls).__init__(name, bases, d)
class FSADeprecationWarning(DeprecationWarning):
pass
warnings.simplefilter('always', FSADeprecationWarning)
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1616093781.0
Flask-SQLAlchemy-2.5.1/flask_sqlalchemy/_compat.py 0000644 0001750 0001750 00000001465 00000000000 021004 0 ustar 00david david import sys
PY2 = sys.version_info[0] == 2
if PY2:
def iteritems(d):
return d.iteritems()
def itervalues(d):
return d.itervalues()
xrange = xrange
string_types = (unicode, bytes)
def to_str(x, charset='utf8', errors='strict'):
if x is None or isinstance(x, str):
return x
if isinstance(x, unicode):
return x.encode(charset, errors)
return str(x)
else:
def iteritems(d):
return iter(d.items())
def itervalues(d):
return iter(d.values())
xrange = range
string_types = (str,)
def to_str(x, charset='utf8', errors='strict'):
if x is None or isinstance(x, str):
return x
if isinstance(x, bytes):
return x.decode(charset, errors)
return str(x)
././@PaxHeader 0000000 0000000 0000000 00000000026 00000000000 010213 x ustar 00 22 mtime=1616093781.0
Flask-SQLAlchemy-2.5.1/flask_sqlalchemy/model.py 0000644 0001750 0001750 00000011574 00000000000 020464 0 ustar 00david david import re
import sqlalchemy as sa
from sqlalchemy import inspect
from sqlalchemy.ext.declarative import DeclarativeMeta, declared_attr
from sqlalchemy.schema import _get_table_key
from ._compat import to_str
def should_set_tablename(cls):
"""Determine whether ``__tablename__`` should be automatically generated
for a model.
* If no class in the MRO sets a name, one should be generated.
* If a declared attr is found, it should be used instead.
* If a name is found, it should be used if the class is a mixin, otherwise
one should be generated.
* Abstract models should not have one generated.
Later, :meth:`._BoundDeclarativeMeta.__table_cls__` will determine if the
model looks like single or joined-table inheritance. If no primary key is
found, the name will be unset.
"""
if (
cls.__dict__.get('__abstract__', False)
or not any(isinstance(b, DeclarativeMeta) for b in cls.__mro__[1:])
):
return False
for base in cls.__mro__:
if '__tablename__' not in base.__dict__:
continue
if isinstance(base.__dict__['__tablename__'], declared_attr):
return False
return not (
base is cls
or base.__dict__.get('__abstract__', False)
or not isinstance(base, DeclarativeMeta)
)
return True
camelcase_re = re.compile(r'([A-Z]+)(?=[a-z0-9])')
def camel_to_snake_case(name):
def _join(match):
word = match.group()
if len(word) > 1:
return ('_%s_%s' % (word[:-1], word[-1])).lower()
return '_' + word.lower()
return camelcase_re.sub(_join, name).lstrip('_')
class NameMetaMixin(type):
def __init__(cls, name, bases, d):
if should_set_tablename(cls):
cls.__tablename__ = camel_to_snake_case(cls.__name__)
super(NameMetaMixin, cls).__init__(name, bases, d)
# __table_cls__ has run at this point
# if no table was created, use the parent table
if (
'__tablename__' not in cls.__dict__
and '__table__' in cls.__dict__
and cls.__dict__['__table__'] is None
):
del cls.__table__
def __table_cls__(cls, *args, **kwargs):
"""This is called by SQLAlchemy during mapper setup. It determines the
final table object that the model will use.
If no primary key is found, that indicates single-table inheritance,
so no table will be created and ``__tablename__`` will be unset.
"""
# check if a table with this name already exists
# allows reflected tables to be applied to model by name
key = _get_table_key(args[0], kwargs.get('schema'))
if key in cls.metadata.tables:
return sa.Table(*args, **kwargs)
# if a primary key or constraint is found, create a table for
# joined-table inheritance
for arg in args:
if (
(isinstance(arg, sa.Column) and arg.primary_key)
or isinstance(arg, sa.PrimaryKeyConstraint)
):
return sa.Table(*args, **kwargs)
# if no base classes define a table, return one
# ensures the correct error shows up when missing a primary key
for base in cls.__mro__[1:-1]:
if '__table__' in base.__dict__:
break
else:
return sa.Table(*args, **kwargs)
# single-table inheritance, use the parent tablename
if '__tablename__' in cls.__dict__:
del cls.__tablename__
class BindMetaMixin(type):
def __init__(cls, name, bases, d):
bind_key = (
d.pop('__bind_key__', None)
or getattr(cls, '__bind_key__', None)
)
super(BindMetaMixin, cls).__init__(name, bases, d)
if bind_key is not None and getattr(cls, '__table__', None) is not None:
cls.__table__.info['bind_key'] = bind_key
class DefaultMeta(NameMetaMixin, BindMetaMixin, DeclarativeMeta):
pass
class Model(object):
"""Base class for SQLAlchemy declarative base model.
To define models, subclass :attr:`db.Model