def create_app(env_name):
"""
Create app
"""
# app initiliazation
app = Flask(__name__)
app.config.from_object(app_config[env_name])
db.init_app(app)
app.register_blueprint(job_blueprint, url_prefix='/modulelog')
app.register_blueprint(jobid_blueprint, url_prefix='/modulelogid')
@app.route('/', methods=['GET'])
def index():
"""
example endpoint
"""
return 'Congratulations! Your first endpoint is working'
return app
def setup_app(app):
# cria as tabelas se elas nao existirem ainda
@app.before_first_request
def create_tables():
db.create_all()
#inicia base de dados
db.init_app(app)
#congirura blueprint para as rotas com namespace
blueprint = Blueprint('api', __name__, url_prefix='/api')
#adiciona blueprint no app
api.init_app(blueprint)
#chama a funcao que vai congigurar as API
init_config(app)
#adiciona namespaces to blueprint
api.add_namespace(author_namespace)
api.add_namespace(post_namespace)
#registra blueprint
app.register_blueprint(blueprint, url_prefix='')
if __name__ == "__main__":
app.run(debug=True, host='0.0.0.0')
def create_app(config_file='config.py'):
app = Flask(__name__)
app.config.from_pyfile(config_file)
db.init_app(app)
# Blueprints
app.register_blueprint(auth.bp)
app.register_blueprint(dashboard.bp)
# Index page
@app.route('/')
def index():
return redirect(url_for('auth.sign_in'))
# DB Creation
from src.models import users
@app.route('/create-db')
def create_db():
db.create_all()
return "DB Created!"
return app
def create_app():
flask_app = Flask(__name__)
flask_app.config['SQLALCHEMY_DATABASE_URI'] = config.DATABASE_CONNECTION_URI
flask_app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
flask_app.app_context().push()
db.init_app(flask_app)
db.create_all()
return flask_app
def create_simple_app():
app = Flask(__name__)
logging.basicConfig(format="%(asctime)s %(levelname)s [%(module)s %(lineno)d] %(message)s",
level=app.config['LOG_LEVEL'])
app.config.from_envvar("CONFIG")
db.init_app(app)
return app
def create_app():
app = Flask(__name__)
config_app(app)
db.init_app(app)
api = Api(app)
create_api(api)
return app
def setUp(self):
app.config['TESTING'] = True
app.config['DEBUG'] = False
app.config['SQLALCHEMY_DATABASE_URI'] = "sqlite:///{}".format(
os.path.join(project_dir, TEST_DB))
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['PAGE_SIZE'] = 10
db.init_app(app)
self.app = app.test_client()
self.assertEqual(app.debug, False)
def create_app():
"""This is an application factory"""
app = Flask(__name__)
app.config.from_object("src.config.BaseConfig")
CORS(app)
db.init_app(app)
jwt.init_app(app)
app.register_blueprint(api, url_prefix="/api")
return app
def create_app(env_name):
# Initialize app
app = Flask(__name__)
CORS(app)
app.config.from_object(app_config[env_name])
db.init_app(app)
app.register_blueprint(api_bp, url_prefix='/api')
return app
def create_app(env):
app = Flask(__name__)
from config import app_config
app.config.from_object(app_config[env])
from src import api_bp
app.register_blueprint(api_bp)
from src.models import db
db.init_app(app)
return app
def setUpClass(cls):
from src.app import application
from src.models import db
from src import settings
application.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql+psycopg2://{0:s}:{1:s}@{2:s}:{3:d}/{4:s}'.format(
settings.DB_USER, settings.DB_PASS, settings.DB_HOST, settings.DB_PORT, settings.DB_NAME)
application.config['TESTING'] = True
db.init_app(application)
db.create_all(app=application)
cls.test_app = application.test_client()
cls.db = db
cls.application = application
def setUp(self):
#create app
self.app = create_test_app()
#init with app test1
db.init_app(self.app)
#bind context
self.app.app_context().push()
#create instance for tests
self.instance = Inventory(**{
"value" : "+55 86 90000-0000",
"monthyPrice" : 15,
"currency" : "R$",
"setupPrice" : 25,
})
self.instance.save()
def create_app(config_object):
"""Application factory function"""
app = Flask(__name__, static_folder=None, template_folder=None)
app.config.from_object(config_object)
app.register_blueprint(views)
app.register_blueprint(recycles)
app.register_blueprint(users)
db.init_app(app)
Migrate(app, db)
bcrypt.init_app(app)
jwt_manager.init_app(app)
return app
def create_app():
"""
Create a instance of Flask App
"""
app = Flask(__name__)
#set config
app.config.from_object('config')
#start db
db.init_app(app)
#set blueprints
app.register_blueprint(inventory_blueprint, url_prefix='/api/v1/inventory')
#handlers
app.register_error_handler(500, handle_internal_server_error)
return app
def create_app(config):
app = Flask(__name__)
app.config.from_object(config)
# DO NOT deploy this application to a production environment without first adjusting
# the CORS settings
CORS(app)
# Initialize extensions
db.init_app(app)
migrate.init_app(app, db)
# Initialize blueprints
app.register_blueprint(root_blueprint)
app.register_blueprint(campaign_blueprint)
return app
def create_app():
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get('DATABASE_URL')
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
with app.app_context():
db.init_app(app)
migrate.init_app(app, db)
app.register_blueprint(errors.bp)
app.register_blueprint(actors.bp)
app.register_blueprint(movies.bp)
@app.route('/')
@app.route('/api')
def index():
return jsonify({'message': 'Welcome to the casting agency API'})
return app
def setUpClass(self):
"""Excuted in the beginning of the test, the target of this test is that all tests run in order at once """
"""Define test variables and initialize src."""
self.app = create_app()
self.client = self.app.test_client
self.database_name = "casting_agency_test"
self.database_path = "postgresql://*****:*****@{}/{}".format('localhost:5432', self.database_name)
# binds the src to the current context
self.new_actor = {"name": "Markos24", "age": 23, "gender": "Male"}
self.new_movie = {"title": "the real stuff", "release_date": "08/20/2020"}
setup_db(self.app, self.database_path)
with self.app.app_context():
db.init_app(self.app)
# create all tables
db.drop_all()
db.create_all()
def setUp(self):
app.config['TESTING'] = True
app.config['WTF_CSRF_ENABLED'] = False
app.config['DEBUG'] = False
db.init_app(app)
with app.app_context():
db.create_all()
example_user = User(id=1,
email="*****@*****.**",
username="******")
example_user.set_password("111")
db.session.merge(example_user)
db.session.commit()
self.app = app.test_client()
def create_app(env_name):
app = Flask(__name__)
app.config.from_object(app_config[env_name])
db.init_app(app)
app.register_blueprint(question_blueprnt, url_prefix='/api/v1/questions')
app.register_blueprint(response_blueprint, url_prefix='/api/v1/responses')
@app.route('/', methods=['GET'])
def index():
# question = QuestionModel.get_all_question()
# # testing endpoint
# req_data = request.get_json()
return 'endpoint is working'
return app
def create_app(env_name):
app = Flask(__name__)
app.config.from_object(app_config[env_name])
bcrypt.init_app(app)
db.init_app(app)
app.register_blueprint(user_blueprint, url_prefix='/garden/v1/users')
app.register_blueprint(device_blueprint, url_prefix='/garden/v1/devices')
docs = FlaskApiSpec(app)
docs.register(devices.create, blueprint=device_blueprint)
@app.route('/', methods=['GET'])
def index():
return 'blah blah blah'
return app
def create_app():
# create flask app
app = Flask(__name__)
app.config.from_envvar("CONFIG")
# allow any origin for testing and development environments
if app.config["TESTING"] or app.config["DEVELOPMENT"]:
CORS(app)
# configure logger
logging.basicConfig(format="%(asctime)s %(levelname)s [%(module)s %(lineno)d] %(message)s", level=app.config['LOG_LEVEL'])
# init sqlalchemy db connection
db.init_app(app)
# db.create_all()
app.register_blueprint(auth, url_prefix='/auth')
app.register_blueprint(jokes, url_prefix='/jokes')
return app
def build_api():
api_build = Flask(__name__)
CORS(api_build, supports_credentials=True)
api_build.url_map.strict_slashes = False # critical to come before build_blueprints
if api_build.config['ENV'] == 'development':
print(bcolours.OKGREEN + "\n %% DEV %% \n" + bcolours.ENDC)
api_build.config.from_object('config.DevelopmentConfig')
elif api_build.config['ENV'] == 'testing':
print(bcolours.WARNING + "\n %% TEST %% \n" + bcolours.ENDC)
api_build.config.from_object('config.TestingConfig')
elif api_build.config['ENV'] == 'production':
print(bcolours.OKBLUE + "\n %% PROD %% \n" + bcolours.ENDC)
api_build.config.from_object('config.ProductionConfig')
else:
raise RuntimeError('CONFIGURATION STARTUP ERROR')
db.init_app(api_build)
build_blueprints(api_build)
build_jwt_helpers(JWTManager(api_build))
Migrate(api_build, db)
return api_build
def create_app(env_name):
"""
Create the app
"""
# initialize the app
app = Flask(__name__)
app.config.from_object(app_config[env_name])
app.register_blueprint(api_v1)
app.register_blueprint(user_api)
# initialize bcrypt
bcrypt.init_app(app)
# initialize the database
db.init_app(app)
# # initialize migration scripts
# Migrate(app, db)
return app
def create_app(test_config=None):
app = Flask(__name__, instance_relative_config=True)
app.config.from_mapping(SECRET_KEY='sridhar')
if test_config is None:
app.config.from_pyfile('config.py', silent=True)
else:
app.config.from_mapping(test_config)
@app.route('/hello')
def hello():
return "Hello World"
from src.models import db
from src.controllers import auth
db.init_app(app)
app.register_blueprint(auth.auth_blueprint)
from src.controllers import posts
app.register_blueprint(posts.bp)
app.add_url_rule('/', endpoint="index")
CORS(app)
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(app_config[config_name])
app.register_blueprint(product_api, url_prefix="/api")
app.register_blueprint(variants_api, url_prefix="/api")
app.register_blueprint(variants_property_api, url_prefix="/api")
app.register_blueprint(branch_api, url_prefix="/api")
app.register_blueprint(user_api, url_prefix="/api")
db.init_app(app)
bcrypt.init_app(app)
@app.route('/')
def hello_world():
return 'Hello, World!'
migrate = Migrate(app, db)
from src.models.branch_model import Branch
from src.models.product_model import Product
from src.models.variants_model import Variants
from src.models.variants_property_model import VariantsProperty
return app
def create_app():
app = Flask(__name__)
app.config.from_pyfile(SETTINGS_FILE)
@app.before_first_request
def create_db():
db.create_all()
if not os.getenv('SECRET'):
raise EnvironmentError(
'The secret key is required. Pls add to the environment in the variable "SECRET".'
)
if not os.getenv('SQLALCHEMY_DATABASE_URI'):
raise EnvironmentError(
'The environment variable SQLALCHEMY_DATABASE_URI is required.')
app.config['SQLALCHEMY_DATABASE_URI'] = os.getenv(
'SQLALCHEMY_DATABASE_URI')
app.secret_key = os.getenv('SECRET')
db.init_app(app)
api.init_app(app)
JWTManager(app)
return app
from flask import Flask
from flask_migrate import Migrate
from src.models import db, Usuario, Producto, Tienda, Suscripcion
import json
import os
# iniciar la aplicación
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get('DB_CONNECTION_STRING')
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# iniciar la sesión de sqlalchemy - mysql
MIGRATE = Migrate(app, db)
db.init_app(app)
with app.app_context():
# cargar data de un archivo .json con la información de los objetos a crear
with open("./baseline_data.json") as data_file:
data = json.load(data_file)
# crear esos objetos y guardar en bdd
for tienda in data["tienda"]:
nuevo_tienda = Tienda.nuevo(
tienda["nombre_tienda"], tienda["correo_tienda"],
tienda["telefono_tienda"], tienda["foto_tienda"],
tienda["facebook_tienda"], tienda["instagram_tienda"],
tienda["twitter_tienda"], tienda["zona_general"],
tienda["zona_uno"], tienda["zona_dos"], tienda["zona_tres"])
db.session.add(nuevo_tienda)
db.session.commit()
for producto in data["producto"]:
nuevo_producto = Producto.nuevo(
producto["titulo"], producto["foto"], producto["descripcion"],
def create_app(env_name):
app = Flask(__name__, static_url_path='')
CORS(app, support_credentials=True)
#app.config.from_object(app_config[env_name])
app.config[
"SQLALCHEMY_DATABASE_URI"] = "postgresql://*****:*****@database-1.cvbo289m1v6g.us-west-2.rds.amazonaws.com:5432/postgres"
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
app.config["DEBUG"] = True
db.init_app(app)
@app.route('/api/', methods=['GET'])
def index():
return 'This index endpoint is working!'
@app.route('/api/ingredients')
@cross_origin(supports_credentials=True)
def get_all_ingredients():
ingredients_schema = IngredientSchema(many=True)
return jsonify(
ingredients_schema.dump(Ingredient.query.limit(10).all()))
@app.route('/api/ingredient/<sought_ingredient>/<y>')
@cross_origin(supports_credentials=True)
def get_ingredient_by_name(sought_ingredient, y):
ingredient_schema = IngredientSchema(many=True)
found_ingredient = Ingredient.query.filter_by(name=sought_ingredient)
if found_ingredient is None:
response = {'message': 'Sorry. Ingredient does not exist.'}
return jsonify(response), 404
result = ingredient_schema.dump(found_ingredient)
result_call = result[0]["name"]
sql = text(
f"select i.id as source_id, i.name as source_name, t.id as target_id, t.name as target, s.strength from ingredients i, similarities s, ingredients t where t.id=s.target and i.id=s.source and i.name='{result_call}' and s.strength>{y} and i.id!=t.id order by s.strength desc"
)
sims = db.engine.execute(sql)
print(sims)
sim_results = jsonify({'ing_data': [dict(row) for row in sims]})
print('this is the ing json', sim_results)
return sim_results
@app.route('/api/recipes/')
@cross_origin(supports_credentials=True)
def get_matching_recipes():
schema = RawDataSchema(many=True)
array = request.args.getlist("ing")
num = len(array)
string = ', '.join(str(e) for e in array)
sql = text(
f"select r.* from (select max(recipe_id), count(recipe_id) from ingredients i, recipe_ingredients ri where i.id=ri.ingredient_id and i.id in ({string} ) group by recipe_id having count(recipe_id)={num}) as foo, raw_data r where foo.max=r.id;"
)
recipes = db.engine.execute(sql)
if recipes is None:
return []
print(recipes)
recipes_to_send = jsonify({'rec_data': [dict(row) for row in recipes]})
print('this is the rec json', recipes_to_send)
return recipes_to_send
# return jsonify(schema.dump())
@app.route('/api/recipe/<id>')
@cross_origin(supports_credentials=True)
def get_recipe_by_id(id):
schema = RawDataSchema(many=False)
# recipe = RawDataModel.query.get(id)
# print(recipe.allData)
return jsonify(schema.dump(RawDataModel.query.get(id)))
@app.route('/api/json/<path:path>')
@cross_origin(supports_credentials=True)
def get_json(path):
return send_from_directory('data', path)
# if __name__ == "__main__":
# app.run(host='0.0.0.0', port=8000, debug=True)
return app
#!/usr/local/bin/python3
"""
RESTful API
"""
import logging
import connexion
from src import SWAGGER_PATH
from src import settings
from src.config import log
from src.models import db
log.init()
logger = logging.getLogger('app')
logger.info('Path of swagger file: {path}'.format(path=SWAGGER_PATH))
app = connexion.App(__name__, specification_dir=SWAGGER_PATH)
app.add_api('employee.yaml')
application = app.app
application.config[
'SQLALCHEMY_DATABASE_URI'] = 'postgresql+psycopg2://{0:s}:{1:s}@{2:s}:{3:d}/{4:s}'.format(
settings.DB_USER, settings.DB_PASS, settings.DB_HOST, settings.DB_PORT,
settings.DB_NAME)
application.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db.init_app(application)
db.create_all(app=application)
if __name__ == '__main__':
application.run(port=settings.APP_PORT)
def setUpClass(cls):
app = create_app('test')
app.app_context().push()
db.init_app(app)
cls.request = app.test_client()
from flask import Flask
from src.models import db
from src.assets_loader import assets
from src.api import api
app = Flask(__name__, instance_relative_config=True)
app.config.from_object('config.BaseConfiguration')
app.config.from_pyfile('config.py', silent=True)
api.init_app(app)
assets.init_app(app)
db.init_app(app)
import src.controllers
