def create_app(): app = Flask(__name__, template_folder='templates') CORS(app) CSRFProtect(app) config.init(os.environ['CONFIG_PATH']) app.config['SERVER_NAME'] = config.config['server_name'] app.config['SECRET_KEY'] = config.config['secret_key'] app.config['SQLALCHEMY_DATABASE_URI'] = config.config['db_url'] app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False app.config['SQLALCHEMY_ECHO'] = app.debug app.config.update(**config.config['mail']) app.config['MAIL_USERNAME'] = os.environ['APP_MAIL_USERNAME'] app.config['MAIL_PASSWORD'] = os.environ['APP_MAIL_PASSWORD'] login_manager.init_app(app) db.init_app(app) make_searchable(db.metadata) mail.init_app(app) migrate.init_app(app, db) from .auth import auth app.register_blueprint(auth, url_prefix='/auth') from .main import main app.register_blueprint(main, url_prefix='/') from .api import api app.register_blueprint(api, url_prefix='/api') return app
def __init__(self, database_conf: {}, meta_data=None): super().__init__() self.user = database_conf["db_user"] self.password = database_conf["db_pass"] self.host = database_conf["db_host"] self.database = database_conf["db_name"] self.port = database_conf["db_port"] make_searchable(meta_data)
def setup_method(self, method): self.engine = create_engine(CONNECTION_STRING) self.engine.execute('CREATE EXTENSION IF NOT EXISTS hstore') # self.engine.echo = True self.Base = declarative_base() make_searchable(self.Base.metadata) self.create_models() Session = sessionmaker(bind=self.engine) self.session = Session() sa.orm.configure_mappers() self.create_tables()
def db(app, request): from cal import db db.init_app(app) db.configure_mappers() db.create_all() make_searchable() yield db db.session.close() # prevent py.test from hanging db.drop_all()
def __init__(self, config): super().__init__(config) self.engine = build_engine(sql_engine_uri=self.config.DATABASE_URI) self.session_factory = sessionmaker(bind=self.engine, autoflush=True) sa.orm.configure_mappers() # IMPORTANT! make_searchable(metadata=metadata) metadata.create_all(self.engine) if config.AFFAIR_REPOSITORY == "ELASTIC": self.elastic_repositories = ElasticRepositories(config=self.config) self.affair = self.elastic_repositories.affair else: self.affair = InMemoryAffairRepository()
def create_app(config_path=None, name=None): """Create a Flask application. Args: config_path (str, optional): The absolute or relative path to the JSON formatted configuration file. If not provided, defaults to *config.json*. name (str, optional): The name of the Flask application. Defaults to the name of the package. Returns: :class:`flask.Flask`: A Flask application instance. """ if name is None: name = __name__.split('.')[0] app = flask.Flask(name, instance_relative_config=True) if config_path is None: config_path = os.getenv('RMFDB_CONFIG', default_config_filename) init_config(app, config_path=config_path) for key in app.config: envvar = key.upper() if envvar in os.environ: app.config[key] = os.getenv(envvar) app.logger.setLevel(logging.INFO) init_handlers(app) # middleware middleware.cache.init_app(app) middleware.db.init_app(app) middleware.limiter.init_app(app) middleware.ma.init_app(app) middleware.migrate.init_app(app, middleware.db) middleware.talisman.init_app(app, force_https=False) # fts make_searchable(middleware.db.metadata) middleware.db.configure_mappers() # blueprints app.register_blueprint(settings) app.register_blueprint(stigs) app.register_blueprint(controls) app.register_blueprint(search) return app
def enable_full_text_search(): """ Add full-text search capabilities to the database models. This must be called prior to any database model creation or migration """ from flask.ext.sqlalchemy import BaseQuery from sqlalchemy_searchable import SearchQueryMixin class OrganizationQuery(BaseQuery, SearchQueryMixin): pass from sqlalchemy_searchable import make_searchable from sqlalchemy_utils.types import TSVectorType #Update the models query_class if full-text search desired Organization.query_class = OrganizationQuery search_vector = db.Column(TSVectorType('legalName', 'description')) #enable full-text search of postgres. call after models are augmented. make_searchable()
class Recipe(db.Model): """ Model for storing recipes """ query_class = RecipeQuery __tablename__ = 'recipes' make_searchable() id = db.Column(UUID(as_uuid=True), primary_key=True, default=lambda: uuid.uuid4().hex) name = db.Column(db.String(255), unique=True, nullable=False) description = db.Column(db.Text) steps = db.Column(ARRAY(db.Text)) image = db.Column(db.String(255), unique=False, nullable=True) rating = db.Column(db.Float) num_ratings = db.Column(db.Integer, default=0) creator_id = db.Column(UUID(as_uuid=True), db.ForeignKey('users.id')) creator = db.relationship('User', back_populates='created_recipes') search_vector = db.Column(TSVectorType('name', 'description')) raters = association_proxy('rating_users', 'user') ingredients = association_proxy('recipe_ingredients', 'ingredient') def __init__(self, name, description=None, steps=None, image=None, rating=None, creator=None, creator_id=None): self.name = name self.description = description self.steps = steps self.image = image self.rating = rating self.creator_id = creator_id self.creator = creator
from sqlalchemy import Unicode, Integer, Text, desc, Boolean from sqlalchemy.sql import select, func from sqlalchemy.orm import Query from sqlalchemy.ext.hybrid import hybrid_property from sqlalchemy.dialects.postgresql import ARRAY from sqlalchemy_searchable import SearchQueryMixin from sqlalchemy_utils.types import TSVectorType from sqlalchemy_searchable import make_searchable #from flask_dance.consumer.backend.sqla import OAuthConsumerMixin #from flask_login import UserMixin from arguments.database import integer_pk, integer_fk, TimeStamp, rel, FK, C, Model, Table, bref, db_metadata make_searchable(options={'regconfig': 'pg_catalog.german'}) class QuestionQuery(Query, SearchQueryMixin): pass class UserGroup(Model): __tablename__ = "usergroup" id = integer_pk() name = C(Unicode) user_to_usergroup = Table( "user_to_usergroup", db_metadata,
super(RedashSQLAlchemy, self).apply_pool_defaults(app, options) if settings.SQLALCHEMY_DISABLE_POOL: options['poolclass'] = NullPool # Remove options NullPool does not support: options.pop('max_overflow', None) db = RedashSQLAlchemy(session_options={'expire_on_commit': False}) # Make sure the SQLAlchemy mappers are all properly configured first. # This is required by SQLAlchemy-Searchable as it adds DDL listeners # on the configuration phase of models. db.configure_mappers() # listen to a few database events to set up functions, trigger updates # and indexes for the full text search make_searchable(db.metadata, options={'regconfig': 'pg_catalog.simple'}) class SearchBaseQuery(BaseQuery, SearchQueryMixin): """ The SQA query class to use when full text search is wanted. """ @vectorizer(db.Integer) def integer_vectorizer(column): return db.func.cast(column, db.Text) Column = functools.partial(db.Column, nullable=False)
import flask_sqlalchemy import sqlalchemy_searchable from sqlalchemy_utils import TSVectorType db = flask_sqlalchemy.SQLAlchemy() """SQLAlchemy: SQLAlchemy with Flask integration The SQLAlchemy object handles interactions with the application's database. the object provides the db.Model class to create Python abstractions around resources as well as query execution functions """ sqlalchemy_searchable.make_searchable() """Prepares models to be indexable for later searching""" class CustomQuery(flask_sqlalchemy.BaseQuery, sqlalchemy_searchable.SearchQueryMixin): """Mixin adds search method to query for each model""" pass class Base(db.Model): """Abstract Model for defining shared columns between models""" __abstract__ = True query_class = CustomQuery
from sqlalchemy_utils.types.choice import ChoiceType from sqlalchemy_utils.types.url import URLType from little_boxes.key import Key as LittleBoxesKey from activitypub.utils import ap_url from activitypub.vars import DEFAULT_CTX from sqlalchemy.dialects.postgresql import UUID, JSONB from sqlalchemy import text as sa_text from little_boxes import activitypub as ap from urllib.parse import urlparse from authlib.flask.oauth2.sqla import OAuth2ClientMixin, OAuth2AuthorizationCodeMixin, OAuth2TokenMixin import time import uuid from utils.defaults import Reel2bitsDefaults db = SQLAlchemy() make_searchable(db.metadata) # #### Base #### class CaseInsensitiveComparator(Comparator): def __eq__(self, other): return func.lower(self.__clause_element__()) == func.lower(other) class Config(db.Model): __tablename__ = "config" id = db.Column(db.Integer, primary_key=True) app_name = db.Column(db.String(255), default=None) app_description = db.Column(db.Text)
super(RedashSQLAlchemy, self).apply_pool_defaults(app, options) if settings.SQLALCHEMY_DISABLE_POOL: options['poolclass'] = NullPool # Remove options NullPool does not support: options.pop('max_overflow', None) db = RedashSQLAlchemy(session_options={'expire_on_commit': False}) # Make sure the SQLAlchemy mappers are all properly configured first. # This is required by SQLAlchemy-Searchable as it adds DDL listeners # on the configuration phase of models. db.configure_mappers() # listen to a few database events to set up functions, trigger updates # and indexes for the full text search make_searchable(options={'regconfig': 'pg_catalog.simple'}) class SearchBaseQuery(BaseQuery, SearchQueryMixin): """ The SQA query class to use when full text search is wanted. """ @vectorizer(db.Integer) def integer_vectorizer(column): return db.func.cast(column, db.Text) Column = functools.partial(db.Column, nullable=False)
options["pool_pre_ping"] = True if settings.SQLALCHEMY_DISABLE_POOL: options["poolclass"] = NullPool # Remove options NullPool does not support: options.pop("max_overflow", None) db = RedashSQLAlchemy(session_options={"expire_on_commit": False}) # Make sure the SQLAlchemy mappers are all properly configured first. # This is required by SQLAlchemy-Searchable as it adds DDL listeners # on the configuration phase of models. db.configure_mappers() # listen to a few database events to set up functions, trigger updates # and indexes for the full text search make_searchable(options={"regconfig": "pg_catalog.simple"}) class SearchBaseQuery(BaseQuery, SearchQueryMixin): """ The SQA query class to use when full text search is wanted. """ @vectorizer(db.Integer) def integer_vectorizer(column): return db.func.cast(column, db.Text) Column = functools.partial(db.Column, nullable=False)
MANAGE_USERS = 0b1 MANAGE_SEEDS = 0b10 class Anonymous(AnonymousUserMixin): """Anonymous user for flask-login that mocks some attributes of User.""" def __init__(self): self.name = 'Guest' self.permissions = 0 def can(self, permission=None): """Anonymous users can't do squat, always return False!""" return False db = SQLAlchemy() make_searchable(options={'remove_symbols': '@"<>-'}) mail = Mail() login_manager = LoginManager() login_manager.anonymous_user = Anonymous login_manager.session_protection = 'basic' login_manager.login_view = 'auth.login' def create_app(config_name): """Create a Flask instance based on a Config subclass. Args: config_name (str): The config mode we want to load. Options for this are enumerated in the CONFIG dictionary in ``/config.py``.
super(RedashSQLAlchemy, self).apply_pool_defaults(app, options) if settings.SQLALCHEMY_DISABLE_POOL: options['poolclass'] = NullPool db = RedashSQLAlchemy(session_options={ 'expire_on_commit': False }) # Make sure the SQLAlchemy mappers are all properly configured first. # This is required by SQLAlchemy-Searchable as it adds DDL listeners # on the configuration phase of models. db.configure_mappers() # listen to a few database events to set up functions, trigger updates # and indexes for the full text search make_searchable(options={'regconfig': 'pg_catalog.simple'}) class SearchBaseQuery(BaseQuery, SearchQueryMixin): """ The SQA query class to use when full text search is wanted. """ @vectorizer(db.Integer) def integer_vectorizer(column): return db.func.cast(column, db.Text) Column = functools.partial(db.Column, nullable=False)
from flask import current_app from string import split from . import db, BaseNameMixin, BaseMixin from flask_sqlalchemy import SQLAlchemy, BaseQuery from sqlalchemy_searchable import SearchQueryMixin from sqlalchemy_utils.types import TSVectorType from sqlalchemy_searchable import make_searchable __all__ = [ 'ORG_STATUS', 'ORG_STATUS_CHOICES', 'Organization', 'OrganizationInfo', 'OrganizationWork', 'Campaign', 'is_org_name_exists', 'is_org_email_exists' ] make_searchable(options={'remove_symbols': ''}) def is_org_name_exists(name): """Check the username exists in db. :param name `unicode`: name to check in db. """ return Organization.query.filter_by(name=name).first() def is_org_email_exists(email): """Check the email exists in db. :param email `unicode`: org info email to check in db. """
from sqlalchemy.ext.declarative import declarative_base from sqlalchemy_searchable import make_searchable Base = declarative_base() make_searchable(Base.metadata) __all__ = [ 'Answer', 'Base', 'LogEntity', 'Post', 'Question', 'Tag', 'User', 'VoteAnswer', 'VoteQuestion' ] # Model import to expose in core.db.models from core.db.models.log_entity import LogEntity from core.db.models.post import Post from core.db.models.answer import Answer from core.db.models.question import Question from core.db.models.tag import Tag from core.db.models.user import User from core.db.models.vote import VoteAnswer from core.db.models.vote import VoteQuestion
app.config["CACHE_TYPE"] = "redis" app.config["CACHE_REDIS_URL"] = os.environ["REDIS_URL"] app.config["CACHE_DEFAULT_TIMEOUT"] = 60 * 60 # 1 hour app.config["SQLALCHEMY_DATABASE_URI"] = url # remove whitespaces from HTML app.jinja_env.trim_blocks = True app.jinja_env.lstrip_blocks = True cache = Cache(app) db = SQLAlchemy(app) make_searchable(db.metadata, options={"regconfig": "pg_catalog.german"}) class DocumentQuery(BaseQuery, SearchQueryMixin): pass class Document(db.Model): id = db.Column(db.Integer, primary_key=True) year = db.Column(db.Integer) title = db.Column(db.String) jurisdiction = db.Column(db.String) file_url = db.Column(db.String, unique=True) num_pages = db.Column(db.Integer)
import logging from datetime import datetime from sqlalchemy import Table, MetaData, Column, String, ForeignKey, Integer, TIMESTAMP, Enum from sqlalchemy_searchable import make_searchable logger = logging.getLogger(__name__) metadata = MetaData() make_searchable(metadata=metadata)
func, Enum, CheckConstraint) from sqlalchemy.dialects.postgresql import JSONB from sqlalchemy.ext.mutable import MutableDict from sqlalchemy.orm import relationship, backref, object_session from sqlalchemy.ext.associationproxy import association_proxy from sqlalchemy.ext.hybrid import hybrid_property from sqlalchemy_searchable import make_searchable from sqlalchemy_utils.types import TSVectorType, URLType, EmailType from ekklesia_portal.database import Base, integer_pk, C from ekklesia_portal.enums import ArgumentType, EkklesiaUserType, Majority, PropositionStatus, SupporterStatus, VotingType, VotingStatus, \ VotingSystem, VoteByUser from ekklesia_common.utils import cached_property make_searchable(Base.metadata, options={'regconfig': 'pg_catalog.german'}) class Group(Base): __tablename__ = 'groups' id = Column(Integer, Sequence('id_seq', optional=True), primary_key=True) name = Column(String(64), unique=True, nullable=False) is_admin_group = Column(Boolean, nullable=False, server_default='false') members = association_proxy('group_members', 'member') # <-GroupMember-> User class User(Base): __tablename__ = 'users' id = Column(Integer, Sequence('id_seq', optional=True), primary_key=True) name = Column(String(64), unique=True, nullable=False)
from sqlalchemy.ext.declarative import declarative_base # For full-text search on emails from sqlalchemy_utils.types import TSVectorType from sqlalchemy_searchable import make_searchable # creates engine that stores data in local postgres server engine = create_engine('postgresql://*****:*****@localhost/eventador') db_session = scoped_session(sessionmaker(autocommit=False, autoflush=False, bind=engine)) Base = declarative_base() # Allow querying on models directly Base.query = db_session.query_property() # Use sqlalchemy-searchable make_searchable() class Email(Base): __tablename__ = 'emails' id = Column(Integer, primary_key=True) html = Column(Text) text = Column(CIText) domain = Column(Text) author_address = Column(Text) author_name = Column(Text) subject = Column(CIText) start_time = Column(DateTime) end_time = Column(DateTime) location = Column(Text) search_vector = Column(TSVectorType('text', 'subject', 'location'))
def initdb(): db.drop_all() make_searchable() db.configure_mappers() db.create_all()
from sqlalchemy_utils.types import TSVectorType from sqlalchemy_searchable import make_searchable, SearchQueryMixin, search from geoalchemy2 import Geometry, Geography, WKTElement from flask.ext.script import Manager from flask.ext.migrate import Migrate, MigrateCommand app = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://*****:*****@localhost:5432/flask_fts_local' db = SQLAlchemy(app) migrate = Migrate(app, db) manager = Manager(app) manager.add_command('db', MigrateCommand) make_searchable() class DocumentQuery(BaseQuery, SearchQueryMixin): pass class Document(db.Model): query_class = DocumentQuery id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(200), unique=True) description = db.Column(db.Text) search_vector = db.Column(TSVectorType('title', 'description')) def __init__(self, title, description): self.title = title self.description = description
import sqlalchemy_searchable import sqlalchemy.ext.declarative Base: sqlalchemy.ext.declarative.declarative_base = sqlalchemy.ext.declarative.declarative_base( ) """ The declarative base for all tables in Mandarin. """ sqlalchemy_searchable.make_searchable(metadata=Base.metadata) __all__ = ("Base", )