def create_app(config_class=Config): app = Flask(__name__) app.config.from_object(Config) db.init_app(app) bcrypt.init_app(app) login_manager.init_app(app) mail.init_app(app) from core.users.routes import users from core.posts.routes import posts from core.main.routes import main from core.finance.routes import finance from core.errors.handlers import errors app.register_blueprint(users) app.register_blueprint(posts) app.register_blueprint(main) app.register_blueprint(finance) app.register_blueprint(errors) # flask admin setup from core.models import User, Post, Transaction, MyAdminIndexView, MyModelView, WebsiteReturn admin.init_app(app, index_view=MyAdminIndexView()) admin.add_view(MyModelView(User, db.session)) admin.add_view(MyModelView(Post, db.session)) admin.add_view(WebsiteReturn(name='Website', endpoint='website')) # whoosh search function import flask_whooshalchemy flask_whooshalchemy.whoosh_index(app, Post) return app
def create_web_app(**config): app = create_app(**config) app.jinja_env.add_extension('pyjade.ext.jinja.PyJadeExtension') with app.app_context(): from openspending.views import register_views register_views(app) from openspending.admin.routes import register_admin flaskadmin = admin.Admin(app, name='FIND Admin') #flaskadmin = Admin(app, url='/admin', name='admin2') register_admin(flaskadmin, db) from openspending.model import Dataset from openspending.model.country import Country whoosearch.whoosh_index(app, Dataset) whoosearch.whoosh_index(app, Country) from openspending.views.context import generate_csrf_token app.jinja_env.globals['csrf_token'] = generate_csrf_token from openspending.assets.assets import register_assets register_assets(assets) return app
def create_web_app(**config): app = create_app(**config) app.jinja_env.add_extension("pyjade.ext.jinja.PyJadeExtension") with app.app_context(): from openspending.views import register_views register_views(app) from openspending.admin.routes import register_admin flaskadmin = admin.Admin(app, name="FIND Admin") # flaskadmin = Admin(app, url='/admin', name='admin2') register_admin(flaskadmin, db) from openspending.model import Dataset from openspending.model.country import Country whoosearch.whoosh_index(app, Dataset) whoosearch.whoosh_index(app, Country) from openspending.views.context import generate_csrf_token app.jinja_env.globals["csrf_token"] = generate_csrf_token from openspending.assets.assets import register_assets register_assets(assets) return app
def rebuild_index(model): import whoosh import flask_whooshalchemy """Rebuild search index of Flask-SQLAlchemy model""" app.logger.info("Rebuilding {0} index...".format(model.__name__)) primary_field = model.pure_whoosh.primary_key_name searchables = model.__searchable__ index_writer = flask_whooshalchemy.whoosh_index(app, model) # Fetch all data entries = model.query.all() entry_count = 0 with index_writer.writer() as writer: for entry in entries: index_attrs = {} for field in searchables: index_attrs[field] = unicode(getattr(entry, field)) index_attrs[primary_field] = unicode(getattr(entry, primary_field)) writer.update_document(**index_attrs) entry_count += 1 app.logger.info("Rebuilt {0} {1} search index entries.".format( str(entry_count), model.__name__))
def create_app(config_name): app = Flask(__name__, instance_relative_config=True) app.config.from_object(app_config[config_name]) app.config.from_pyfile('config.py') app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True app.config['DEBUG'] = True app.config['WHOOSH_BASE'] = 'D:\CRUD' Bootstrap(app) db.init_app(app) login_manager.init_app(app) login_manager.login_message = "You must be logged in to access this page." login_manager.login_view = "auth.login" migrate = Migrate(app, db) from models import Reports wa.whoosh_index(app, Reports) from models import Lives wa.whoosh_index(app, Lives) from models import Transports wa.whoosh_index(app, Transports) from models import Studios wa.whoosh_index(app, Studios) from models import Sngorders wa.whoosh_index(app, Sngorders) from .its import its as its_blueprint app.register_blueprint(its_blueprint, url_prefix='/its') from .auth import auth as auth_blueprint app.register_blueprint(auth_blueprint) from .home import home as home_blueprint app.register_blueprint(home_blueprint) @app.errorhandler(403) def forbidden(error): return render_template('errors/403.html', title='Forbidden'), 403 @app.errorhandler(404) def page_not_found(error): return render_template('errors/404.html', title='Page Not Found'), 404 @app.errorhandler(500) def internal_server_error(error): return render_template('errors/500.html', title='Server Error'), 500 return app
def reindex(): """ Grant admin privileges to given user """ from openspending.core import db from openspending.model import Dataset from openspending.model.country import Country index = whoo.whoosh_index(current_app, Dataset) with index.writer() as writer: for dataset in Dataset.all(): primary_field = dataset.pure_whoosh.primary_key_name searchable = dataset.__searchable__ attrs = {} for key in searchable: try: attrs[key] = unicode(getattr(dataset, key)) except AttributeError: raise AttributeError( '{0} does not have {1} field {2}'.format( "Dataset", __searchable__, key)) attrs[primary_field] = unicode(getattr(dataset, primary_field)) writer.update_document(**attrs) #make sure we ahve all of the geometry tables in there createCountries(silent=True) index = whoo.whoosh_index(current_app, Country) with index.writer() as writer: for country in Country.all(): primary_field = country.pure_whoosh.primary_key_name searchable = country.__searchable__ attrs = {} for key in searchable: try: attrs[key] = unicode(getattr(country, key)) except AttributeError: raise AttributeError( '{0} does not have {1} field {2}'.format( "Country", __searchable__, key)) attrs[primary_field] = unicode(getattr(country, primary_field)) writer.update_document(**attrs)
def reindex(): """ Grant admin privileges to given user """ from openspending.core import db from openspending.model import Dataset from openspending.model.country import Country index = whoo.whoosh_index(current_app, Dataset) with index.writer() as writer: for dataset in Dataset.all(): primary_field = dataset.pure_whoosh.primary_key_name searchable = dataset.__searchable__ attrs = {} for key in searchable: try: attrs[key] = unicode(getattr(dataset, key)) except AttributeError: raise AttributeError('{0} does not have {1} field {2}' .format("Dataset", __searchable__, key)) attrs[primary_field] = unicode(getattr(dataset, primary_field)) writer.update_document(**attrs) #make sure we ahve all of the geometry tables in there createCountries(silent=True) index = whoo.whoosh_index(current_app, Country) with index.writer() as writer: for country in Country.all(): primary_field = country.pure_whoosh.primary_key_name searchable = country.__searchable__ attrs = {} for key in searchable: try: attrs[key] = unicode(getattr(country, key)) except AttributeError: raise AttributeError('{0} does not have {1} field {2}' .format("Country", __searchable__, key)) attrs[primary_field] = unicode(getattr(country, primary_field)) writer.update_document(**attrs)
def configure_extensions(app): """ Configures the Flask extensions for an app. Args: app: The Flask app object to initialize the extensions with. """ db.init_app(app) lm.init_app(app) cache.init_app(app, app.config) markdown.init_app(app) moment.init_app(app) security.init_app(app, user_datastore) whoosh_index(app, Post) app.jinja_env.add_extension('jinja2.ext.do')
def create_app(config_name): app = Flask(__name__) app.config.from_object(config['default']) app.config.from_object(config[config_name]) app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True # app.config['SQLALCHEMY_ECHO'] = True app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = False app.config['SIMPLEMDE_USE_CDN'] = True app.config['SIMPLEMDE_JS_IIFE'] = True # ------ APPLICATION FACTORY ----- # db.init_app(app) migrate.init_app(app, db) bootstrap.init_app(app) toolbar.init_app(app) login_manager.init_app(app) simplemde.init_app(app) moment.init_app(app) csrf.init_app(app) Misaka(app, fenced_code=True, strikethrough=True, tables=True, highlight=True, autolink=True, no_intra_emphasis=True, underline=True, smartypants=True, qoute=True) from app.models import Entries # import local for whoosh index wa.whoosh_index(app, Entries) # ------- BLUEPRINTS --------------# from .blog import blog as blog app.register_blueprint(blog) ''' Blueprint was required after making the application factory. As the app instance is created and configured at run time and thus the 'app' has already created, you cannot access the 'app' after this. I.e. the app in app.route is inaccessible: blueprints mitigate this. ''' return app
def create_app(config_class=Config): app = Flask(__name__) app.config.from_object(config_class) db.init_app(app) mail.init_app(app) login_manager.init_app(app) migrate.init_app(app, db) from app.models import Project w.whoosh_index(app, Project) from app.models import User w.whoosh_index(app, User) #import and register blueprints here from app.api import api app.register_blueprint(api) return app
def create_app(config_class=Config): app = Flask(__name__) app.config.from_object(Config) db.init_app(app) bcrypt.init_app(app) login_manager.init_app(app) mail.init_app(app) from lostandfound.users.routes import users from lostandfound.items.routes import items from lostandfound.errors.handlers import errors from lostandfound.models import LostItem, FoundItem wa.whoosh_index(app, LostItem) wa.whoosh_index(app, FoundItem) #register blueprints app.register_blueprint(users) app.register_blueprint(items) app.register_blueprint(errors) return app
def create_app(config_file): app = Flask(__name__) app.config.from_pyfile(config_file) from app.models import db db.app = app db.init_app(app) with app.app_context(): db.create_all() if config_file == 'config_dev.py': from app.models import User admin_user = User("admin", "*****@*****.**", "Th1515NOT53cur3") admin_user.is_admin = True admin_user.zipcode = 80915 admin_user.viewable = True db.session.add(admin_user) db.session.commit() app.register_blueprint(home) app.register_blueprint(auth) app.register_blueprint(market) app.register_blueprint(comm) app.register_blueprint(admin) app.debug = True from app.login_manager import lm lm.init_app(app) lm.login_view = 'auth.login' lm.login_message = u"You must be logged in to access that page." from app.email import mail mail.init_app(app) resize.init_app(app) from app.models import Item whooshalchemy.whoosh_index(app, Item) toolbar = DebugToolbarExtension(app) return app
def create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) configure_logging() app.jinja_env.globals.update(slugify=slugify) app.jinja_env.globals.update(truncate=truncate) app.jinja_env.globals.update(url=ads.url) bootstrap.init_app(app) db.init_app(app) login_manager.init_app(app) configure_uploads(app, (ads, imgs, landings)) mail.init_app(app) babel.init_app(app) afla_manager.init_app(app) from .models import Post whoosh_index(app, Post) from .aflafrettir import aflafrettir as afla_blueprint from .auth import auth as auth_blueprint from .admin import admin as admin_blueprint from .rss import feed as feed_blueprint app.register_blueprint(afla_blueprint) app.register_blueprint(auth_blueprint, url_prefix='/auth') app.register_blueprint(admin_blueprint, url_prefix='/admin') app.register_blueprint(feed_blueprint, url_prefix='/feed') from helpers.image import start_image_deletion_thread #pylint: disable-msg=W0612 @app.before_first_request def before_first_request(): start_image_deletion_thread() return app
class Post(db.Model): __searchable__ = ['title'], ['content'] post_id = db.Column(db.Integer, primary_key=True) title = db.Column(db.Text(50)) content = db.Column(db.String(140)) timestamp = db.Column(db.DateTime) user_id = db.Column(db.Integer, db.ForeignKey('user.user_id')) def __repr__(self): # pragma: no cover return '<Post %r>' % (self.content) if enable_search: whooshalchemy.whoosh_index(app, Post, User)
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) migrate.init_app(app, db) login_manager.init_app(app) configure_uploads(app, photos) pagedown.init_app(app) from models import Knjige whooshalchemy.whoosh_index(app, Knjige) 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') return app
def create_app(configname): app = Flask(__name__) login_manager.init_app(app) app.config.from_object(config[configname]) bootstrap.init_app(app) db.init_app(app) csrf.init_app(app) configure_uploads(app, (photos, audio)) # main blueprint from main import main as main_blueprint app.register_blueprint(main_blueprint) # auth blueprint from auth import auth as auth_blueprint app.register_blueprint(auth_blueprint, url_prefix='/auth') #index searches from .models import Song, Album if enable_search: flask_whooshalchemy.whoosh_index(app, Song) flask_whooshalchemy.whoosh_index(app, Album) return app
def rebuild_index(model): primary_field = model.pure_whoosh.primary_key_name searchables = model.__searchable__ index_writer = flask_whooshalchemy.whoosh_index(APP, model) entries = model.query.all() entry_count = 0 with index_writer.writer() as writer: for entry in entries: index_attrs = {} for field in searchables: index_attrs[field] = unicode(getattr(entry, field)) index_attrs[primary_field] = unicode( getattr(entry, primary_field)) writer.update_document(**index_attrs) entry_count += 1 print 'Rebuilt {0} {1} search index entries.'.format(str(entry_count), model.__name__)
def rebuild_index(model): """Rebuild search index of Flask-SQLAlchemy model""" log("Rebuilding {0} index...".format(model.__name__)) primary_field = model.pure_whoosh.primary_key_name searchables = model.__searchable__ index_writer = flask_whooshalchemy.whoosh_index(app, model) # Fetch all data entries = model.query.all() entry_count = 0 with index_writer.writer() as writer: for entry in entries: index_attrs = {} for field in searchables: index_attrs[field] = unicode(getattr(entry, field)) index_attrs[primary_field] = unicode(getattr(entry, primary_field)) writer.update_document(**index_attrs) entry_count += 1 log("Rebuilt {0} {1} search index entries.".format(str(entry_count), model.__name__))
def create_web_app(**config): app = create_app(**config) app.jinja_env.add_extension('pyjade.ext.jinja.PyJadeExtension') with app.app_context(): from openspending.views import register_views register_views(app) from openspending.admin.routes import register_admin register_admin(app, db) from openspending.model import Dataset from openspending.model.country import Country from openspending.forum.forum.models import Category,Post,Topic,Forum whoosearch.whoosh_index(app,Dataset) whoosearch.whoosh_index(app, Country) whoosearch.whoosh_index(app, Category) whoosearch.whoosh_index(app, Post) whoosearch.whoosh_index(app, Topic) whoosearch.whoosh_index(app, Forum) from openspending.views.context import generate_csrf_token app.jinja_env.globals['csrf_token'] = generate_csrf_token from openspending.assets.assets import register_assets register_assets(assets) configure_template_filters(app) if os.environ.get("FLASK_DEBUGTOOLBAR", False): toolbar = DebugToolbarExtension(app) return app
from app import create_app import flask_whooshalchemy as whooshalchemy from app.models import Company, Product, Article, User from flask import request, abort, g from app.config import ProductionConfig from app.main.forms import SearchForm from app.users.forms import SubscribeForm from app.constants import Constants app = create_app() app.app_context().push() @app.before_request def before_request(): g.subscribe_form = SubscribeForm() if ProductionConfig.MAINTENANCE_MODE and not "static" in request.path: abort(Constants.MAINTENANCE_PAGE) elif ProductionConfig.COMING_SOON and not "static" in request.path: abort(Constants.COMING_SOON_PAGE) else: g.search_form = SearchForm() if __name__ == "__main__": whooshalchemy.whoosh_index(app, Company) whooshalchemy.whoosh_index(app, Product) whooshalchemy.whoosh_index(app, Article) whooshalchemy.whoosh_index(app, User) app.run(debug=True)
def configure_extensions(app): """Configures the extensions.""" # Flask-WTF CSRF csrf.init_app(app) # Flask-Plugins plugin_manager.init_app(app) # Flask-SQLAlchemy db.init_app(app) # Flask-Migrate migrate.init_app(app, db) # Flask-Mail mail.init_app(app) # Flask-Cache cache.init_app(app) # Flask-Debugtoolbar debugtoolbar.init_app(app) # Flask-Themes themes.init_themes(app, app_identifier="flaskbb") # Flask-And-Redis redis_store.init_app(app) # Flask-WhooshAlchemy with app.app_context(): whoosh_index(app, Post) whoosh_index(app, Topic) whoosh_index(app, Forum) whoosh_index(app, Category) whoosh_index(app, User) # Flask-Login login_manager.login_view = app.config["LOGIN_VIEW"] login_manager.refresh_view = app.config["REAUTH_VIEW"] login_manager.anonymous_user = Guest @login_manager.user_loader def load_user(user_id): """Loads the user. Required by the `login` extension.""" user_instance = User.query.filter_by(id=user_id).first() if user_instance: return user_instance else: return None login_manager.init_app(app) # Flask-BabelEx babel.init_app(app=app, default_domain=FlaskBBDomain(app)) @babel.localeselector def get_locale(): # if a user is logged in, use the locale from the user settings if current_user.is_authenticated and current_user.language: return current_user.language # otherwise we will just fallback to the default language return flaskbb_config["DEFAULT_LANGUAGE"] # Flask-Allows allows.init_app(app) allows.identity_loader(lambda: current_user)
def is_following(self, user): return self.followed.filter( followers.c.followed_id == user.id).count() > 0 def followed_posts(self): return Post.query.join( followers, (followers.c.followed_id == Post.user_id)).filter( followers.c.follower_id == self.id).order_by( Post.timestamp.desc()) def __repr__(self): # pragma: no cover return '<User %r>' % (self.nickname) class Post(db.Model): __searchable__ = ['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): # pragma: no cover return '<Post %r>' % (self.body) if enable_search: flask_whooshalchemy.whoosh_index(app, Post)
def __str__(self): return str(self.username) class Movies(db.Model): __searchable__ = ['name', 'director'] id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(200), nullable=False) imdb_score = db.Column(db.Numeric(2, 2), default=0.0) popularity99 = db.Column(db.Numeric(2, 2), default=0.0) director = db.Column(db.String(80), nullable=False) def __str__(self): index_service.register_class(Movies) return str(self.name) wb.whoosh_index(app, Movies) class MovieGenre(db.Model): MovieID = db.Column(db.Integer, db.ForeignKey('movies.id'), primary_key=True) Genre = db.Column(db.String(20), primary_key=True) def __str__(self): return str(self.GenreID + str(self.MovieID)) db.create_all() db.session.commit()
class Codes(db.Model): __tablename__ = 'Codes' __searchable__ = ['description', 'tags'] code_id = db.Column('code_id', db.Unicode, primary_key=True) description = db.Column('description', db.Unicode) tags = db.Column('tags', db.Unicode) code = db.Column('code', db.Unicode) def __init__(self, code_id, description, tags, code): self.code_id = code_id self.description = description self.tags = tags self.code = code wa.whoosh_index(app, Codes) @bp.route('/save', methods=['GET', 'POST']) def save(): if request.method == 'POST': if request.form.get('save'): code = request.form.get('code') tags = request.form.get('tags') description = request.form.get('problem') code_id = random_String() temp = Codes(code_id, description, tags, code) db.session.add(temp) db.session.commit()
def configure_extensions(app): """Configures the extensions.""" # Flask-WTF CSRF csrf.init_app(app) # Flask-Plugins plugin_manager.init_app(app) # Flask-SQLAlchemy db.init_app(app) # Flask-Migrate migrate.init_app(app, db) # Flask-Mail mail.init_app(app) # Flask-Cache cache.init_app(app) # Flask-Debugtoolbar debugtoolbar.init_app(app) # Flask-Themes themes.init_themes(app, app_identifier="flaskbb") # Flask-And-Redis redis_store.init_app(app) # Flask-WhooshAlchemy with app.app_context(): whoosh_index(app, Post) whoosh_index(app, Topic) whoosh_index(app, Forum) whoosh_index(app, Category) whoosh_index(app, User) # Flask-Login login_manager.login_view = app.config["LOGIN_VIEW"] login_manager.refresh_view = app.config["REAUTH_VIEW"] login_manager.login_message_category = app.config["LOGIN_MESSAGE_CATEGORY"] login_manager.needs_refresh_message_category = \ app.config["REFRESH_MESSAGE_CATEGORY"] login_manager.anonymous_user = Guest @login_manager.user_loader def load_user(user_id): """Loads the user. Required by the `login` extension.""" user_instance = User.query.filter_by(id=user_id).first() if user_instance: return user_instance else: return None login_manager.init_app(app) # Flask-BabelEx babel.init_app(app=app, default_domain=FlaskBBDomain(app)) @babel.localeselector def get_locale(): # if a user is logged in, use the locale from the user settings if current_user.is_authenticated and current_user.language: return current_user.language # otherwise we will just fallback to the default language return flaskbb_config["DEFAULT_LANGUAGE"] # Flask-Allows allows.init_app(app) allows.identity_loader(lambda: current_user)
self.cost_price = cost_price self.package_id = package_id self.edit_log = edit_log def __repr__(self): return '<name {0}>'.format(self.order_status) class User(db.Model): __tablename__ = 'users' id = db.Column(db.String, primary_key = True) name = db.Column(db.String, unique = True, nullable = False) email = db.Column(db.String, unique = True, nullable = False) password = db.Column(db.String, nullable = False) role = db.Column(db.String, default = 'user') def __init__(self, id, name = None, email = None, password = None, role = None, price_model = None): self.id = id self.name = name self.email = email self.password = password self.role = role def __repr__(self): return '<User {0}>'.format(self.name) if enable_search: whooshalchemy.whoosh_index(app, Orders)
import flask_whooshalchemy as whooshalchemy from dataviva import app from models import Publication whooshalchemy.whoosh_index(app, Publication)
'id': self.id, } class Book(db.Model): __searchable__ = ['name','description'] id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(30), nullable=False) description = db.Column(db.String(250)) price = db.Column(db.String(8)) author_id = db.Column(db.Integer, db.ForeignKey('author.id')) @property def serialize(self): return { 'name': self.name, 'description': self.description, 'id': self.id, 'price': self.price, } class User(UserMixin, db.Model): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(15), unique=True) email = db.Column(db.String(50), unique=True) password = db.Column(db.String(80)) db.create_all(); wa.whoosh_index(app, Book)
image_url=None, game_id=None, owner_id=None, *args): super(Community, self).__init__(*args) self.id = id self.name = name self.description = description self.language = language self.rules = rules self.image_url = image_url self.game_id = game_id self.owner_id = owner_id id = db.Column(db.String(128), primary_key = True) # Attributes name = db.Column(db.TEXT) description = db.Column(db.TEXT) language = db.Column(db.String(128)) rules = db.Column(db.TEXT) image_url = db.Column(db.TEXT) # Connection to other models game_id = db.Column(db.Integer) owner_id = db.Column(db.String) # Allow indexing on models wa.whoosh_index(application, User) wa.whoosh_index(application, Game) wa.whoosh_index(application, Team) wa.whoosh_index(application, Community)
#!/usr/bin/env python # -*- coding:utf-8 -*- from app import create_app from flask_script import Manager from flask_migrate import MigrateCommand import flask_whooshalchemy as whooshalchemy from app.models import User, Question, Answer app = create_app('production') manager = Manager(app) manager.add_command('db', MigrateCommand) whooshalchemy.whoosh_index(app, Question) #初始化whoosh全文搜索索引 whooshalchemy.whoosh_index(app, Answer) whooshalchemy.whoosh_index(app, User) if __name__ == '__main__': manager.run()
short_description = db.Column(db.String(140), index=True) def __repr__(self): return 'CodeProject %r \n short description: %r \n timestamp: %r \n github_link: %r \n download_link: %r \n name_no_spaces: %r \n datestring: %r \n' \ % (self.name,self.short_description, self.timestamp, self.github_link, self.download_link, self.name_no_spaces, self.date_string) def get_id(self): try: return unicode(self.id) # python 2 except NameError: return str(self.id) # python 3 class Picture(db.Model): id = db.Column(db.Integer, primary_key=True) link = db.Column(db.String(150), index=True, unique=True) foreign_id = db.Column(db.Integer, db.ForeignKey('code_project.id')) def __repr__(self): return '<Picture %r>' % (self.link) def get_id(self): try: return unicode(self.id) # python 2 except NameError: return str(self.id) # python 3 # Enable search if running python 2 if enable_search: whooshalchemy.whoosh_index(app, BlogPost) whooshalchemy.whoosh_index(app, CodeProject)
def configure_extensions(app): """Configures the extensions.""" # Flask-Plugins plugin_manager.init_app(app) # Flask-SQLAlchemy db.init_app(app) # Flask-Migrate migrate.init_app(app, db) # Flask-Mail mail.init_app(app) # Flask-Cache cache.init_app(app) # Flask-Debugtoolbar debugtoolbar.init_app(app) # Flask-Themes themes.init_themes(app, app_identifier="flaskbb") # Flask-And-Redis redis_store.init_app(app) # Flask-WhooshAlchemy with app.app_context(): whoosh_index(app, Post) whoosh_index(app, Topic) whoosh_index(app, Forum) whoosh_index(app, Category) whoosh_index(app, User) # Flask-Login login_manager.login_view = app.config["LOGIN_VIEW"] login_manager.refresh_view = app.config["REAUTH_VIEW"] login_manager.anonymous_user = Guest @login_manager.user_loader def load_user(user_id): """Loads the user. Required by the `login` extension.""" unread_count = db.session.query(db.func.count(PrivateMessage.id)).\ filter(PrivateMessage.unread, PrivateMessage.user_id == user_id).subquery() u = db.session.query(User, unread_count).filter(User.id == user_id).\ first() if u: user, user.pm_unread = u return user else: return None login_manager.init_app(app) # Flask-BabelEx babel.init_app(app=app, default_domain=FlaskBBDomain(app)) @babel.localeselector def get_locale(): # if a user is logged in, use the locale from the user settings if current_user.is_authenticated() and current_user.language: return current_user.language # otherwise we will just fallback to the default language return flaskbb_config["DEFAULT_LANGUAGE"]
location_id = db.Column(db.Integer, db.ForeignKey('location.id')) title = db.Column(db.String(30), nullable=False) price_low = db.Column(db.Integer) price_high = db.Column(db.Integer) description = db.Column(db.Text) create_time = db.Column(db.DateTime) valid_time = db.Column(db.DateTime) status = db.Column(db.SmallInteger) phone = db.Column(db.String(40)) qq = db.Column(db.String(40)) def __repr__(self): """docstring for __repr__""" return '<Buy id:%s user_id:%s title:%s>' % (self.id, self.user_id, self.title) class Token(db.Model, Serializer): """docstring for Token""" id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey('user.id')) confirm = db.Column(db.Integer, nullable=False) create_time = db.Column(db.DateTime, nullable=False) def __repr__(self): """docstring for __repr__""" return '<Token user_id:%s confirm:%s create_time:%s>' % (self.user_id, self.confirm, self.create_time) whooshalchemy.whoosh_index(app, Sell) whooshalchemy.whoosh_index(app, Buy)
self.C150_4_COMB_PRESENT = C150_4_COMB_PRESENT self.COSTT4_COMB_PRESENT = COSTT4_COMB_PRESENT self.WDRAW_ORIG_YR6_RT_PRESENT = WDRAW_ORIG_YR6_RT_PRESENT self.NPT4_COMB_PRESENT = NPT4_COMB_PRESENT self.PCTPELL_PRESENT = PCTPELL_PRESENT self.RET_FT4_COMB_PRESENT = RET_FT4_COMB_PRESENT self.RET_PT4_COMB_PRESENT = RET_PT4_COMB_PRESENT self.ADJ_AVGFACSAL_PRESENT = ADJ_AVGFACSAL_PRESENT self.ADJ_INEXPFTE_PRESENT = ADJ_INEXPFTE_PRESENT self.PFTFTUG1_EF_PRESENT = PFTFTUG1_EF_PRESENT self.PFTFAC_PRESENT = PFTFAC_PRESENT self.fin_COMB_RET_RATE_PRESENT = fin_COMB_RET_RATE_PRESENT self.rankp_MN_EARN_WNE_P6 = rankp_MN_EARN_WNE_P6 self.rankp_DEBT_MDN = rankp_DEBT_MDN self.rankp_C150_4_COMB = rankp_C150_4_COMB self.rankp_COSTT4_COMB = rankp_COSTT4_COMB self.rankp_WDRAW_ORIG_YR6_RT = rankp_WDRAW_ORIG_YR6_RT self.rankp_NPT4_COMB = rankp_NPT4_COMB self.rankp_PCTPELL = rankp_PCTPELL self.rankp_ADJ_AVGFACSAL = rankp_ADJ_AVGFACSAL self.rankp_ADJ_INEXPFTE = rankp_ADJ_INEXPFTE self.rankp_PFTFAC = rankp_PFTFAC self.rankp_COMB_RET_RATE = rankp_COMB_RET_RATE self.adm_pct = adm_pct self.IF_SAT_PRESENT = IF_SAT_PRESENT self.IF_ACT_PRESENT = IF_ACT_PRESENT if enable_search: whooshalchemy.whoosh_index(flask_app, School_details) whooshalchemy.whoosh_index(flask_app, Wiki_summary)
from . import db from . import app from . import ma import flask_whooshalchemy as wa class Movie(db.Model): __searchable__ = ['title', 'description'] id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(50)) rating = db.Column(db.Integer) description = db.Column(db.String(255)) wa.whoosh_index(app, Movie) class Show(db.Model): id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(200)) description = db.Column(db.String(1000)) class Season(db.Model): id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(200)) total_episodes = db.Column(db.Integer) show_id = db.Column(db.Integer, db.ForeignKey('show.id')) show = db.relationship('Show', backref='seasons')
__searchable__ = ['name'] id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(255)) def __init__(self, name): self.name = name def get_name(self): return self.name def __repr__(self): return '<Book %r>' % self.name flask_whooshalchemy.whoosh_index(app, Author) flask_whooshalchemy.whoosh_index(app, Book) AuthorFormBase = model_form(Author, base_class=Form, db_session=db.session) BookFormBase = model_form(Book, base_class=Form, db_session=db.session) class MultiCheckboxField(SelectMultipleField): widget = widgets.ListWidget(prefix_label=False) option_widget = widgets.CheckboxInput() class AuthorForm(AuthorFormBase): books = MultiCheckboxField(coerce=int) class BookForm(BookFormBase):
class Operations(db.Model): __tablename__ = 'operations' id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer) operation = db.Column(db.String(200)) timestamp = db.Column(db.TIMESTAMP) class Rates(db.Model): __tablename__ = 'rates' __searchable__ = ['date', 'client', 'rate', 'origin', 'destination', 'type', 'terms', 'manager', 'comments'] id = db.Column(db.Integer, primary_key=True, autoincrement=True) date = db.Column(db.DateTime, default=datetime.datetime.now()) client = db.Column(db.String(100)) rate = db.Column(db.String(100)) origin = db.Column(db.String(100)) destination = db.Column(db.String(100)) capacity = db.Column(db.String(100)) type = db.Column(db.String(100)) terms = db.Column(db.String(500)) manager = db.Column(db.String(100)) comments = db.Column(db.String(500)) created_by = db.Column(db.Integer) is_new = db.Column(db.Boolean) taken_by = db.Column(db.Integer) user_datastore = SQLAlchemyUserDatastore(db, User, Role) security = Security(app, user_datastore) whooshalchemy.whoosh_index(app, Rates)
if not self.is_following(user): self.followed.append(user) return self def unfollow(self, user): if self.is_following(user): self.followed.remove(user) return self def is_following(self, user): return self.followed.filter(followers.c.followed_id == user.id).count() > 0 def followed_posts(self): return Post.query.join(followers, (followers.c.followed_id == Post.user_id)).filter( followers.c.follower_id == self.id).order_by(Post.timestamp.desc()) class Post(db.Model): __searchable__ = ['body'] id = db.Column(db.Integer, primary_key=True) body = db.Column(db.String(120)) timestamp = db.Column(db.DateTime) user_id = db.Column(db.Integer, db.ForeignKey('user.id')) def __repr__(self): return '<Post %r>' % self.body whooshalchemy.whoosh_index(app, Post)
class Category(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(60)) description = db.Column(db.String(560)) sort = db.Column(db.Integer) is_custom = db.Column(db.Integer) parent_id = db.Column(db.Integer, db.ForeignKey('category.id')) type = db.Column(db.Integer) parrent = db.relationship('Category', remote_side=[id], backref='children') # def __init__(self, name): # self.name = name def __init__(self, **kwargs): super(Category, self).__init__(**kwargs) def __repr__(self): return self.name class Contact(db.Model): id = db.Column(db.Integer, primary_key=True) cellphone = db.Column(db.String(30)) email = db.Column(db.String(120)) report = db.Column(db.String(1024)) if enable_search: flask_whooshalchemy.whoosh_index(app, Post)
# Relationships characters = db.relationship("Character", secondary=characters_books, back_populates="books") povCharacters = db.relationship("Character", secondary=characters_povbooks, back_populates="povBooks") def __init__(self, id="", name="", isbn="", numberOfPages=0, publisher="", country="", mediaType="", released=""): self.id = id self.name = name self.isbn = isbn self.numberOfPages = numberOfPages self.publisher = publisher self.country = country self.mediaType = mediaType self.released = released def __repr__(self): return "<Book %r>" % self.name """ Index the models for searching with Whoosh """ flask_whooshalchemy.whoosh_index(app, Character) flask_whooshalchemy.whoosh_index(app, House) flask_whooshalchemy.whoosh_index(app, Book)
username = db.Column(db.String(164)) password_hash = db.Column(db.String(164)) book = db.relationship('Book', backref="user", lazy="dynamic") @login_manager.user_loader def load_user(user_id): """flask-login要求实现的用户加载回调函数 依据用户的unicode字符串的id加载用户""" return User.query.get(int(user_id)) @property def password(self): """将密码方法设为User类的属性""" raise AttributeError('无法读取密码原始值!') @password.setter def password(self, password): """设置密码散列值""" self.password_hash = generate_password_hash(password) def verify_password(self, password): """验证密码散列值""" return check_password_hash(self.password_hash, password) def __repr__(self): return "%r :The instance of class User" % self.username if enable_search: whooshalchemy.whoosh_index(app, Book)
__tablename__ = 'Post' __searchable__ = ['id','name'] id = db.Column(db.Integer,primary_key=True) name = db.Column(db.String(30)) age= db.Column(db.VARCHAR(10)) gender=db.Column(db.VARCHAR(1)) school=db.Column(db.VARCHAR(10)) height=db.Column(db.Float(5,2)) health=db.Column(db.String(20)) blood=db.Column(db.VARCHAR(10)) db.create_all() def __repr__(self): return '{0}(title={1})'.format(self.__class__.__name__, self.name) wa.whoosh_index(app,Post) @app.route('/search',methods=['GET']) def search(Post): with app.test_request_context(): from flask import request# Do Expensive work posts =Post.query.whoosh_search(request.args.get('query')). all() return render_template('records.html',posts=posts) class Donate(db.Model): id=db.Column(db.Integer,primary_key=True,autoincrement=True) name1=db.Column(db.String(100)) address=db.Column(db.String(100))
# --------------------------------------------------------------------------------------------------- class Interview_question(db.Model): id = db.Column(db.Integer, db.ForeignKey('user.id'), primary_key=True) jobkey = jobkey = db.Column(db.String, db.ForeignKey('position.jobkey'), primary_key=True) employer_name = db.Column(db.String, db.ForeignKey('position.employername')) interview_round = db.Column(db.Integer) question = db.Column(db.String) solution = db.Column(db.String) feedback = db.Column(db.String) user = db.relationship(User, uselist=False, backref="application_status") position = db.relationship(Position, uselist=False, backref="application_status") def __init__(self, id, jobkey, employer_name, interview_round, queston, solution, feedback): self.id = id self.jobkey = jobkey self.employer_name = employer_name self.interview_round = interview_round self.question = queston self.solution = solution self.feedback = feedback def __repr__(self): return '<Interview_question | accountid: %s, jobkey : %s, round: %d, question: %s>' \ % (self.id, self.jobkey, self.interview_round, self.question) # --------------------------------------------------------------------------------------------------- # create index for table: Position whooshalchemy.whoosh_index(app, Position)
#判断python版本是否大于3.0, 大于3.0的版本还不能用Whoosh if sys.version_info >= (3, 0): enable_search = False else: enable_search = True import flask_whooshalchemy as whooshalchemy class Warehouseinfo(db.Model): #__searchable__字段中包含数据库中所有能被搜索并被建立索引的字段 #即, "title"字段可以被全文搜索引擎搜索到 __tablename__ = 'warehouseinfo' __searchable__ = ['title'] id = db.Column(db.String(100), primary_key=True) title = db.Column(db.String(50)) author = db.Column(db.String(30)) tags = db.Column(db.String(100)) desc = db.Column(db.String(700)) imgurl = db.Column(db.String(250)) kmzurl = db.Column(db.String(250)) imgfile = db.Column(db.String(30)) kmzfile = db.Column(db.String(30)) other = db.Column(db.String(100)) if enable_search: #whoosh_index()为Warehouseinfo模型初始化了全文搜索索引 #即, 为"title"初始化了全文搜索索引 whooshalchemy.whoosh_index(app, Warehouseinfo)
site = db.Column(db.String(200)) def __init__(self, title, picture, species, comment, by, uploaded, email, country, site): self.title = title self.picture = picture self.species = species self.comment = comment self.by = by self.uploaded = uploaded self.email = email self.country = country self.site = site wa.whoosh_index(app, Sightings) class Comments(db.Model): _id = db.Column("id", db.Integer, primary_key=True) post_id = db.Column(db.Integer) comment = db.Column(db.String(300)) by = db.Column(db.String(100)) def __init__(self, post_id, comment, by): self.post_id = post_id self.comment = comment self.by = by @app.route("/")
def a(): from manage import app whooshalchemy.whoosh_index(app, Post)
subject = db.Column(db.VARCHAR(128), nullable=True) place = db.Column(db.VARCHAR(128), nullable=True) timing = db.Column(db.Date, nullable=False) description = db.Column(db.VARCHAR(2048), nullable=True) thumbnail = db.Column(db.BLOB, nullable=False) photo = db.Column(db.BLOB, nullable=False) # Relationship to follow with sqlalchemy viewed_by = relationship("Popularity", backref="image") def __repr__(self): return '<Image %r %r>' % (self.photo_id, self.owner_name) # Register indexes on images whooshalchemy.whoosh_index(app, Image) class Popularity(db.Model): """ ORM for the `popularity` table. This table stores a combination of photo_id/viewed_by for each user that has viewed an image. """ __tablename__ = 'popularities' # Columns photo_id = db.Column(db.Integer, ForeignKey('images.photo_id'), primary_key=True, nullable=False)
from app import app from app.models import Post as Model from flask_whooshalchemy import whoosh_index """ from app.models import <table to index> as Model. change <table to index> to the table you want indexed atatime - the number of records to pull from the database at once limitmb - "max" megabytes to use procs - cores to use in parallel """ sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0) atatime = 512 # how many rows to load at a time with app.app_context(): index = whoosh_index(app, Model) # Create a Whoosh index object searchable = Model.__searchable__ # Import the fields we want indexed print 'counting rows...' total = int(Model.query.order_by(None).count()) # Count the number of rows done = 0 # initialize the done variable print 'total rows: {}'.format(total) writer = index.writer(limitmb=10000, procs=16, multisegment=True) # Create the writer object for p in Model.query.yield_per(atatime): # to batch results in sub-collections and yield them out partially (Save memory) record = dict([(s, p.__dict__[s]) for s in searchable]) # create a dictionary of of the fields we are indexing with whoosh form the table record.update({'id': unicode(p.id)}) # id is mandatory, or whoosh won't work writer.add_document(**record) # write record to index database done += 1 # update done variable if done % atatime == 0: print 'c {}/{} ({}%)'.format(done, total, round((float(done)/total)*100, 2)), # calculate percentage complete print '{}/{} ({}%)'.format(done, total, round((float(done)/total)*100, 2)) # print completion
nullable=False) #demo_email = db.Column(db.String(100), db.ForeignKey('demo.email', ondelete='CASCADE'), nullable=False) def __init__(self, body, meeting_id, like_count): self.body = body self.timestamp = datetime.utcnow() self.meeting_id = meeting_id self.like_count = like_count # Or should it be just meeting.id instead of g.course.id? def __repr__(self): return '<Muddy %r>' % self.body class EmailList(db.Model): __tablename__ = 'email' id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(100), index=True, nullable=False, unique=True) def __init__(self, email): self.email = email def __repr__(self): return '<Email %r>' % self.email if enable_search: whooshalchemy.whoosh_index(app, Course) whooshalchemy.whoosh_index(app, Meeting) whooshalchemy.whoosh_index(app, Muddy)
Post.timestamp.desc()) # order by date created def __repr__(self): return '<User {nickname}>'.format(nickname=self.nickname) """ defines a method for printing this object """ class Post(db.Model): __searchable__ = ['body'] # used by whoosh id = db.Column(db.Integer, primary_key=True) # Creates a primary key, integer column named ID body = db.Column(db.String(140)) # Creates a column named body with type string, 140 char length timestamp = db.Column(db.DateTime) # Creates a column named timestamp with type datetime user_id = db.Column(db.Integer, db.ForeignKey('user.id')) """ Creates a ForeignKey linked to the id column in the user table (provided by the User class) """ def __repr__(self): return '<Post {body}>'.format(body=self.body) """ defines a method for printing this object """ if enable_search: # checks to see if the enable search flag has been enabled whooshalchemy.whoosh_index(app, Post) # indexes the database on the fields we need
# Bookmark model and related db columns class Bookmark(db.Model): id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey('user.id')) lesson_id = db.Column(db.Integer, db.ForeignKey('lesson.id')) topic_id = db.Column(db.Integer, db.ForeignKey('topic.id')) created_at = db.Column('created_at', db.TIMESTAMP, server_default=db.func.now()) # What gets printed in flask shell or yarn shell when # querying Lessons def __repr__(self): return '<Bookmark {}>'.format(self.id, self.lesson_id, self.user_id, self.topic_id, self.created_at) @login.user_loader def load_user(id): return User.query.get(int(id)) wa.whoosh_index(app, User) wa.whoosh_index(app, Role) wa.whoosh_index(app, Topic) wa.whoosh_index(app, Lesson) wa.whoosh_index(app, Comment)
Rates = db.Column(db.Float(8), index=True, unique=False) DownloadTimes = db.Column(db.Integer, index=True, unique=False) ImplementedDate = db.Column(db.String(64), index=True, unique=False) developer_tool_mapping = db.relationship('Developer_tool_map', backref='tool', lazy='dynamic') keyword_tool_mapping = db.relationship('Keyword_tool_map', backref='tool', lazy='dynamic') def __repr__(self): return '<Tool %r>' % (self.NameString) if enable_search: whooshalchemy.whoosh_index(app, Tool) class Developer(db.Model): id = db.Column(db.Integer, primary_key=True) NameString = db.Column(db.String(32), index=True, unique=False) developer_tool_mapping = db.relationship('Developer_tool_map', backref='developer', lazy='dynamic') def __repr__(self): return '<Developer %r>' % (self.NameString) class Keyword(db.Model): id = db.Column(db.Integer, primary_key=True)
def is_following(self, user): return self.followed.filter( followers.c.followed_id == user.id).count() > 0 def followed_posts(self): return Post.query.join( followers, (followers.c.followed_id == Post.user_id)).filter( followers.c.follower_id == self.id).order_by( Post.timestamp.desc()) def __repr__(self): # pragma: no cover return '<User %r>' % (self.nickname) class Post(db.Model): __searchable__ = ['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)
def register_search_models(app): whooshalchemy.whoosh_index(app, HrApplication)