Python create_app Examples

Example #1

File: manage.py Project: aakanshu/data-Collection-backend

import os
import unittest
from flask_migrate import Migrate, MigrateCommand
from flask_script import Manager
from app import blueprint
from app.main import create_app, db

app = create_app(os.getenv("FLASK_ENV") or "dev")
app.register_blueprint(blueprint)
app.app_context().push()

manager = Manager(app)
migrate = Migrate(app, db)
manager.add_command("db", MigrateCommand)


@manager.command
def run():
    app.run()


@manager.command
def test():
    """Runs the unit tests."""
    tests = unittest.TestLoader().discover("app/test", pattern="test*.py")
    result = unittest.TextTestRunner(verbosity=2).run(tests)
    if result.wasSuccessful():
        return 0
    return 1

Example #2

"""
Descrição do arquivo: este é o arquivo principal da API, aqui será feito o gerenciamento do banco de dados
(com os comandos drop_db e create_db, por exemplo) e a execução da API (com o comando run)
Imports deste arquivo:
    Manager: permite criar comandos para usar na linha de comando com o decorator @manager.command
    create_app: cria o app já com o db setado (ver em app/main/__init__.py)
    db: objeto SQAlchemy para o gerenciamento do banco de dados através do Flask
    blueprint: objeto que registra informações a respeito das funções da API (útil para a modularização)
"""

from flask_script import Manager
from app.main import create_app, db
from app import blueprint

app = create_app()
app.register_blueprint(blueprint)

# liga o contexto do 'app' ao contexto atual do script
app.app_context().push()

manager = Manager(app)


@manager.command
def run():
    """Run the API"""
    app.run(debug=True, host='0.0.0.0', port=5000)


@manager.command
def drop_db():

Example #3

File: manage.py Project: AndanteDev/ondo-server

import os 
import unittest

from flask_migrate import Migrate, MigrateCommand
from flask_script import Manager

from app import blueprint
from app.main import create_app,db
from app.main.model import user,blacklist

app = create_app(os.getenv('BOILERPLATE_ENV') or 'dev')
app.register_blueprint(blueprint)

app.app_context().push()

manager = Manager(app)

migrate = Migrate(app,db)

manager.add_command('db',MigrateCommand)

@manager.command
def run():
    app.run(host='0.0.0.0')


@manager.command
def test():
    tests = unittest.TestLoader().discover('app/test',pattern='test*.py')
    result = unittest.TextTestRunner(verbosity=2).run(tests)
    if result.wasSuccessful():

Example #4

File: manage.py Project: ziedbf/test-flask-postgres-redis-spotguide

import os
import unittest

from flask_migrate import Migrate, MigrateCommand

from app import blueprint
from app.main import create_app, db
from app.main.model import user, blacklist

app = create_app(os.getenv('FLASK_ENV') or 'development')
app.register_blueprint(blueprint)

app.app_context().push()

migrate = Migrate(app, db)

@app.cli.command("run")
def run():
    app.run()


@app.cli.command("test")
def test():
    """Runs the unit tests."""
    tests = unittest.TestLoader().discover('app/test', pattern='test*.py')
    result = unittest.TextTestRunner(verbosity=2).run(tests)
    if result.wasSuccessful():
        return 0
    return 1

if __name__ == '__main__':

Example #5

def main():
    """PGSync Demo Webserver."""
    app = create_app()
    web.run_app(app)

Example #6

File: test_person_api.py Project: Jmwas/workshop-content-archive

def test_get_all_api():
    app = create_app()
    with app.test_client() as c:
        rv = c.get('/person/')
        assert rv.status_code == 200

Example #7

File: manage.py Project: dywsGD/Personal-Data-Protection-Service

import os
import unittest

from flask_migrate import Migrate, MigrateCommand
from flask_script import Manager

from app.main import create_app, db

from app import blueprint

app = create_app(os.getenv('BOILERPLATE_ENV') or 'prod')

app.register_blueprint(blueprint)

app.app_context().push()

manager = Manager(app)

migrate = Migrate(app, db)

manager.add_command('db', MigrateCommand)


@app.after_request
def after_request(response):
    """
    Allows response resources to be shared with the given source.
    """
    response.headers.add('Access-Control-Allow-Origin', '*')
    return response

Example #8

File: run.py Project: yorjaggy/python_projects

import os

from app import blueprint
from app.main import create_app

application = create_app(os.getenv('EXEC_ENV') or 'dev')
application.register_blueprint(blueprint)
application.app_context().push()

if __name__ == '__main__':
    application.run()

Example #9

from app.main.message import MessageStoreError
from db import init_db
from flask import g, request, session, make_response, jsonify
from app.main import create_app
from app.logic import message_service as ms
from app.logic import user_service as us
import os
import tempfile

app = create_app(__name__)
app.secret_key = b'_5#y2L"F4Q8z\n\xec]/'


def create_db_file():
    """

    :rtype: str
    :return:
    """
    temp_db_path = tempfile.NamedTemporaryFile().name
    app.logger.info('Database path: {0}'.format(temp_db_path))
    return temp_db_path


db_path = create_db_file()
app.config['DATABASE'] = db_path
with app.app_context():
    init_db()


# Post Create message

Example #10

File: manage.py Project: SimChang/Flask-API-Events

from flask_script import Manager

from app import blueprint
from app.main import create_app, db

app = create_app('prod')
app.register_blueprint(blueprint)

app.app_context().push()

manager = Manager(app)


@manager.command
def run():
    app.run()


if __name__ == '__main__':
    manager.run()

Example #11

File: manage.py Project: ArielVilleda/docker-flask-postgres

import os
import unittest
from flask_migrate import Migrate, MigrateCommand
from flask_script import Manager

from app.main import (create_app, db)  # importing our app
from app import blueprint  # importing services
from app.main.models import *  # importing all our db models for migrations

app = create_app(os.getenv('FLASK_ENV') or 'dev')  # dev, prod or test
app.register_blueprint(blueprint)  # registering in Flask application instance
app.app_context().push()
# Instantiates the manager and migrate classes
# by passing the app instance to their respective
# constructors
manager = Manager(app)
migrate = Migrate(app, db)
# Exposing all the database migration commands
# through Flask-Script
manager.add_command('db', MigrateCommand)


@manager.command
def run():
    app.run(host='0.0.0.0', port=5000)  # host exposed (works with docker)


@manager.command
def test():
    """Runs the unit tests"""
    tests = unittest.TestLoader().discover('app/test', pattern='test*.py')

Example #12

def client():
    _client = TestClient(create_app())
    yield _client

Example #13

import os
import unittest
from flask_script import Manager
from app.main import create_app
from app.main.controller.company_controller import CompanyService
from app.main.controller.member_controller import MemberService
from app.main.controller.team_controller import TeamService

app = create_app(os.getenv('ENV_STATE'))

app.app_context().push()
manager = Manager(app)

app.register_blueprint(CompanyService)
app.register_blueprint(MemberService)
app.register_blueprint(TeamService)


@manager.command
def run():
    app.run(port=5000, host="0.0.0.0")


@manager.command
def test():
    """Runs the unit tests."""
    tests = unittest.TestLoader().discover('app/test', pattern='test*.py')
    result = unittest.TextTestRunner(verbosity=2).run(tests)
    if result.wasSuccessful():
        return 0
    return 1

Example #14

import datetime

from flask import jsonify

from flask_migrate import Migrate, MigrateCommand
from flask_script import Manager

from app import blueprint
from app.main import create_app, db, socketio
from app.main.model import user, message, game, room, game_user, room_user, follower_user
from app.main.model.game import Game
from app.main.model.user import User

from flask_cors import CORS

app = create_app(os.getenv('APP_ENV') or 'development')


def init_db():
    # create new game when run app
    battle_ship = Game.query.filter_by(public_id="battle_ship").first()

    if battle_ship is None:
        battle_ship = Game(public_id="battle_ship",
                           name="Battle Ship",
                           num_players=2)
        db.session.add(battle_ship)
        db.session.commit()

    # create admin account when run app
    admin = User.query.filter_by(public_id="admin").first()

Example #15

File: start_server.py Project: adrielklein/anagram-server

import os

from app.main import create_app


def _get_words():
    result = []
    with open('words.txt') as file:
        for word in file:
            result.append(word.strip())
    return result


PORT = 5000
if __name__ == '__main__':
    port = int(os.environ.get('PORT', PORT))
    app = create_app(_get_words())
    app.run(host='0.0.0.0', port=port)

Example #16

File: manage.py Project: tranhieu956230/flask-bp

import os
import unittest
from flask_migrate import Migrate, MigrateCommand
from flask_script import Manager

from app.main import create_app, db
from app.main.model import user
from app.main.model import blacklist
from app import blueprint

app = create_app(os.getenv("ENV"))

app.register_blueprint(blueprint)

app.app_context().push()

manager = Manager(app)

migrate = Migrate(app, db)

manager.add_command("db", MigrateCommand)


@manager.command
def run():
    app.run()


@manager.command
def test():
    tests = unittest.TestLoader().discover("app/test", pattern="test*.py")

Example #17

File: manage.py Project: diasclyde92/attendanceManagement_API

import os
import unittest
from app import blueprint
from flask_cors import CORS
from app.main import create_app
from flask_script import Manager
from flask_jwt_extended import JWTManager

app = create_app(os.getenv('ENV') or 'DEV', is_test=False)
# app = create_app(os.getenv('ENV') or 'TEST', is_test=True)
app.register_blueprint(blueprint)
app.app_context().push()
jwt = JWTManager(app)
manager = Manager(app)
# CORS(app)
# app.run()
CORS(app, resources={r"/*": {"origins": "*"}})

@manager.command
def test():
    """Runs the unit tests."""
    tests = unittest.TestLoader().discover('app/test', pattern='test*.py')
    result = unittest.TextTestRunner(verbosity=2).run(tests)
    if result.wasSuccessful():
        return 0
    return 1
# test()


if __name__ == '__main__':
    app.run(debug=True)

Example #18

File: test_person.py Project: koitoror/workshop-content-archive

def test_get_api():
    app = create_app()
    client = app.test_client()
    res = client.get('/person/')
    assert res.status_code == 200

Example #19

File: test_person_api.py Project: Jmwas/workshop-content-archive

def test_get_one_api(mock_ps):
    app = create_app()
    mock_ps.return_value.retrieve_one.return_value = Person(name='wrong', primary_email='ncwk')
    with app.test_client() as c:
        rv = c.get('/person/123')
        assert rv.status_code == 200

Example #20

File: test_person.py Project: koitoror/workshop-content-archive

def test_create_api():
    app = create_app()
    client = app.test_client()
    res = client.post('/person/', json={"name": "gandhi", "email": "*****@*****.**"})
    assert res.status_code == 202

Example #21

File: test_app.py Project: adrielklein/anagram-server

def test_when_app_is_created_then_corpus_is_populated_with_english_dictionary():
    app = create_app(['dear', 'dare'])
    with app.test_client() as test_client:
        response = test_client.get('/anagrams/dear.json')
        response_string = response.get_data().decode()
        assert ['dare'] == sorted(json.loads(response_string)['anagrams'])

Example #22

File: chesstify.py Project: Chesstify/chesstify-backend

import os

from app.main import config
from app.main import create_app

config = config.ProdConfig if "prod" == os.getenv(
    "FLASK_ENV") else config.DevConfig

app = create_app(config)

if __name__ == "__main__":
    app.run(host='0.0.0.0')

Example #23

File: manage.py Project: antidoc/flask_api

import os
import unittest

from flask_migrate import Migrate, MigrateCommand
from flask_script import Manager

from app.main import create_app, db
from app.main.model import user, blacklist
from app import blueprint

app = create_app(os.getenv('APP_ENV') or 'dev')
app.register_blueprint(blueprint)
app.app_context().push()
manager = Manager(app)
migrate = Migrate(app, db)
manager.add_command('db', MigrateCommand)

app.app_context().push()

@manager.command
def run():
    app.run()

@manager.command
def test():
    tests = unittest.TestLoader().discover('app/test', pattern='test*.py')
    result = unittest.TextTestRunner(verbosity=2).run(tests)
    if result.wasSuccessful():
        return 0
    return 1

Example #24

File: manage.py Project: rvsgltkn/Flask-Bookstore-WebProject

import os
import unittest

from flask_migrate import Migrate, MigrateCommand
from flask_script import Manager

from app import blueprint
from app.main import create_app, db
from app.main.model import user, book, blacklist

app = create_app(os.getenv('FLASKBOOKSTORE_ENV') or 'dev')
app.register_blueprint(blueprint)
app.app_context().push()

manager = Manager(app)

migrate = Migrate(app, db)

manager.add_command('db', MigrateCommand)


@manager.command
def run():
    app.run()


@manager.command
def test():
    tests = unittest.TestLoader().discover('app/test', pattern='test*.py')
    result = unittest.TextTestRunner(verbosity=2).run(tests)
    if result.wasSuccessful():

Example #25

async def test_method_not_allowed(aiohttp_client):

    client = await aiohttp_client(create_app())

    res = await client.post("/logout", data={"some": "data"})
    assert res.status == 405

Example #26

File: manage.py Project: cbrown24/overdraft-irate-analyzer

import os

from flask_script import Manager

from app import blueprint
import app
from app.main import create_app

app = create_app(os.getenv('UPDRAFT_ENV') or 'dev')
app.register_blueprint(blueprint)

app.app_context().push()

manager = Manager(app)


@manager.command
def run():
    app.run()


if __name__ == '__main__':
    manager.run()

Example #27

File: execute.py Project: sohailchd/tagup_api

import os
import unittest

from flask_migrate import Migrate, MigrateCommand
from flask_script import Manager

from app import blueprint
from app.main import create_app, db
from app.main.model import user, blacklist

app = create_app(os.getenv('CONFIG') or 'dev')
app.register_blueprint(blueprint)
app.app_context().push()

manager = Manager(app)
migrate = Migrate(app, db)
manager.add_command('db', MigrateCommand)


@manager.command
def setupdb():
    db.create_all()
    db.session.commit()


@manager.command
def run():
    if os.getenv('CONFIG') == "dev":
        app.config.from_object('app.main.config.DevelopmentConfig')
    else:
        app.config.from_object('app.main.config.ProductionConfig')

Example #28

File: manage.py Project: rohitjain00/Recipe-App

import os
import unittest

from flask_script import Manager

from app.main import create_app
from app import blueprint

env = os.getenv('BOILERPLATE_ENV') or 'dev'
app = create_app(env)
app.register_blueprint(blueprint)

app.app_context().push()

manager = Manager(app)


@manager.command
def run():
    app.run()


@manager.command
def test():
    """Runs the unit tests."""
    tests = unittest.TestLoader().discover('app/test', pattern='test*.py')
    result = unittest.TextTestRunner(verbosity=2).run(tests)
    if result.wasSuccessful():
        return 0
    return 1

Example #29

import os
import unittest

from flask_migrate import Migrate, MigrateCommand
from flask_script import Manager

from app.main import create_app, db
from app.main.model import user
from app import blueprint

app = create_app(os.getenv('TODO_ENV') or 'dev')
app.register_blueprint(blueprint)

app.app_context().push()

manager = Manager(app)

migrate = Migrate(app, db)

manager.add_command('db', MigrateCommand)


@manager.command
def run():
    app.run(host='0.0.0.0', port=8080)


@manager.command
def test():
    """Runs the unit tests."""
    tests = unittest.TestLoader().discover('app/test', pattern='test*.py')

Example #30

File: test_person_api.py Project: Jmwas/workshop-content-archive

def test_post_api(user):
    app = create_app()
    with app.test_client() as c:
        rv = c.post('/person/', json=user)
        assert rv.status_code == 202

Example #31

File: manage.py Project: cjw0515/flask-todo-api

import os
import unittest
import pymysql

pymysql.install_as_MySQLdb()

from flask_migrate import Migrate, MigrateCommand
from flask_script import Manager
from app.main.model import todo

from app.main import create_app, db
from app import blueprint
from flask_cors import CORS

app = create_app('dev')
CORS(app)
app.register_blueprint(blueprint)
app.app_context().push()

# flask_script : https://flask-script.readthedocs.io/en/latest/
manager = Manager(app)
# flask_migrate : https://flask-migrate.readthedocs.io/en/latest/
migrate = Migrate(app, db)

manager.add_command('db', MigrateCommand)

@manager.command
def run():
    app.run()

@manager.command

Example #32

File: test_person_api.py Project: Jmwas/workshop-content-archive

def test_post_api_in_valid_payload(user):
    app = create_app()
    with app.test_client() as c:
        rv = c.post('/person/', json={'xyz': 123})
        assert rv.status_code == 422

Example #33

File: conftest.py Project: adrielklein/anagram-server

def app():
    return create_app([])

Example #34

File: wsgi.py Project: RowlandMtetezi/maximilianfellner.eu

# -*- coding: utf-8 -*-

from app.main import create_app

application = None

# Create application object for debugging or production.
# http://pythonhosted.org/Flask-SQLAlchemy/contexts.html
if __name__ == '__main__':
    from flask.ext.script import Manager
    from flask.ext.assets import ManageAssets
    from flask.ext.migrate import Migrate, MigrateCommand
    from app.shared.models import db
    from app.assets import assets_env
    from app.util import GenerateSitemap

    application = create_app(debug=True)
    application.test_request_context().push()

    # This 'migrate' instance is required by MigrateCommand.
    migrate = Migrate(application, db)
    manager = Manager(application)
    manager.add_command('db', MigrateCommand)
    manager.add_command('assets', ManageAssets(assets_env))
    manager.add_command('sitemap', GenerateSitemap(application.static_folder))
    manager.run()
else:
    application = create_app(debug=False)