__all__ = ('API_BLUEPRINT', 'OPS_BLUEPRINT')
# This will add the Authorize button to the swagger docs
AUTHORIZATIONS = {
'apikey': {
'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 COLIN API for the Legal Entities 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='COLIN API',
version='1.0',
description='The COLIN API for the Legal Entities System',
security=['apikey'],
authorizations=AUTHORIZATIONS)
API.add_namespace(META_API, path='/meta')
from flask import Blueprint
from flask_restplus import Api
iperf_blueprint = Blueprint('root', __name__)
api = Api(iperf_blueprint, version='1.0', title='Iperf API', description='Iperf API',
doc='/api_docs/')
from flask import Flask
from flask_restplus import Api, Resource, fields
app = Flask(__name__)
api = Api(
app,
version='1.0',
title='API UFollower',
description='API UFollower',
)
ns = api.namespace('Operações: Nodo Pessoal', description='')
todo = api.model(
'Todo', {
'id':
fields.Integer(readOnly=True,
description='Identificado único de cada nodo pessoal'),
'nome':
fields.String(required=True, description='Nome do nodo pessoal'),
'pais':
fields.String(required=True, description='The task details'),
'idade':
fields.String(required=True, description='Idade'),
'genero':
fields.String(required=True, description='Feminino e Masculino'),
'endereco':
fields.String(required=True, description='Endereço'),
'e-mail':
fields.String(required=True, description='E-mail'),
'dt_nascimento':
from flask_restplus import Api
from .sensors import api as sensors
api = Api(title='canary assignment',
description='Sensors api using mongoengine and flask_restplus')
#set sensors endpoint
api.add_namespace(sensors, path='/sensors')
from flask import Blueprint
from flask_restplus import Api
from api.qr_api import api as qr_namespace
from api.login_api import api as login_namespace
app_api = Blueprint('app_api', __name__, url_prefix='/pingan/api')
api1 = Api(app_api,
title='API',
version='1.0',
description='API文档',
doc='/doc/'
# All API metadatas
)
api1.add_namespace(qr_namespace)
api1.add_namespace(login_namespace)
import config.config as config
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_restplus import Resource, Api
import os
config = config.config
app = Flask(__name__)
app.config["SQLALCHEMY_DATABASE_URI"] = os.environ.get("CKMO_DATABASE_URI")
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
app.secret_key = os.environ.get("CKMO_SECRET") or "i23jnm2hi0ghn2i0g"
api = Api(app)
db = SQLAlchemy(app)
# before the 1 hour expiry:
user = auth.refresh(user['refreshToken'])
# now we have a fresh token
user['idToken']
# Get a reference to the database service
db = firebase.database()
# ---------------------------
# Define application and api object
application = Flask(__name__)
api = Api(application, version='1.0', title='Logistic Regression',
description='Logistic Regression')
ns = api.namespace('DS2_3_docker_and_aws', description='Methods')
# Define arguments for our API, in this case, it is going to be just a comma separated string
single_parser = api.parser()
single_parser.add_argument('input', type=str, required=True, help='input CSV')
# Load objects from pickle files
labelEncoder1 = pickle.load(open('pickle_files/labelEncoder1.pickle', 'rb'))
labelEncoder2 = pickle.load(open('pickle_files/labelEncoder2.pickle', 'rb'))
standardScaler = pickle.load(open('pickle_files/standardScaler.pickle', 'rb'))
onehotencoder = pickle.load(open('pickle_files/onehotencoder.pickle', 'rb'))
model = pickle.load(open('pickle_files/log_reg_model.pickle', 'rb'))
@ns.route('/prediction')
import logging
import traceback
from flask_restplus import Api
from mtm import settings
from mtm.api.errors import InvalidInputError, NotFoundError
log = logging.getLogger(__name__)
api = Api(version='1.0', title='The Music Time Machine API',
description='The Music Time Machine is a test API created for CMPUT 401 at the University of Alberta.')
def getErrorObject(e):
"""
Gets an error object to return in the response.
@type e: Exception
@param e: The exception object.
@rtype: dict
@return: An error object
"""
return {
'errors': [{
'code': e.code,
'title': e.title,
'details': e.details,
'href': e.href
}],
'message': 'Some errors were found during the execution of this request'
}
@api.errorhandler
#!/usr/bin/python
from flask import Flask
from flask_restplus import Api, Resource, fields
from sklearn.externals import joblib
from m29_model_deployment import predict_movie_genre
app = Flask(__name__)
api = Api(
app,
version='1.0',
title='Prediction Movie Genre',
description=
'Developed By Andres Martinez, Nicolas Gil, Ana Maria and Jorge Medina')
ns = api.namespace('predict', description='Movie Genre')
parser = api.parser()
parser.add_argument('Data Year',
type=int,
required=True,
help='Year',
location='args')
parser.add_argument('Data title',
type=str,
required=True,
help='title the movie',
location='args')
parser.add_argument('Data plot',
from flask_restplus import Api
from .UserController import api as user_api
api = Api(
title='API',
version='1.0',
description='APIs to handle mighty car'
)
api.add_namespace(user_api)
from flask import current_app
from flask_restplus import Api, Resource, fields, reqparse
from api_framework import create_app, register_init
from api_framework.utils import AppError
app = create_app(__name__)
api = Api(
app,
title="sample",
version="1.0",
description="sample api",
default="sample",
default_label="sample api",
)
fields_info = {
"name": {
"type_func": fields.String,
"required": True,
"description": "use error for demo error handler",
},
"gender": {
"type_func": fields.String,
"enum": ["male", "female"],
"required": True,
},
"msg": {
"type_func": fields.String,
"default": "some msg~"
},
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
blueprint = Blueprint('api', __name__)
api = Api(blueprint,
title='Restplus boilerplate with JWT',
version='1.0',
description='a boilerplate for flask restplus web service'
)
api.add_namespace(user_ns, path='/user')
api.add_namespace(auth_ns)
from flask import Blueprint
from flask_restplus import Api
from cerebralcortex.apiserver.apis.v1.stream import api as v1_stream
from cerebralcortex.apiserver.apis.v1.user import api as v1_user
blueprint = Blueprint('version1', __name__, url_prefix='/api/1')
api = Api(blueprint,
title='Cerebral Cortex',
version='1.0',
description='API server for Cerebral Cortex',
contact='*****@*****.**',
license='BSD 2-Clause',
license_url='https://opensource.org/licenses/BSD-2-Clause')
api.add_namespace(v1_user)
api.add_namespace(v1_stream)
""" API Blueprint Application """
from flask import Blueprint
from flask_restplus import Api
api_bp = Blueprint('api_bp', __name__, url_prefix='/api')
api_rest = Api(api_bp)
@api_bp.after_request
def add_header(response):
response.headers[
'Access-Control-Allow-Headers'] = 'Content-Type,Authorization'
return response
# Import resources to ensure view is registered
from .resources import * # NOQA
'''
from flask import Flask, Response, render_template, request, jsonify
import json
# from src.readtsv import Logic
from flask_restplus import Resource, Api, reqparse
from flask_cors import CORS
from flask_restplus import Api, reqparse
import datetime
import logging
from src.readtsv import Logic
app = Flask(__name__)
CORS(app)
api = Api(app,
version='1.0',
title='Autocomplete',
description='World of Fuzzy Search')
nm_space = api.namespace(
"", description="A restful web service that allow to do fuzzy search..!")
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
fmt = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
ch.setFormatter(fmt)
logger.addHandler(ch)
#created a parser to accept the user input, We can provide the input in the Swagger UI as well.
parser = reqparse.RequestParser()
parser.add_argument('input',
from contextlib import suppress
import requests
from flask import abort, Blueprint
from flask_restplus import Api, fields, Resource
from service import app
blueprint_v1 = Blueprint('api-v1', __name__)
api_v1 = Api(
blueprint_v1,
version='1.0',
title='Ping Service',
validate=True,
)
ping = api_v1.model('Ping', {
'url': fields.String(required=True),
})
@api_v1.route('/ping')
class PingResource(Resource):
@api_v1.expect(ping)
def post(self):
url = api_v1.payload['url']
try:
response = requests.get(url, timeout=app.config['REQUEST_TIMEOUT'])
except requests.RequestException:
abort(400, f"Cannot access URL at '{url}'")
from datetime import datetime
from flask import Flask, jsonify
from flask_restplus import Api, Resource, fields
from flask_cors import CORS, cross_origin
from infrastructure.db_connect import DBConnect
from services.db_service import DBService
db_conn = DBConnect()
db_service = DBService(db_conn)
app = Flask(__name__)
CORS(app)
api = Api(
app,
version='1.0',
title='Grading App',
description='',
)
add_student_api = api.namespace('addStudent',
description='Assign student to the assignment')
question_api = api.namespace('question', description='Question Management')
# exposed apis
student_api = api.namespace('student', description='Studet View')
teacher_api = api.namespace('teacher', description='Teacher View')
student_model = api.model(
'AssignStudent', {
'name':
fields.String(required=True, description='Name of the student'),
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.catergory_controller import api as catergory_ns
from .main.controller.article_controller import api as article_ns
from .main.controller.picture_controller import api as picture_ns
blueprint = Blueprint('api', __name__)
api = Api(
blueprint,
title='Liphephandzaba API',
version='1.0',
description='This is a web service for the Liphephandzaba application')
api.add_namespace(user_ns, path='/user')
api.add_namespace(auth_ns)
api.add_namespace(catergory_ns, path='/categories')
api.add_namespace(article_ns, path='/article')
api.add_namespace(picture_ns, path='/picture')
from flask import Flask
from flask_restplus import Api, Resource
from functions import hello, snore, np_estimate_pi, estimate_pi
app = Flask(__name__)
api = Api(app=app)
@api.route('/hello')
class Hello(Resource):
def get(self):
return hello()
@api.route('/sleep/<float:t>')
class Sleep(Resource):
def get(self, t: float):
return snore(t=t)
@api.route('/estimate-pi-np/<int:n>')
class EstimatePiNumpy(Resource):
def get(self, n: int):
return np_estimate_pi(n=n)
@api.route('/estimate-pi/<int:n>')
from flask_restplus import Api
# from server.configs import configs
from server.logger import log
from server.status import HTTPStatus
# flask对象
app = Flask(__name__)
app.config['ERROR_404_HELP'] = False
app.secret_key = "\x1a\x8dfb#\xb9\xc8\xc3\x05\x86|\xda\x96\xff\xceo3\xf0\xa3\xb8\x8beoW"
# flask_restplus对象
api = Api(app, version='1.0.0', title='da API 1.0.0',
description='da API 1.0.0', authorizations={
'apikey': {
'type': 'apiKey',
'in': 'header',
'name': 'Token'
}
}, security='apikey', ui=True)
# session超时时间
app.permanent_session_lifetime = timedelta(seconds=7200)
# 跨域设置
@app.after_request
def cors(resp):
resp.headers.add('Access-Control-Allow-Origin', '*')
resp.headers.add(
'Access-Control-Allow-Headers',
'Origin, X-Requested-With, Content-Type, Accept, token, appVersion')
"""Initialization module of Resources."""
# Flask based imports
from flask import Blueprint
from flask_restplus import Api
# Api based imports
from api.config import Config
# Resources based imports
from api.resources.main import api as main
blueprint = Blueprint('api', __name__, url_prefix='/api')
# API instantiation
api = Api(blueprint,
title=Config.TITLE,
version=Config.VERSION,
description=Config.DESCRIPTION)
# Namespaces registration
api.add_namespace(main, path='')
from flask import Blueprint
from flask_restplus import Api
from flask_cors import CORS
from .main.controller.nasa_controller import api as nasa
from .main.controller.todo_controller import api as todo
blueprint = Blueprint('api', __name__, url_prefix='/api')
CORS(blueprint, support_credentials=True)
api = Api(blueprint,
title="Space Data Service",
description='Keeping data from different space agencies centralized')
'# Add more namespaces for other paths here'
api.add_namespace(nasa, path='/nasa')
api.add_namespace(todo, path='/todo')
pattern = r'[^a-zA-z0-9\s]'
text = re.sub(pattern, '', text)
return text
# Função que limpa o texto
def denoise_text(text):
text = strip_html(text)
text = remove_between_square_brackets(text)
text = remove_special_characters(text)
return text
flask_app = Flask(__name__)
app = Api(app=flask_app,
version="1.0",
title="Movies Sentiment Classifier",
description="Predict the sentiment of movies review")
name_space = app.namespace('prediction', description='Prediction APIs')
model = app.model(
'Prediction params', {
'review':
fields.String(required=True,
description="Text containing the review of movies",
help="Text review cannot be blank")
})
classifier = joblib.load('classifier_movies.joblib')
vectorizer = joblib.load('count_vectorizer.joblib')
########
# initialization
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = URL
app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
# extensions
CORS(app)
db = SQLAlchemy(app)
auth = HTTPBasicAuth()
authorizations = {'token': {'type': 'apiKey', 'in': 'header', 'name': 'token'}}
api = Api(app,
version='1.0',
title=API_TITLE,
description=API_DESCRIPTION,
authorizations=authorizations)
migrate = Migrate(app, db)
#
# Models
#
users_roles = db.Table(
'users_roles',
db.Column('users_id',
db.Integer,
db.ForeignKey('users.id'),
primary_key=True),
db.Column('roles_id',
from flask import Flask from config import Config from flask_mongoengine import MongoEngine from flask_restplus import Api from application.functions.SeedUrls import * from application.functions.CrawlFromSeedUrls import * from application.functions.CrawlArticles import * api = Api() app = Flask(__name__) app.config.from_object(Config) db = MongoEngine() db.init_app(app) api.init_app(app) # crawl_seed_urls() # crawl_unvisited_seed_urls() # crawl_for_articles() from application import routes
import ah_config
from utils import ResourceException
from flask import jsonify, Response
from flask_restplus import Api, Resource
from resources.control import api as control_ns
from resources.risk import api as risk_ns
import prometheus_client
from app_factory import app_factory
from middleware import setup_metrics
from datadog_middleware import setup_metrics as setup_dd_metrics
# Use a custom LogRecord factory to inject some request and context attributes
app = app_factory(ah_config)
api = Api(app, version='1.0', doc='/swagger')
setup_metrics(app)
setup_dd_metrics(app)
#
# Handle our ResourceException
#
@api.errorhandler(ResourceException)
def handle_resource_exception(resource_exception):
app.logger.exception("handle_resource_exception")
# Turn the exception into a flask Response and add the status code
response = jsonify(resource_exception.to_dict())
response.status_code = resource_exception.status_code
return response
from flask_restplus import Api
from .things import api as things
from .events import api as events
from .assets import api as assets
from .owm import api as owm
from .widgets import api as widgets
api = Api(
title='Smart API',
version='1.0',
prefix='/api/v1',
description=
'Restfull API used to query things, ecexute events and manageing assets')
api.add_namespace(things)
api.add_namespace(events)
api.add_namespace(assets)
api.add_namespace(owm)
api.add_namespace(widgets)
def create_app():
app = Flask(__name__)
api = Api(app)
setup_resources(api)
return app
from app import routes
from flask_restplus import Api
arl_app = Flask(__name__)
arl_app.config['BUNDLE_ERRORS'] = True
authorizations = {
"ApiKeyAuth": {
"type": "apiKey",
"in": "header",
"name": "Token"
}
}
api = Api(arl_app, prefix="/api", doc = "/doc", title='ARL backend API', authorizations = authorizations,
description='ARL（Asset Reconnaissance Lighthouse）资产侦察灯塔系统', security="ApiKeyAuth")
api.add_namespace(routes.task_ns)
api.add_namespace(routes.site_ns)
api.add_namespace(routes.domain_ns)
api.add_namespace(routes.ip_ns)
api.add_namespace(routes.url_ns)
api.add_namespace(routes.user_ns)
api.add_namespace(routes.image_ns)
api.add_namespace(routes.cert_ns)
api.add_namespace(routes.service_ns)
api.add_namespace(routes.filleak_ns)
api.add_namespace(routes.export_ns)
if __name__ == '__main__':
# -*- coding: utf-8 -*- from flask_restplus import Api from .users import api as users from .posts import api as posts from .auth import api as auth api = Api(title='API REST', version='1.0', description='Lista de APIS') api.add_namespace(users) api.add_namespace(posts) api.add_namespace(auth)
