def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
bootstrap.init_app(app)
mail.init_app(app)
moment.init_app(app)
db.init_app(app)
login_manager.init_app(app)
pagedown.init_app(app)
whoosh_index(app, Post)
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask.ext.sslify import SSLify
sslify = SSLify(app)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix='/auth')
from .api_1_0 import api as api_1_0_blueprint
app.register_blueprint(api_1_0_blueprint, url_prefix='/api/v1.0')
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
bootstrap.init_app(app)
mail.init_app(app)
moment.init_app(app)
db.init_app(app)
login_manager.init_app(app)
pagedown.init_app(app)
whoosh_index(app, Post)
if not app.debug and not app.testing and not app.config['SSL_DISABLE']:
from flask.ext.sslify import SSLify
sslify = SSLify(app)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix='/auth')
from .api_1_0 import api as api_1_0_blueprint
app.register_blueprint(api_1_0_blueprint, url_prefix='/api/v1.0')
return app
def create_app(config_name): # APP factory function
app = Flask(__name__)
app.config.from_object(
config[config_name]
) # config是在config.py中最后定义的dict; from_object()方法将配置导入app/程序
config[config_name].init_app(app) # config[config_name]是'配置类'
bootstrap.init_app(app)
mail.init_app(app) # 邮件的相关信息(邮箱/密码)由此传递到mail
moment.init_app(app)
db.init_app(app)
login_manager.init_app(app)
pagedown.init_app(app)
# [IMP] (1)初始化whooshalchemy;
# (2)通过whoosh_index函数初始化Post模型的全文搜索索引
import flask_whooshalchemyplus as whooshalchemyplus
from app.models import Post # [IMP] Post模型需要db(db在本脚本上方创建,所以import Post时需谨慎关注其模组依赖)
whooshalchemyplus.init_app(app)
whooshalchemyplus.whoosh_index(
app, Post
) # get the whoosh index for this model, creating one if it doesn't exist
from .main import main as main_blueprint # relative import: 从main文件夹中的__init__.py中导入'main' as 'main_blueprint'
app.register_blueprint(
main_blueprint
) # 蓝本在工厂函数create_app()中注册到程序/app上 (蓝本中包括: 路由 & 自定义的错误页面)
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix='/auth')
from .api_1_0 import api as api_1_0_blueprint
app.register_blueprint(api_1_0_blueprint, url_prefix='/api/v1.0')
return app
def create_app(configuration=DevelopmentConfig):
app = Flask(__name__)
app.config.from_object(configuration)
db.init_app(app)
wa.whoosh_index(app, Category)
wa.whoosh_index(app, Service)
mail.init_app(app)
login_manager.init_app(app)
login_manager.login_view = 'auth.index'
app.register_blueprint(auth)
app.register_blueprint(home)
migrate.init_app(app, db)
return app
def create_app(object_name):
app = Flask(__name__)
wa.whoosh_index(app,FUND_ESSENTIAL)
wa.whoosh_index(app, FoFModel)
app.config.from_object(object_name)
db.init_app(app)
login_manager.init_app(app)
admin.init_app(app)
celery.init_app(app)
babel.init_app(app)
mail.init_app(app)
SocketIo.init_app(app,message_queue=app.config['SOCKETIO_MESSAGE_QUEUE'],async_mode='gevent')
app.register_blueprint(f_app.f_app_blueprint)
app.register_blueprint(auth.auth_blueprint)
app.register_blueprint(manager_task.task_blueprint,url_prefix='/task')
return app
followers.c.follower_id == self.id).order_by(
Post.timestamp.desc())
def __repr__(self):
return '<User %r>' % (self.nickname)
import sys
if sys.version_info >= (3, 0):
enable_search = False
else:
enable_search = True
import flask_whooshalchemyplus as whooshalchemy
class Post(db.Model):
__searchable__ = ['body'] # 索引 blog 的 body 字段。
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.String(140))
timestamp = db.Column(db.DateTime)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
language = db.Column(db.String(5))
def __repr__(self):
return '<Post %r>' % (self.body)
if enable_search:
whooshalchemy.whoosh_index(app, Post) # whoosh_index 函数，为这个模型初始化了全文搜索索引。
def reply_comment(self, user, time, body):
new_reply = Comment(user_id=user.id, time_comment=time, body=body)
new_reply.save()
self.replies.append(new_reply)
self.save()
return self
def __repr__(self):
return '<Comment %s>' % self.id
# -------------------------------------------Searchble_setting---------------------------
whooshalchemy.init_app(app)
with app.app_context():
whooshalchemy.whoosh_index(app, User)
whooshalchemy.whoosh_index(app, Post)
whooshalchemy.whoosh_index(app, Label)
# --------------------------------------------Test----------------------------------------
if __name__ == '__main__':
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker, relationship, backref, scoped_session
engine = create_engine(app.config['SQLALCHEMY_DATABASE_URI'],
pool_size=120,
pool_recycle=20)
session_factory = sessionmaker(bind=engine)
DBSession = scoped_session(session_factory)
if app.config['DROP_ALL']:
#!/usr/bin/python
# -*- coding: utf-8 -*-
import os
from app import create_app,db
from app.models import Post,User,Role,Answer,Comment
from flask.ext.script import Manager,Shell,Server
from flask.ext.migrate import Migrate,MigrateCommand
import flask_whooshalchemyplus as whoolshalchemy
app = create_app(os.getenv('FLASKY_CONFIG') or 'default')
manager = Manager(app)
migrate = Migrate(app,db)
whoolshalchemy.whoosh_index(app,Post)
whoolshalchemy.whoosh_index(app,User)
whoolshalchemy.whoosh_index(app,Answer)
def make_shell_context():
return dict(app=app,db=db,Post=Post,User=User,Role=Role,Answer=Answer,Comment=Comment)
manager.add_command("shell",Shell(make_context=make_shell_context))
manager.add_command('db',MigrateCommand)
manager.add_command('runserver',Server(threaded=True))
@manager.command
def test():
'''测试开始'''
import unittest
#!/usr/bin/python
# -*- coding: utf-8 -*-
import os
from app import create_app, db
from app.models import Post, User, Role, Answer, Comment
from flask.ext.script import Manager, Shell, Server
from flask.ext.migrate import Migrate, MigrateCommand
import flask_whooshalchemyplus as whoolshalchemy
app = create_app(os.getenv('FLASKY_CONFIG') or 'default')
manager = Manager(app)
migrate = Migrate(app, db)
whoolshalchemy.whoosh_index(app, Post)
whoolshalchemy.whoosh_index(app, User)
whoolshalchemy.whoosh_index(app, Answer)
def make_shell_context():
return dict(app=app,
db=db,
Post=Post,
User=User,
Role=Role,
Answer=Answer,
Comment=Comment)
manager.add_command("shell", Shell(make_context=make_shell_context))
manager.add_command('db', MigrateCommand)
app.config.from_object(ProdConfig)
else:
app.config.from_object(LocalDevConfig)
# Search index folder
app.config['WHOOSH_BASE'] = os.path.join(BASE_DIR, 'whoosh_index')
db = SQLAlchemy(app)
from models import Actor, Character, ComicSeries, Event, Movie, TvShow
models_list = [Actor, Character, ComicSeries, Event, Movie, TvShow]
# Creates tables
db.create_all()
for model in models_list:
whooshalchemy.whoosh_index(app, model)
# Create the Flask-Restless API manager.
manager = APIManager(app, flask_sqlalchemy_db=db)
# Flask-Restless config
kwargs = {
'methods': frozenset(['GET', 'POST', 'PATCH']),
'allow_functions': True,
'results_per_page': 6
}
# Create API endpoints, which will be available at /api/<tablename> by
# default. Allowed HTTP methods can be specified as well.
for model in models_list:
manager.create_api(model, **kwargs)
pages = db.Column(db.Integer, unique=False, nullable=False)
price = db.Column(db.Float, unique=False, nullable=False)
def __repr__(self):
return f"Book('{self.author_name}', '{self.title}', '{self.press}', '{self.year}', '{self.pages}', '{self.price}')"
def __init__(self, author_name, title, press, year, pages, price):
self.author_name = author_name
self.title = title
self.press = press
self.year = year
self.pages = pages
self.price = price
wa.whoosh_index(app, Book)
@app.route("/")
@app.route("/books")
def books():
data = Book.query.all()
return render_template('books.html', Book=data)
@app.route('/search')
def search():
data = Book.query.whoosh_search(request.args.get('query')).all()
return render_template('books.html', Book=data)
#提问者提问的问题
class Question(db.Model):
__tablename__ = 'questions'
__searchable__ = ['title']
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(64))
body = db.Column(db.Text)
body_html = db.Column(db.Text)
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
author_id = db.Column(db.Integer, db.ForeignKey('users.id'))
answers = db.relationship('Answer', backref='question', lazy='dynamic')
@staticmethod
def on_changed_body(target, value, oldvalue,
initiator): #在服务器使Markdown文本转换为html文本
allowed_tags = [
'a', 'abbr', 'acronym', 'b', 'blockquote', 'code', 'em', 'i', 'li',
'ol', 'pre', 'strong', 'ul', 'h1', 'h2', 'h3', 'p'
]
target.body_html = bleach.linkify(
bleach.clean(markdown(value, output_format='html'),
tags=allowed_tags,
strip=True))
db.event.listen(Question.body, 'set', Question.on_changed_body)
myapp = create_app('default' or os.getenv('FLASK_CONFIG'))
if enable_search:
whooshalchemyplus.whoosh_index(myapp, Question)
id = db.Column(db.INTEGER, primary_key=True)
company = db.Column(db.TEXT)
url = db.Column(db.TEXT)
tel = db.Column(db.TEXT)
fax = db.Column(db.TEXT)
mail = db.Column(db.TEXT)
contacts = db.Column(db.TEXT)
address = db.Column(db.TEXT)
remarks = db.Column(db.TEXT)
def __repr__(self):
return '<Sheet_Form {}'.format(self.company)
flask_whooshalchemyplus.whoosh_index(app, Sheet_Form)
'''
方法：按id获取数据
'''
def select_id(id):
if id is not None:
try:
info = Sheet_Form.query.filter_by(id=id).first()
return info
except IOError:
return None
return None
# Job数据模型
class Job(db.Model):
__tablename__ = 'jobs'
__searchable__ = ['job_name', 'company_name', 'job_detail', 'requirement', 'industry']
id = db.Column(db.Integer, primary_key=True)
company_id = db.Column(db.Integer, db.ForeignKey('companies.id'))
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
company_name = db.Column(db.String(20), index=True)
job_name = db.Column(db.String(20), index=True)
email = db.Column(db.String(40), index=True)
industry = db.Column(db.String(20), index=True)
salary = db.Column(db.String(10), index=True) # 用string 还是 integer 存疑
welfare = db.Column(db.Text, index=True)
work_place = db.Column(db.String(20), index=True)
requirement = db.Column(db.Text, index=True)
job_detail = db.Column(db.Text, index=True)
PS = db.Column(db.Text, index=True)
avatar = db.Column(db.String(20), index=True, )
timestamp = db.Column(db.DateTime, index=True) #, default=datetime.utcnow())
def __repr__(self):
return '<Job %s from %s>' % (self.job_name, self.company_name)
whooshalchemyplus.whoosh_index(app, Job)
class BlogingPost(db.Model):
__tablename__ = 'blogingpost2'
__searchable__ = ['title', 'content'] # these fields will be indexed by whoosh
#__analyzer__ = SimpleAnalyzer() # configure analyzer; defaults to
__analyzer__ = ChineseAnalyzer() # StemmingAnalyzer if not specified
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100)) # Indexed fields are either String,
content = db.Column(db.String(15000)) # Unicode, or Text
datime = db.Column(db.String(20))
url = db.Column(db.String(100))
#flask_whooshalchemyplus.init_app(app) # initialize
flask_whooshalchemyplus.init_app(app)
flask_whooshalchemyplus.whoosh_index(app,BlogingPost)#about flask_whooshalchemyplus
@app.route('/',methods=['GET'])
def index():
posts = BlogingPost.query.all()
return render_template('index.html')
@app.route('/',methods=['POST'])
def indexPost():
get_update = None
if request.form['action'] == u'AI写歌':
para = rundoc.ngram_lm('test2.txt',5,80)
lines = para.split(",")
from app import db
from app.playlist.forms import PlaylistCreateForm, CollectionsCreateForm, CollectionSearchForm
from app.playlist.models import Playlist
from app.playlist.models import Collection
from app.playlist.serializer import get_playlist_serialized, get_collection_serialized
from app.playlist.functions import is_valid_file, get_modified_file_name, check_file_name_already_exist, delete_file_from_audio_directory
from app import ALLOWED_EXTENSIONS, UPLOAD_FOLDER
from marshmallow import Serializer, fields, pprint
from wtforms import StringField, PasswordField, BooleanField
from wtforms.validators import InputRequired, Email, Length
from werkzeug.utils import secure_filename
playlist=Blueprint('playlist', __name__, url_prefix='/')
flask_whooshalchemyplus.whoosh_index(app, Collection)
@playlist.route('/dashboard')
@login_required
def dashboard():
form=PlaylistCreateForm()
queryset = Playlist.query.filter_by(user_id=current_user.id)
serialized = [get_playlist_serialized(item) for item in queryset]
# res = jsonify(res=serialized)
return render_template('dashboard.html', dict=serialized, form=form)
@playlist.route('/playlist', methods=['GET', 'POST', 'DELETE'])
@login_required
def playlistcreate():
form=PlaylistCreateForm()
if flask.request.method == 'POST':
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpg')
password = db.Column(db.String(60), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class Post(db.Model):
__searchable__ = ['title', 'content']
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
date_posted = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
content = db.Column(db.Text, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
category = db.Column(db.String(100), nullable=False)
def __repr__(self):
return f"Post('{self.title}', '{self.date_posted}')"
wa.whoosh_index(app, Post)
class Classes(db.Model):
__tablename__ = 'classes'
__searchable__ = ['name', 'department', 'teacher_one']
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
department = db.Column(db.String(100))
description = db.Column(db.String)
semester = db.Column(db.String(100))
teacher_one = db.Column(db.Integer,
db.ForeignKey('teachers.teacher_id'),
nullable=False)
teacher_two = db.Column(db.Integer)
teachers = db.relationship('Teacher', backref='classes', lazy=True)
wa.whoosh_index(app, Classes)
class Comments(db.Model):
__tablename__ = 'comments'
__searchable__ = ['comment_name', 'comment_class']
id = db.Column(db.Integer, primary_key=True)
comment_name = db.Column(db.String(200))
comment_class = db.Column(db.Integer,
db.ForeignKey('classes.id'),
nullable=False)
classes = db.relationship('Classes', backref='classes', lazy=True)
class ClassCart(db.Model):
__tablename__ = 'class_cart'
def before_request():
from .. import create_app
app = create_app('default')
whoosh.whoosh_index(app, Post)
g.search_form = SearchForm()
relate_message = Column(ForeignKey('message.id'))
uploader = Column(ForeignKey('user.id'))
uploade_time = Column(String(45))
url = Column(String(50))
def full_url(self):
base_url = app.config['BASE_URL'] + '/'
return base_url + self.url
def __repr__(self):
return '<Image %s>' % self.id
# ---------------------------------------------简历搜索index--------------------------
whooshalchemy.whoosh_index(app, User)
whooshalchemy.whoosh_index(app, Message)
whooshalchemy.whoosh_index(app, Channel)
# ---------------------------------test-----------------------------------------------
if __name__ == '__main__':
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker, relationship, backref, scoped_session
engine = create_engine(app.config['SQLALCHEMY_DATABASE_URI'],
pool_size=120,
pool_recycle=20)
session_factory = sessionmaker(bind=engine)
DBSession = scoped_session(session_factory)
if app.config['DROP_ALL']:
app = Flask(__name__)
# 读取配置文件
app.config.from_object('config')
db = SQLAlchemy(app)
lm = LoginManager()
lm.init_app(app)
lm.login_view = 'main.login'
# 多语言处理Flask自带的登录提醒
lm.login_message = lazy_gettext('请登录后访问本页.')
flask_whooshalchemyplus.init_app(app)
from app.leaf.leaf_models import Post
flask_whooshalchemyplus.whoosh_index(app, Post)
from app.book.book_models import Book
flask_whooshalchemyplus.whoosh_index(app, Book)
mail = Mail(app)
# 将封装类与jinja2绑定
app.jinja_env.globals['momentjs'] = momentjs
# 国际化支持
babel = Babel(app)
from app.main import views, models
from app.leaf import leaf_views, leaf_models
from app.book import book_views, book_models
import os
import sys
from flask import request
from flask_script import Manager, Shell
from flask_migrate import Migrate, MigrateCommand
from app import create_app, db, reload_config
from app.models import User, Role, BookStatus, Category, Book, Ebook, BookRent
import flask_whooshalchemyplus as whooshalchemy
reload(sys)
sys.setdefaultencoding('utf-8')
app = create_app(os.getenv('FLASK_BMS_ENV') or 'default')
whooshalchemy.whoosh_index(app, Book)
whooshalchemy.whoosh_index(app, Ebook)
whooshalchemy.whoosh_index(app, User)
if os.getenv('FLASK_BMS_ENV') != 'production':
@app.after_request
def app_after_request(response):
if request.endpoint != 'static':
return response
response.cache_control.max_age = 0
return response
@app.before_first_request
def refresh_config():
print 'config refreshing....'
