from app import api app = api.create_app()
"""
wsgi
~~~~
web wsgi module
"""
# auto Alembic
import sys
from os.path import dirname, abspath
sys.path.append(dirname(dirname(abspath(__file__))))
from subprocess import Popen, PIPE, STDOUT
from werkzeug.serving import run_simple
from werkzeug.wsgi import DispatcherMiddleware
from app import api, frontend, restless
application = DispatcherMiddleware(frontend.create_app(), {
'/api': api.create_app(),
'/restless': restless.create_app()
})
if __name__ == "__main__":
# Preform Database Upgrades Automatically :)
command = 'alembic upgrade head'
Popen(command, shell=True)
run_simple('0.0.0.0', 9400, application, use_reloader=True,
use_debugger=True)
from werkzeug.serving import run_simple
from werkzeug.wsgi import DispatcherMiddleware
#imports apps
from app import admin,api
#create main app
admin_app = admin.create_app()
api = api.create_app()
from app.api.database import module as mongo_api
from app.api.local import module as local_api
api.register_blueprint(mongo_api)
api.register_blueprint(local_api)
application = DispatcherMiddleware(admin_app,{
'/api':api
})
if __name__ == '__main__':
run_simple('127.0.0.1',4444,application,use_reloader=True,use_debugger=True)
import os
from app.api import create_app
config_name = os.getenv('APP_SETTINGS') or 'development'
app = create_app(config_name)
from werkzeug.serving import run_simple
from werkzeug.wsgi import DispatcherMiddleware
#imports apps
from app import admin, api
#create main app
admin_app = admin.create_app()
api = api.create_app()
from app.api.database import module as mongo_api
from app.api.local import module as local_api
api.register_blueprint(mongo_api)
api.register_blueprint(local_api)
application = DispatcherMiddleware(admin_app, {'/api': api})
if __name__ == '__main__':
run_simple('127.0.0.1',
4444,
application,
use_reloader=True,
use_debugger=True)
import unittest
from flask_migrate import Migrate, MigrateCommand
from flask_script import Manager
from app import blueprint
from app.api import create_app, db
app = create_app('desenv')
app.register_blueprint(blueprint)
app.app_context().push()
gerente = Manager(app)
migrate = Migrate(app, db)
gerente.add_command('db', MigrateCommand)
@gerente.command
def run():
app.run()
@gerente.command
def test():
"""
Roda testes de unidade.
"""
testes = unittest.TestLoader().discover('app/test', 'teste*.py')
resultado = unittest.TextTestRunner(verbosity=2).run(testes)
if resultado.wasSuccessful():
return 0
# -*- coding: utf-8 -*-
"""
runserver
~~~~
riskmanager wsgi module
"""
from werkzeug.serving import run_simple
from werkzeug.wsgi import DispatcherMiddleware
from app import api, frontend
application = DispatcherMiddleware(frontend.create_app(),
{'/api/v1': api.create_app()})
if __name__ == "__main__":
run_simple('0.0.0.0',
5000,
application,
use_reloader=True,
use_debugger=True)
sys.path.insert(0, '/home/flask/Luyasi-Flask')
# from app import thld_web
from app import api
from thld import setting
reload(sys)
sys.setdefaultencoding('utf-8')
# from flask.ext.security import forms
# web应用
# frontend_app = thld_web.create_app(settings_override=setting)
# api接口
api_app = api.create_app(settings_override=setting)
# apps = [{'api_id': 'app0001', 'app_key': '12345678', 'app_type': 'web'}]
#
#
# @api_app.before_first_request
# def api_gateway():
# api_id = request.args.get('api_id')
# print api_id
# return js
# 可以分发给不同的app
# application = DispatcherMiddleware(frontend)
# application = DispatcherMiddleware(api_app)
application = DispatcherMiddleware(api_app, {'/api': api_app})
default=200)
parser.add_argument("-v",
"--verbose",
help="allow verbosity",
action="store_true")
args = parser.parse_args()
def create_history(pair: str, timeframe: str, limit: int, verbose: bool):
series: Series = get_candles(pair=pair, timeframe=timeframe, limit=limit)
print(
f"Creating {series.pair}{series.timeframe}. Size: {series.close.size}")
atoms = Atomics(series)
atoms.remake(verbose)
if args.pair and args.timeframe:
verbose = True if args.verbose else False
# Setup proper config
Config = resolve_config()
# Create app
app = create_app(Config)
# Generate history
with app.app_context():
create_history(pair=args.pair,
timeframe=args.timeframe,
limit=args.limit,
verbose=verbose)
exit(0)
import os
from app.api import create_app
# config_name = os.getenv('APP_SETTING')
app = create_app('development')
if __name__ == '__main__':
port = int(os.environ.get('PORT', 5000))
app.run(host='0.0.0.0', port=port)
import uvicorn
# from app.config import config
from app.api import create_app
if __name__ == '__main__':
application = create_app()
uvicorn.run(application,
host='0.0.0.0',
port=8000,
log_level="info",
loop="asyncio")
"""
Restful Entry
"""
import os
from flask import Flask
from app.api import create_app
app = create_app(os.getenv('FLASK_CONFIG') or 'dev_api')
if __name__ == '__main__':
app.run()
def setUp(self):
self._client = create_app().test_client()
def client():
"""Flask test client with Google Cloud logging client removed."""
app = api.create_app()
return app.test_client()
from __future__ import with_statement from alembic import context from sqlalchemy import engine_from_config, pool from logging.config import fileConfig import sys from os.path import dirname, abspath sys.path.append(dirname(dirname(abspath(__file__)))) from app.models import * from app.core import db from app.api import create_app app = create_app() # this is the Alembic Config object, which provides # access to the values within the .ini file in use. config = context.config # Interpret the config file for Python logging. # This line sets up loggers basically. fileConfig(config.config_file_name) # add your model's MetaData object here # for 'autogenerate' support # from myapp import mymodel # target_metadata = mymodel.Base.metadata target_metadata = None # other values from the config, defined by the needs of env.py, # can be acquired:
def apiapp(request):
_app = api.create_app(TestingConfig)
classy_api(_app)
with _app.test_request_context():
yield _app
from flask_script import Manager
from app.api import create_app
from app.extensions import db
from app.models import User, Risk, Question, FieldType
manager = Manager(create_app())
@manager.command
def test():
pass
@manager.command
def create_db():
db.create_all()
@manager.command
def init_db():
text_field = FieldType(name='text')
db.session.add(text_field)
num_field = FieldType(name='number')
db.session.add(num_field)
date_field = FieldType(name='date')
db.session.add(date_field)
enum_field = FieldType(name='enum')
db.session.add(enum_field)
user = User()
from flask import url_for
from flask.ext.script import Manager, Shell
from flask.ext.migrate import Migrate, MigrateCommand
from werkzeug.wsgi import DispatcherMiddleware
from werkzeug.serving import run_simple
from app import api
from app.database import db_session as sess, Base
from app.models import *
#app = DispatcherMiddleware(frontend.create_app(), {'/api': api.create_app()})
app = api.create_app()
migrate = Migrate(app, Base)
manager = Manager(app)
def make_shell_context():
return dict(app=app,
User=User,
Tire=Tire,
sess=sess)
manager.add_command('shell', Shell(make_context=make_shell_context))
manager.add_command('db', MigrateCommand)
@manager.command
def list_routes():
import urllib
output = []
# -*- coding: utf-8 -*-
# @Time : 2020/6/24 10:42
# @Author : CoderCharm
# @File : test_docs.py
# @Software: PyCharm
# @Desc :
"""
测试文档地址是否正确
"""
from app.api import create_app
from fastapi.testclient import TestClient
app = create_app()
client = TestClient(app)
def test_read_docs():
docs_response = client.get("/api/v1/docs")
assert docs_response.status_code == 200
def test_docs_api():
api_response = client.get("/api/v1/openapi.json")
assert api_response.status_code == 200
if __name__ == '__main__':
from werkzeug.serving import run_simple
from werkzeug.wsgi import DispatcherMiddleware
from app import api, frontend
application = DispatcherMiddleware(frontend.create_app(),
{'/api': api.create_app()})
if __name__ == "__main__":
run_simple('0.0.0.0',
5000,
application,
use_reloader=True,
use_debugger=True)
