from flask import Blueprint
from flask_restplus import Api
from rest.event import api as event
blueprint = Blueprint('api', __name__)
api = Api(blueprint,
title='Remarkably Code Test',
version='0.1.0',
description='Backend API for Remarkably Code Test')
api.add_namespace(event, path="/event")
from flask_bcrypt import Bcrypt
from flask_restplus import Api
from flask import Blueprint
from .main.config import config_by_name
from .main.controller.user_controller import api as user_ns
from .main.controller.auth_controller import api as auth_ns
db = SQLAlchemy()
flask_bcrypt = Bcrypt()
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config_by_name[config_name])
db.init_app(app)
flask_bcrypt.init_app(app)
return app
blueprint = Blueprint('api', __name__)
api = Api(blueprint,
title='Flask-Restplus-JWT',
version='1.0',
description='a boilerplate for a flask restplus web service')
api.add_namespace(user_ns, path='/user')
api.add_namespace(auth_ns)
from flask_restplus import Api
from flask import Blueprint
from app.main.controllers.users_controller import api as user_ns
from app.main.controllers.visits_controller import api as visit_ns
from app.main.controllers.products_controller import api as product_ns
blueprint = Blueprint('api', __name__)
api = Api(blueprint,
title='STORELIFT API',
version='0.1.0',
description='Api for store actions')
api.add_namespace(user_ns, path='/users')
api.add_namespace(visit_ns, path='/visits')
api.add_namespace(product_ns, path='/products')
import os
from flask_restplus import Api
from flask import Blueprint
from .controller.home_controller import api as home_ns
from .controller.auth_controller import api as auth_ns
from .controller.user_controller import api as user_ns
blueprint = Blueprint('api', __name__)
api = Api(
blueprint,
title=os.environ.get("FLASK_SERVER_NAME"),
description=os.environ.get("FLASK_SERVER_DESCRIPTION"),
version=os.environ.get("FLASK_API_VERSION")
)
# Routes
api.add_namespace(home_ns, path='/api')
api.add_namespace(auth_ns, path='/api/auth')
api.add_namespace(user_ns, path='/api/user')
from flask import Flask
from flask_restplus import Api
from .version import api as version_ns
from .gpio import api as gpio_ns
from .spi import api as spi_ns
# Can't use distribution name in python 3.4.0
# https://github.com/mitsuhiko/flask/issues/1011
app = Flask(__name__)
api = Api(app, endpoint='api', prefix='/api', doc='/api',
version='0.1',
title='raspberry-api-server',
description='RESTful interface to Raspberry Pi')
api.add_namespace(version_ns)
api.add_namespace(gpio_ns)
api.add_namespace(spi_ns)
def run(*args, **kwargs):
import os
if os.environ.get('DEBUG'):
app.config['DEBUG'] = True
app.run(*args, **kwargs)
from flask_restplus import Api, fields
from bootstrap.apis.collection import api as ns_small
authorizations = {
'apikey': {
'type': 'apiKey',
'in': 'header',
'name': 'Authorization'
}
}
api = Api(title='RESTFUL API',
version='1.0',
description='',
authorizations=authorizations)
api.namespaces.clear()
api.add_namespace(ns_small)
from flask_restplus import Api
import settings
from apis.LogisticREgression import api as api_1
api = Api(doc=settings.SWAGGER_DOC,
title=settings.SWAGGER_TITLE,
description=settings.SWAGGER_DESCRIPTION,
contact=settings.SWAGGER_CONTACT,
contact_url=settings.SWAGGER_CONTACT_URL,
contact_email=settings.SWAGGER_CONTACT_EMAIL)
api.add_namespace(api_1)
from flask_restplus import Api api = Api(title="Mailer microservice", version="1.0") from .mails import create_api as create_mails api.add_namespace(create_mails())
from .resources.requests import ns as requests_ns
from .resources.comments import ns as comments_ns
from .resources.movies import ns as movies_ns
from .resources.tvshows import ns as tvshows_ns
from .model.database import db
app = Flask(__name__,
static_url_path = '',
static_folder = config['STATIC_FOLDER'])
blueprint = Blueprint('api', __name__)
api = Api(blueprint,
title = 'Plex Requests API',
validate = True)
api.add_namespace(requests_ns)
api.add_namespace(comments_ns)
api.add_namespace(movies_ns)
api.add_namespace(tvshows_ns)
app.register_blueprint(blueprint, url_prefix='/api')
@app.route('/')
def index():
return redirect('/index.html')
def run():
with app.app_context():
db.initialize()
app.run(
from flask_restplus import Api, Namespace, reqparse, inputs
from sokannonser import settings
api = Api(
version='1.3.0',
title='Market Search',
description='An API for searching and retrieving job listings from the '
'entire job market',
default='market',
default_label="An API for searching job listings.")
# Namespace configuration
ns_market = Namespace('All job ads',
description='Search and retrieve ~97% of all job ads.')
api.add_namespace(ns_market, '/')
# Queries
market_query = reqparse.RequestParser()
market_query.add_argument(settings.APIKEY, location='headers', required=True)
market_query.add_argument(settings.OFFSET,
type=inputs.int_range(0, settings.MAX_OFFSET),
default=0)
market_query.add_argument(settings.LIMIT,
type=inputs.int_range(0, settings.MAX_LIMIT),
default=10)
market_query.add_argument(settings.SHOW_EXPIRED, choices=['true', 'false'])
market_query.add_argument(settings.FREETEXT_QUERY)
market_query.add_argument(settings.PLACE, action='append')
market_query.add_argument(settings.EMPLOYER, action='append')
market_query.add_argument(settings.STATISTICS,
from flask_restplus import Api
from .cat import api as cat_api
from .dog import api as dog_api
api = Api(
title='Zoo API',
version='1.0',
description='A simple demo API',
)
api.add_namespace(cat_api)
api.add_namespace(dog_api)
from flask_restplus import Api
from .base import api as ns_base
from .stats import api as ns_stats
from .euro import api as ns_euro
api = Api(
Title="Karma Pi",
version='0.0.1',
description="Data with added karma and pi",
)
api.add_namespace(ns_base)
api.add_namespace(ns_stats)
api.add_namespace(ns_euro)
# This software is distributed under the terms of the GNU General Public
# Licence version 3 (GPL Version 3), copied verbatim in the file "LICENSE".
# In applying this license, CERN does not waive the privileges and immunities
# granted to it by virtue of its status as Intergovernmental Organization
# or submit itself to any jurisdiction.
import logging
from flask_restplus import Api
from .storage import api as unified_ns
from .introspect import api as introspection_ns
from .common.auth import authorizations
logging.getLogger(__name__).addHandler(logging.NullHandler())
__version__ = '3.2.0'
__major_version__ = __version__.split(".")[0]
INTROSPECTION_MOUNTPOINT = "/conf"
SAPI_MOUNTPOINT = "/v{}".format(__major_version__)
api = Api(
title='CERN Unified Storage API',
version=__version__,
description='A unified storage API for all data-storage back-ends.',
authorizations=authorizations,
validate=True,
)
api.add_namespace(unified_ns, path=SAPI_MOUNTPOINT)
api.add_namespace(introspection_ns, path=INTROSPECTION_MOUNTPOINT)
@app.route('/login')
def login():
'''
@ access_token 을 활용한 로그인 구현
@ref https://www.youtube.com/watch?v=J5bIPtEbS0Q
'''
auth = request.authorization
if auth and auth.password == 'password':
# jwt token 활용, 토큰 만료시간 30 m
token = jwt.encode(
{
'user': auth.username,
'exp':
datetime.datetime.utcnow() + datetime.timedelta(minutes=30)
}, app.config['SECRET_KEY'])
return jsonify({'token': token.decode('UTF-8')})
return make_response('Could verify!', 401,
{'WWW-Authenticate': 'Basic realm="Login Required'})
CORS(app)
title = 'My Homepage'
api = Api(app=app, version='1.0', title=title, description=title)
api.add_namespace(board, '/board')
api.add_namespace(user, '/user')
api.add_namespace(comments, '/comments')
if __name__ == '__main__':
app.run(debug=True, port=5001)
@app.before_first_request
def create_tables():
db.create_all()
# ------ api config ------
blueprint = Blueprint('resources', __name__)
api = Api(blueprint,
title='Flask Restplus API',
version=1.0,
description='foo bar description',
doc='/doc/')
api.add_namespace(item_ns)
api.add_namespace(items_ns)
api.add_namespace(store_ns)
api.add_namespace(stores_ns)
api.add_namespace(user_ns)
app.register_blueprint(blueprint)
# ------ jwt config ------
app.secret_key = 'jose'
jwt = JWT(app, authenticate, identity) # /auth
# ------ run ------
if __name__ == '__main__':
from src.db import db
from flask import Blueprint
from flask_restplus import Api
from app.api.namespaces import secondary as secondary_ns
from app.api.secondary import routes as secondary
API_VERSION_V1 = 1
api_v1_bp = Blueprint('api_v1', __name__)
api_v1 = Api(api_v1_bp)
secondary_ns.add_resource(secondary.POST, '/post')
secondary_ns.add_resource(secondary.Delete, '/delete')
secondary_ns.add_resource(secondary.GET, '/get')
api_v1.add_namespace(secondary_ns, '/secondary')
"""Initialization for the app. The controller imports come later due to needing to run after the creation of the app and db."""
import os
import uuid
import sys
from flask import Flask
from flask_restplus import Api
from flask_sqlalchemy import SQLAlchemy
from importlib import import_module
ROOT_DIR = os.path.dirname(os.path.abspath('book_wish_list'))
sys.path.insert(0, f"{ROOT_DIR}/book_wish_list")
app = Flask(__name__)
app.config['SECRET_KEY'] = str(uuid.uuid4())
app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get('DATABASE_URL')
api = Api(app,
doc='/swagger/',
title='book_wish_list',
description='A wishlist keeping microserver by Erik Enderlein.')
db = SQLAlchemy(app)
for module_name in ['book', 'wishlist', 'user']:
import_module(f'tables.{module_name}', package=__name__)
from controllers.books import books
from controllers.users import users
api.add_namespace(books)
api.add_namespace(users)
db.create_all()
"""Main module managing views."""
# from flask import Blueprint
from flask_restplus import Api
from .views_admin import ns as ns_admin
# from .views_core import ns as ns_core
from .views_core import bp
authorizations = {
'ApiKey': {
'type': 'apiKey',
'in': 'header',
'name': 'authentication-token'
}
}
# bp = Blueprint('stuffrapi', __name__, template_folder='templates')
api = Api(bp, authorizations=authorizations, security='ApiKey')
# api.add_namespace(ns_core)
api.add_namespace(ns_admin)
from flask_restplus import Api
from .predictions import api as apipred
from .training import api as apitrain
api = Api(
title='happytal recommender system',
version='0.1',
description='Placeholder description'
)
api.add_namespace(apitrain)
api.add_namespace(apipred)
__version__="0.1"
print(data)
return render_template("iris.html",
iris=data['complete_code'],
name=data['name'],
citycode=data['citycode'],
city=data['city'],
iris_type=data['type'])
api = Api(service,
title='INSEE/IRIS Geolocalizer',
ui=False,
prefix='/api',
version='0.1',
description="Retrieve some data related to the IRIS codes. Look for an IRIS from an address.")
api.add_namespace(insee_api)
geojson_parser = api.parser()
geojson_parser.add_argument("geojson", type=inputs.boolean, default=False, location='args',
help='GeoJSON')
iris_code_parser = geojson_parser.copy()
iris_code_parser.add_argument("limit", required=False, default=10, dest='limit',
location='args', help='Limit')
address_parser = geojson_parser.copy()
address_parser.add_argument("q", required=True, dest='q', location='args',
help='Query')
coords_parser = geojson_parser.copy()
coords_parser.add_argument("lat", required=True, type=float, dest='lat', location='args',
from manage import app
auth = {
"api-key": {
"type": "apiKey",
"in": "header",
"name": "Authorization"
},
"x-api-key": {
"type": "apiKey",
"in": "header",
"name": "X-API-KEY"
},
}
api = Api(
app,
version="1.0",
title="TTHelper",
description=
"<i>Helps the Ticket Checkers to do updates and allocations</i>",
contact_email="*****@*****.**",
authorizations=auth,
)
user_ns = api.namespace("Users", description="TC Routes")
api.add_namespace(user_ns, path="/tcr")
train_ns = api.namespace("Train", description="Train Routes and endpoints")
api.add_namespace(train_ns, path="/train")
'type': 'apiKey',
'in': 'header',
'name': 'Authorization'
}
}
OPS_BLUEPRINT = Blueprint('API_OPS', __name__, url_prefix='/ops')
API_OPS = Api(OPS_BLUEPRINT,
title='Service OPS API',
version='1.0',
description='The Core API for the Payment System',
security=['apikey'],
authorizations=AUTHORIZATIONS)
API_OPS.add_namespace(OPS_API, path='/')
API_BLUEPRINT = Blueprint('API', __name__, url_prefix='/api/v1')
API = Api(API_BLUEPRINT,
title='Payment API',
version='1.0',
description='The Core API for the Payment System',
security=['apikey'],
authorizations=AUTHORIZATIONS)
API.add_namespace(META_API, path='/meta')
# API.add_namespace(TRACE_API, path='/trace')
API.add_namespace(INVOICE_API, path='/invoices')
API.add_namespace(PAY_API, path='/payments')
from flask import Blueprint
from flask_restplus import Api, Resource
from app_routes.namespace_academy import api as ns1
blueprint = Blueprint('apiv2', __name__)
api = Api(blueprint)
api.add_namespace(ns1)
from flask import Blueprint
from flask_restplus import Api
from app.api.restful.user import api as user_api, authentication
from flask_cors import CORS
apiRoutes = Blueprint('api', __name__, url_prefix='/api')
CORS(apiRoutes)
api = Api(apiRoutes,
title='First Choice Travel Hub API',
version='v1',
doc='/documentation',
authorizations=authentication)
api.add_namespace(user_api)
from db_server import db
from constant import *
import models
from flask import request, abort, Response
from flask_login import LoginManager, login_required, login_user, current_user, logout_user
import ast
from datetime import datetime, timedelta, date
from send_email import EmailSender
login_manager = LoginManager()
login_manager.login_view = "login"
api = Namespace('')
book_vector = Api(title='Book Vector',
version='2.0',
description="A book library service by Team Phoenix")
book_vector.add_namespace(api)
# callback to reload the user object
@login_manager.user_loader
def load_user(username):
return query_user_by_name(username)
def invalid_user(username):
try:
if current_user.username == username:
return False
return True
except:
return True
from flask import Blueprint
from flask_restplus import Api
from Routes.area import ns_area
from Routes.capacity import ns_capacity
from Routes.gearRatios import ns_gear_ratios
from Routes.length import ns_length
from Routes.revolutions import ns_revolutions
from Routes.speed import ns_speed
from Routes.temperature import ns_temperature
from Routes.torque import ns_torque
from Routes.weight import ns_weight
blueprint = Blueprint('apiv1', __name__, url_prefix='/api/v1')
api = Api(blueprint,
version='1.0',
title='Conversion API',
description='API to consolidate conversions')
api.add_namespace(ns_area)
api.add_namespace(ns_capacity)
api.add_namespace(ns_gear_ratios)
api.add_namespace(ns_length)
api.add_namespace(ns_revolutions)
api.add_namespace(ns_speed)
api.add_namespace(ns_temperature)
api.add_namespace(ns_torque)
api.add_namespace(ns_weight)
from flask import Blueprint
from flask_restplus import Api
from .. import myservice
api_blueprint_v1 = Blueprint(myservice().name + '_v1', __name__)
api = Api(app=api_blueprint_v1,
version='1.0',
title=myservice().title,
description=myservice().description,
doc='/docs')
from .gdrive import gdrive_ns
from .gsheets import gsheets_ns
api.add_namespace(gdrive_ns, path='/gdrive')
api.add_namespace(gsheets_ns, path='/gsheets')
from flask import Flask
from flask_restplus import Api
from endpoints.email import api as email_ns
from endpoints.content import api as content_ns
from endpoints.subject import api as subject_ns
app = Flask(__name__)
api = Api()
api.add_namespace(email_ns)
api.add_namespace(content_ns)
api.add_namespace(subject_ns)
api.init_app(app)
if __name__ == "__main__":
app.run(debug=True, port=8001)
# authorizations = {
# 'apiKey': {
# 'type': 'apiKey',
# 'in': 'header',
# 'name': 'Authorization'
# }
# }
v1_api = Api(v1_blueprint,
title='DevOps FlaskREST API',
version='1.0',
description='auth: guomaoqiu\n'
'since: 2018-08-01',
contact="Author",
contact_email="*****@*****.**",
default="auth",
default_label=''
# authorizations=authorizations,
# security='apiKey')
)
# 导入两个红图
from .modules.auth.resources import auth_ns
from .modules.user.resources import user_ns
from .modules.test.resources import test_ns
v1_api.add_namespace(auth_ns)
v1_api.add_namespace(user_ns)
v1_api.add_namespace(test_ns)
from flask import Blueprint
from flask_restplus import Api
from .tools import api as tools
from .project import api as project
from .inputs import api as inputs
from .dashboard import api as dashboard
from .glossary import api as glossary
from .databases import api as databases
blueprint = Blueprint('api', __name__, url_prefix='/api')
api = Api(blueprint)
api.add_namespace(tools, path='/tools')
api.add_namespace(project, path='/project')
api.add_namespace(inputs, path='/inputs')
api.add_namespace(inputs, path='/inputs')
api.add_namespace(dashboard, path='/dashboards')
api.add_namespace(glossary, path='/glossary')
api.add_namespace(databases, path='/databases')
@api.errorhandler
def default_error_handler(error):
"""Default error handler"""
import traceback
trace = traceback.format_exc()
return {'message': error.message, 'trace': trace}, 500
from flask_restplus import Api, Namespace, fields
from apis.datasource import api as datasource
from apis.package import api as package
from apis.module import api as module
from apis.script import api as script
from apis.scenario import api as scenario
from apis.run import api as run
# Apis 모듈 집계
api = Api(title='넥스폼 데이터 처리 엔진',
version='1.0',
description='모니터링에 사용 될 Row Data Import/Processing/Analysis 처리 엔진'
# All API metadatas
)
api.add_namespace(datasource)
api.add_namespace(package)
api.add_namespace(module)
api.add_namespace(script)
api.add_namespace(scenario)
api.add_namespace(run)
from flask_restplus import Api
from .portfolioresource import api as portfolio_namespace
api = Api(title="SAL/M Backend API",
description="Systems Architecture Lifecycle Management",
version="0.1")
api.add_namespace(portfolio_namespace)
from flask_restplus import Api
from flask import Blueprint
from app.main.controllers import *
blueprint = Blueprint('api', __name__)
api = Api(blueprint,
title='FLASK RESTPLUS API',
version='1.0',
description='Api Rest',
doc='/docs')
api.add_namespace(test_ns)
api.add_namespace(client_ns)
# Import flask dependencies
from flask import Blueprint
from flask_restplus import Api, Resource
from app.api.profile import views
from app.api.auth.views import authorizations
from app.api.profile.views import api_profile
# Define the blueprint: 'auth', set its url prefix: app.url/auth
mod_profile = Blueprint('profile', __name__, url_prefix='/api/v1/profile')
api = Api(mod_profile, version='1.0',title='Event Equipment and Service Booking System',
description='A documentation for the Event Equipment and Service Booking System User profile',
authorizations=authorizations )
# #add endpoint when using swagger api testing
api.add_namespace(api_profile, path='/profile')
from flask_restplus import Api
from flask import Blueprint
from .main.controller.user_controller import api as user_ns
from .main.controller.auth_controller import api as auth_ns
from .main.controller.post_controller import api as post_ns
blueprint = Blueprint('api', __name__)
api = Api(blueprint,
title='Instapic API',
version='1.0',
description='A Flask RESTful API service for Instapic'
)
api.add_namespace(user_ns, path='/user')
api.add_namespace(auth_ns, path='/auth')
api.add_namespace(post_ns, path='/post')
from flask import Blueprint
from flask_restplus import Api
__version__ = '1.0'
blueprint = Blueprint('api_v1', __name__)
api = Api(blueprint,
version=__version__,
title='Cerebrum REST API',
description='Cerebrum is a user administration and '
'identity management system.',
contact='*****@*****.**')
from Cerebrum.rest.api.v1.account import api as account_ns
from Cerebrum.rest.api.v1.group import api as group_ns
from Cerebrum.rest.api.v1.emailaddress import api as emailaddress_ns
from Cerebrum.rest.api.v1.context import api as context_ns
from Cerebrum.rest.api.v1.ou import api as ou_ns
from Cerebrum.rest.api.v1.person import api as person_ns
from Cerebrum.rest.api.v1.search import api as search_ns
api.add_namespace(account_ns)
api.add_namespace(group_ns)
api.add_namespace(emailaddress_ns)
api.add_namespace(context_ns)
api.add_namespace(ou_ns)
api.add_namespace(person_ns)
api.add_namespace(search_ns)
from flask import Blueprint
from flask_restplus import Api
from apis.movies.views import api as movies
from apis.votings.views import api as votings
blueprint = Blueprint("api", __name__, url_prefix="/api/v1")
api = Api(blueprint,
title="Vote for a Movie",
version="0.1.0",
description="A REST API for the \"Vote for a Movie\" app.")
api.add_namespace(movies)
api.add_namespace(votings)
from flask import Blueprint
from flask_restplus import Api
from .endpoints import predict_ns
blueprint = Blueprint('predict', __name__, url_prefix='/api/v1.0')
# v1_0 = Blueprint('v1_0', __name__, url_prefix='/api/v1.0')
api = Api(
blueprint, version='1.0', title='{{cookiecutter.project_name}}',
description='{{cookiecutter.project_name}} Prediction API', doc='/doc/')
api.namespaces.clear()
api.add_namespace(predict_ns)
from flask_restplus import Api
from flask import Blueprint
from .main.controller.user_controller import api as user_ns
from .main.controller.auth_controller import api as auth_ns
from .main.controller.role_controller import api as role_ns
from .main.controller.card_list_controller import api as card_list_ns
from .main.controller.comment_controller import api as comment_list_ns
from .main.controller.card_controller import api as card_ns
blueprint = Blueprint('api', __name__)
api = Api(blueprint,
title='Irithm task',
version='1.0',
description='flask api docs'
)
api.add_namespace(user_ns, path='/users')
api.add_namespace(auth_ns)
api.add_namespace(role_ns)
api.add_namespace(card_list_ns)
api.add_namespace(card_ns, path='/cards')
api.add_namespace(comment_list_ns, path='/comments')
from flask import Blueprint
from flask_restplus import Api
from .user import api as user_api
from .quote import api as quote_api
from .track import api as track_api
from .book import api as book_api
from .lookup import api as lookup_api
from .update import api as update_api
from .orders import api as orders_api
from .contact import api as contact_api
from .roles import api as roles_api
blueprint = Blueprint('api', __name__)
api = Api(blueprint,
title='Packr',
version='0.0.1',
description='For sending packages')
api.add_namespace(user_api)
api.add_namespace(quote_api)
api.add_namespace(track_api)
api.add_namespace(book_api)
api.add_namespace(lookup_api)
api.add_namespace(update_api)
api.add_namespace(orders_api)
api.add_namespace(contact_api)
api.add_namespace(roles_api)
# app/__init__.py
from flask_restplus import Api
from flask import Blueprint
from .main.controller.user_controller import api as user_ns
blueprint = Blueprint('api', __name__)
api = Api(
blueprint,
title='FLASK RESTPLUS API WITH JWT',
version='1.0',
description='a boilerplate for flask restplus web service'
)
api.add_namespace(user_ns, path='/user')
