def create_app(app_name="MEDIASERVER"):
app = Flask(app_name)
app.wsgi_app = ProxyFix(app.wsgi_app, x_port=1, x_proto=1)
app.config.from_object("mediaserver.config.BaseConfig")
if os.environ.get("MEDIASERVER_API_SETTINGS"):
app.config.from_envvar("MEDIASERVER_API_SETTINGS")
authorizations = {
"Bearer Auth": {
"type": "apiKey",
"in": "header",
"name": "Authorization"
},
}
api = Api(
title="MediaServer REST API",
version="1.0",
description="",
security="Bearer Auth",
authorizations=authorizations,
)
api.add_namespace(auth_api)
api.add_namespace(folder_api)
api.add_namespace(media_api)
api.init_app(app)
cors = CORS(app)
db.init_app(app)
return app
def create_api(app):
api = Api(title='IDM/A Backend Interface',
version='Prototype',
description='Backend API for the IDM/A system.',
authorizations=authorizations)
api.init_app(app)
return api
def init_api():
"""
API모듈을 초기화 하여 그 인스턴스를 리턴한다.
:return: api instance
"""
api = Api(version='1.0', title='Scott API', description='Scott API')
__add_models(api)
@api.errorhandler(MultipleValidationError)
def validation_error(e):
"""
입력한 JSON의 형식이 올바르지 않을 경우 발생한 에러를 처리하기 위한 함수이다.
:param e: 에러객체
:return: 에러메시지
"""
json = {
'status': 400,
'messages': [str(el) for el in e.errors],
'request_id': flask_ctx_get_request_id()
}
return json, 400
@api.errorhandler(ContentsNotFoundException)
def content_not_found_error(e):
"""
조회결과가 존재하지 않을 경우 발생한 에러를 처리하기 위한 함수이다.
:param e: 에러객체
:return: 에러메시지
"""
json = {
'status': e.get_status(),
'message': e.get_message(),
'request_id': flask_ctx_get_request_id()
}
return json, e.get_status()
@api.errorhandler
def default_error_handler(e):
"""
기본 에러 핸들러 함수
:param e: 에러객체
:return: 에러메시지
"""
json = {
'status': 500,
'message': "Internal server error.",
'request_id': flask_ctx_get_request_id()
}
return json, 500
from . import dept_api, emp_api
api.add_namespace(dept_api.ns_dept, path="/dept")
api.add_namespace(emp_api.ns_emp, path="/emp")
blueprint = Blueprint('api', __name__)
api.init_app(blueprint)
return blueprint
def setUp(self):
super(TestBase, self).setUp()
app = Flask(__name__)
app.config[
'ERROR_404_HELP'] = False # Remove extra message from 404 errors
api = Api()
api.add_namespace(record_ns)
api.add_namespace(habit_ns)
api.add_namespace(user_ns)
api.add_namespace(health_ns)
api.add_namespace(auth_ns)
api.add_namespace(measurement_ns)
api.add_namespace(category_ns)
api.init_app(app)
self.app = app.test_client()
self.valid_header = {"Content-Type": "application/json"}
# Create mock logger
mock_logger = Mock()
# Create mock logger methods
mock_logger.debug()
mock_logger.info()
mock_logger.exception()
mock_logger.critical()
mock_logger.reset_mock()
# Override normal logger with mock logger
LoggingRegistry.LOGGER = mock_logger
def register(app):
@app.errorhandler(404)
def not_found(error):
return respond({'msg': 'Url not found.'}, Status.NOT_FOUND)
@app.errorhandler(SDException)
def handle_error(e):
if isinstance(e, NoAdministratorFound):
return respond({'msg': 'Please create an administrator first.'},
Status.INTERNAL_SERVER_ERROR)
else:
return respond({'msg': 'Unknown error just happened.'},
Status.INTERNAL_SERVER_ERROR)
@app.before_request
def parse_token():
token = request.headers.get('token', None)
user = get_user_by_token(token)
request.user = user
api = Api()
api.add_namespace(auth.api)
api.add_namespace(host.api)
api.add_namespace(service.api)
api.init_app(app)
def create_app():
app = Flask(__name__)
from config import Config
app.config.from_object(Config)
db.init_app(app)
@app.route('/login')
def login():
return "login"
@app.route('/register')
def register():
return "register"
from .apis.tweets import api as tweets
from .apis.users import api as users
api = Api()
api.add_namespace(tweets)
api.add_namespace(users)
api.init_app(app)
app.config['ERROR_404_HELP'] = False
return app
def create_app(config):
app = Flask(__name__)
app.config.from_object(config)
constants.FAKE_GPIO = app.config['FAKE_GPIO']
db.init_app(app)
migrate.init_app(app, db)
api = Api(title="The Garrison API",
version=app.config['API_VERSION'],
description='The backend API to interface with The Garrison.',
prefix='/api')
api.namespaces.pop(0)
from app.apis.about import ns as about_ns
api.add_namespace(about_ns)
from app.apis.ingredients import ns as ingredient_ns
api.add_namespace(ingredient_ns)
from app.apis.drinks import ns as drinks_ns
api.add_namespace(drinks_ns)
from app.apis.dispensers import ns as dispensers_ns
api.add_namespace(dispensers_ns)
from app.apis.orders import ns as orders_ns
api.add_namespace(orders_ns)
api.init_app(app)
return app
def setup_api(app):
api = Api()
api.init_app(app)
@api.route('/test')
class ExampleEndpoint(Resource):
def get(self):
return {'hello': 'world'}
def application_factory():
app = Flask(__name__)
api = Api(doc='/swagger', title='Demo', version='1.0', description='Demo description')
api.add_namespace(test_api)
api.add_namespace(user_api)
api.init_app(app)
return app
def init_api():
api = Api(version='1.0', title='API', description='REST API')
from . import router
api.add_namespace(router.ns_app, path="/tx")
blueprint = Blueprint('api', __name__)
api.init_app(blueprint)
return blueprint
def create_app(config):
api = Api()
app = Flask(__name__)
api.init_app(app)
@api.route('/hello')
class HelloWorld(Resource):
def get(self):
return {'hello': 'world'}
return app
def create_app():
app = Flask(__name__)
app.secret_key = b'uH\x88fP9t\xc8\xf3\x1e\\\xb2_\x90\x9d\xf2'
from config import Config
app.config.from_object(Config)
db.init_app(app)
@app.route('/hello')
def hello():
return "Goodbye World!"
authorizations = {
'apikey': {
'type': 'apiKey',
'in': 'header',
'name': 'X-API-KEY'
}
}
from .apis.tweets import api as tweets
api = Api()
api.add_namespace(tweets)
api.init_app(app, authorizations=authorizations)
login_manager = LoginManager()
login_manager.init_app(app)
@login_manager.request_loader
def load_user_from_request(request):
from app.models import User
# first, try to login using the api_key url arg
api_key = request.args.get('api_key')
print(api_key)
if api_key:
user = db.session.query(User).filter(
User.api_key == api_key).first()
if user:
return user
# next, try to login using Basic Auth
api_key = request.headers.get('X-API-Key')
print(api_key)
if api_key:
user = db.session.query(User).filter(
User.api_key == api_key).first()
if user:
return user
# finally, return None if both methods did not login the user
return None
app.config['ERROR_404_HELP'] = False
return app
def flask_application(api: Api) -> Flask:
application = Flask('notes')
CORS(app=application, origins='*')
api.add_namespace(notes_ns)
blueprint = Blueprint(name='notes',
import_name='notes',
url_prefix='/api/v1')
api.init_app(blueprint)
application.register_blueprint(blueprint)
return application
def init_api(app):
api = Api(version='1.0',
title='Fixly clone',
description='WIT Project for Python basics course')
api.init_app(app)
blueprint = Blueprint('api', __name__, url_prefix='/api')
api.init_app(blueprint)
api.add_namespace(login.login)
api.add_namespace(users.users)
api.add_namespace(order_types.order_types)
api.add_namespace(user_types.user_types)
api.add_namespace(orders.orders)
api.add_namespace(offers.offers)
app.register_blueprint(blueprint)
def create_app():
app = Flask(__name__)
from .apis.tweets import api as tweets
from .apis.users import api as users
from config import Config
app.config.from_object(Config)
db.init_app(app)
api = Api()
api.add_namespace(tweets)
api.add_namespace(users)
api.init_app(app)
app.config['ERROR_404_HELP'] = False
return app
def create_app():
app = Flask(__name__)
# Remove the previous code using `@app` and replace it with:
from .main.controllers import main
app.register_blueprint(main)
from .apis.tweets import api as tweets
api = Api()
api.add_namespace(tweets)
api.init_app(app)
app.config['ERROR_404_HELP'] = False
return app
def create_app():
app = Flask(__name__)
@app.route('/hello')
def hello():
return "Hello World!"
from .apis.tweets import api as tweets
api = Api()
api.add_namespace(tweets)
api.init_app(app)
app.config['ERROR_404_HELP'] = False
return app
def configure_api(api_bp):
"""
Handles the configuration of the API
"""
ebr_board_api = Api( # pylint: disable=invalid-name
version=__version__,
title="{project} JSON API".format(project=__project__),
description="JSON API for the EBR dashboard",
doc="/docs",
)
ebr_board_api.add_namespace(job_namespace)
ebr_board_api.add_namespace(job_build_namespace)
ebr_board_api.add_namespace(job_build_test_namespace)
ebr_board_api.add_namespace(tests_namespace)
ebr_board_api.add_namespace(models_namespace)
ebr_board_api.init_app(api_bp)
class Inventory:
"""This will start WSGI server."""
def __init__(self):
"""Initialize api attributes."""
self._api = Api(
version='1.0',
title='Inventory Management Api',
description=
'Inventory Management Api is used to Mannage inventory details.')
self._api.add_namespace(cms_ns_api)
def start(self, _port):
"""Start WSGI server."""
logger.debug("Starting...{}".format(PROG))
self._api.init_app(app)
CORS(app)
run_simple('localhost', _port, app, use_reloader=True)
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(configs[config_name])
app.add_url_rule('/', 'index', index)
app.add_url_rule('/<path:path>', 'index', index)
api = Api(doc='/doc')
api.add_resource(UserList, '/api/users/')
api.add_resource(User, '/api/users/<email>/')
db.init_app(app)
api.init_app(app)
flask_bcrypt.init_app(app)
return app
def setUp(self):
super(TestBase, self).setUp()
app = Flask(__name__)
api = Api()
api.add_namespace(email_ns)
api.add_namespace(content_ns)
api.add_namespace(subject_ns)
api.init_app(app)
self.app = app.test_client()
self.valid_header = {"Content-Type": "application/json"}
mail_service.mail_service = MailServiceStub()
def create_app():
app = Flask(__name__)
from config import Config
app.config.from_object(Config)
db.init_app(app)
@app.route('/hello')
def hello():
return "Goodbye World!"
from .apis.tweets import api as tweets
api = Api()
api.add_namespace(tweets)
api.init_app(app)
app.config['ERROR_404_HELP'] = False
return app
def init_app(app):
api = Api(
title='Player Session Service',
version='1.0',
description='This service which consumes events and provides metrics '
'about players sessions. Each user will generate two '
'events, one start event when the session starts and one '
'end event when session is finished. When both events '
'have been received the session is considered complete. '
'This Service is expected to handle massive amount of '
'sessions.',
)
api.add_namespace(player_events, path='/player-session-service')
api.add_namespace(country_sessions, path='/player-session-service')
api.add_namespace(player_sessions, path='/player-session-service')
# Add similar row for more endpoints...
api.init_app(app)
def create_app():
app = Flask(__name__)
with open('./app/main/resources/properties.yaml', 'r') as config_file:
app.config.update(safe_load(config_file))
if 'API_KEY' not in os.environ:
app.logger.error("Open Weather API Key not found")
sys.exit(1)
app.config["API_KEY"] = os.environ.get("API_KEY")
api = Api(
title='RocketCo',
version='1.0',
description='API for Location, Weather and Launch Window Services'
)
api.add_namespace(launch_window_ns, path='/launch_window')
api.init_app(app)
return app
def create_app(config_name):
app = Flask(__name__)
app.host = 'localhost'
api = Api()
flask_bcrypt = Bcrypt()
CORS(app)
jwt = JWTManager()
app.config.from_object(config_by_name[config_name])
app.config['JWT_TOKEN_LOCATION'] = ['cookies']
app.config['JWT_COOKIE_SECURE'] = False
app.config['JWT_COOKIE_CSRF_PROTECT'] = True
app.config['JWT_SECRET_KEY'] = os.getenv('JWT_ENV_FILE')
app.config['JWT_ACCESS_COOKIE_PATH'] = '/user/login/'
app.config['DYNAMO_TABLES'] = [
dict(
TableName='Users',
KeySchema=[dict(AttributeName='username', KeyType='HASH')],
AttributeDefinitions=[
dict(AttributeName='password', AttributeType='S'),
dict(AttributeName='firstname', AttributeType='S'),
dict(AttributeName='lastname', AttributeType='S')
]
# ProvisionedThroughput = dict(ReadCapacityUnits=5, WriteCapacityUnits=5)
)
]
dynamo = Dynamo()
with app.app_context():
# cors.init_app(app)
dynamo.init_app(app)
from app.controllers.user_controller import api as user_ns
api.add_namespace(user_ns, path='/user')
api.init_app(app)
flask_bcrypt.init_app(app)
jwt.init_app(app)
socket.init_app(app, cors_allowed_origins="*")
return app
class App:
"""Main entrypoint for REST API.
"""
def __init__(self):
self.api = Api(
title='Style transfer api',
version='1.0',
description='A description',
)
from endpoints import api
self.api.add_namespace(api, path="/api")
def run(self):
"""Start Flask web server"""
app = Flask(__name__)
self.api.init_app(app)
serve(app, host='0.0.0.0', port=5000)
def create_app(env, additional_settings={}):
global CONFIG
app = Flask(__name__, instance_relative_config=True, template_folder='templates')
app.config.from_object(config[env])
config[env].init_app(app)
app.config.update(additional_settings)
db.init_app(app)
ma.init_app(app)
from api.models import order
migrate = Migrate(app, db, compare_type=True)
# Namespace
from api.main import api as api_nsp
api = Api(version="1.0",
title="EnSa API Module",
doc='/docs')
api.add_namespace(api_nsp, path='')
api.init_app(app)
return app
class App(object):
def __init__(self):
self.db_user = os.getenv('DB_USER', 'docker')
self.db_password = os.getenv('DB_PASSWORD', 'password')
self.db_name = os.getenv('DB_NAME', 'postgres')
self.db_host = os.getenv('DB_HOST', 'localhost')
self.db_port = os.getenv('DB_PORT', '5432')
self.api = Api(version='1.0',
prefix='/api/v1',
doc='/swagger',
title='Product API',
description='A simple product api')
def logger_init(self) -> None:
path = PurePath.joinpath(
PurePath(__file__).parent, 'logging_config.ini')
fileConfig(path)
_logger.info(f'logger initialized with config: {path}')
def create_app(self) -> Flask:
flask_app = Flask(__name__)
flask_app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
url = f'postgresql://{self.db_user}:{self.db_password}@{self.db_host}:{self.db_port}/{self.db_name}'
flask_app.config['SQLALCHEMY_DATABASE_URI'] = url
self.register_extensions(flask_app)
self.register_api(flask_app)
_logger.info(f'app created')
return flask_app
def register_extensions(self, app_definition: Flask) -> None:
db.init_app(app_definition)
def register_api(self, app_definition: Flask) -> None:
self.api.add_namespace(api_products)
self.api.init_app(app_definition)
def setup_database(self, app_definition: Flask) -> None:
with app_definition.app_context():
db.create_all()
def create_app(config=None, **kwargs):
load_dotenv()
api = Api()
app = Flask(__name__, static_folder=None, **kwargs)
app.request_class = Request
app.url_map.strict_slashes = False
app.config.from_pyfile("../config.py")
if config:
app.config.update(config)
db.init_app(app)
register_blueprints(app)
# Health check
app.health_check_path = "/health-check"
@app.before_request
def health_check():
if request.path == app.health_check_path:
return jsonify(dict(status="healthy"))
@app.after_request
def headers(response):
response.headers["Server"] = "Test API"
response.headers["Keep-Alive"] = "timeout=5, max=100"
return response
@app.after_request
def commit_db_session(response):
session.commit()
return response
bootstrap_app(app)
init_cli(app)
print(app.url_map)
api.init_app(app)
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(configs[config_name])
gzip = Gzip(app)
app.add_url_rule('/', 'index', index)
app.add_url_rule('/<path:path>', 'index', index)
app.add_url_rule('/_nuxt/<file>', 'staticfiles', staticfiles)
api = Api(doc='/doc')
api.add_resource(DailyReport, '/api/reports/<date>/')
api.add_resource(DailyReport, '/api/reports/')
api.add_resource(Stats, '/api/stats/')
api.add_resource(Trends, '/api/trends/')
api.add_resource(Summary, '/api/summary/')
db.init_app(app)
api.init_app(app)
flask_bcrypt.init_app(app)
return app
