from flask_restplus import Resource, Api, fields from scrapper import despesas_total, despesas_por_funcao from flask_cors import CORS app = Flask(__name__) CORS(app) api = Api( app=app, version="1.0", title="Transparência Maranhão", description= "Uma API não oficial com os dados sobre as receitas e despesas do Governo do Maranhão" ) ns = api.namespace('despesas', description='Dados de despesas') model = api.model( 'Dados sobre uma função ou orgão', { 'codigo': fields.String(description='Código da função ou orgão', example="04"), 'nome': fields.String(description='Nome da função ou orgão', example="ADMINISTRACAO"), 'url_detalhe': fields.String( description='Endereço para mais detalhes', example= "http://www.transparencia.ma.gov.br/app/despesas/por-funcao/2016/funcao/04?" ), 'empenhado':
from accident_risk_prediction.controllers.health_check import conn_mongo from accident_risk_prediction.controllers.handle_logs import conf_logging # from accident_risk_prediction.controllers.health_check import HealthCheck conf_logging() APP = Flask(__name__) API = Api( APP, version="1.0", title="PREDICT RISK ACCIDENT AT BH", description="PREDICT RISK ACCIDENT AT BH", doc="/api/v1/swagger", ) NAMESPACE = API.namespace("api/v1", description="TCC") @NAMESPACE.route("/predict-accident") class PredictAccident(Resource): """ Class to /predict-accident handle requests """ @NAMESPACE.doc("TCC") @NAMESPACE.expect(API.schema_model("data", INPUT_BODY)) @NAMESPACE.response(code=HTTPStatus.OK, description="Ok") @NAMESPACE.response(code=HTTPStatus.INTERNAL_SERVER_ERROR, description="Internal Server Error") @NAMESPACE.response(code=HTTPStatus.UNPROCESSABLE_ENTITY, description="Unprocessable Entity") @NAMESPACE.response(code=HTTPStatus.PRECONDITION_FAILED, description="Precondition Failed") def post(self):
import base64 import mysql.connector from threading import Lock from flask import Flask, request from flask_cors import CORS from flask_restplus import Resource, Api, fields from common import * app = Flask(__name__) api = Api(app, title='Book Barter Checkout API') CORS(app) ns = api.namespace('Checkout', description='Checkout operations') api.add_namespace(ns) lock = Lock() connection = mysql.connector.connect(host='localhost', user='******', password='******', database='checkout') cursor = connection.cursor(buffered=True, dictionary=True) checkout_fields = api.model('Checkout', { 'bookId': fields.String, }) @api.route('/cart')
# -*- coding: utf-8 -*- from flask_restplus import apidoc, Api from flask import Blueprint, render_template from flask_cors import cross_origin api_blueprint = Blueprint('api', __name__) api = Api(api_blueprint, doc=False, catch_all_404s=True, title='API version 2.0') ns_administrative = api.namespace('administrative', description="Administrative APIs", path='/') def init_app(app): from . import (hail, taxi, ads, drivers, zupc, profile, vehicle, documents, users, customer) api.init_app(app, add_specs=False) app.register_blueprint(api_blueprint) app.register_blueprint(apidoc.apidoc) @app.route('/swagger.json', endpoint='api.specs') @cross_origin() def swagger(): return render_template('swagger.json', host=app.config['SERVER_NAME']), 200, {'Content-Type': 'application/json'}
# from FeaturesGenerator import FeaturesGenerator # from TicketFinder import TicketFinder from flair_cosine_similarity import flair_semantic from elmo_cosine_similarity import elmo_semantic from spacy_cosine_similarity import spacy_semantic from common import similarity_test from bert_similarity import bert_semantic from flask import Flask, Response, jsonify from flask_restplus import Api, Resource, fields, reqparse import os # the app app = Flask(__name__) api = Api(app, version='1.0', title='semantic', validate=False) ns = api.namespace('Semantic', 'Returns similarity') # # load the algo # processed_tickets = 'C:/FDTickets/data/processed_tickets.csv' # feature_ds = 'C:/FDTickets/data/bert_features.csv' flair = flair_semantic() elmo = elmo_semantic() bert = bert_semantic() spacy = spacy_semantic() common = similarity_test() # tf = TicketFinder(processed_tickets, feature_ds, True, False, False) model_input = api.model('Enter 2 sentences separated with | :', {'sentence_1': fields.FormattedString, 'sentence_2': fields.FormattedString }) port = int(os.getenv('PORT', 8080)) # The ENDPOINT
app = Flask(__name__) api = Api( app, version="1.0", title="Summary API", description="A simple review summarization API which uses Python's sumy library", ) CORS(app) app.config.SWAGGER_UI_DOC_EXPANSION = "list" ns = api.namespace("sum/v1.0", "Text Summary v1.0 ") parser = api.parser() parser.add_argument( "reviews", required=True, location="json", help="Input Format : " "<br>{" '<br> "reviews":[{' '<br> "reviewer_id":"string",' '<br> "reviewee_id":"string",' '<br> "score":"string",' '<br> "feedback":"string"' "<br> }]" "<br>}",
import os, random, exceptions from flask import render_template, flash, redirect, session, url_for, request, jsonify, json, Blueprint, render_template, abort from jinja2 import TemplateNotFound from app import app from models import Game, Ship, Faction, Body, Star from flask_restplus import Api, Resource, fields, apidoc ajax = Blueprint('ajax', __name__, template_folder='templates') api = Api(app, version='1.0', title='Todo API', description='A simple TODO API extracted from the original flask-restful example', ) ns = api.namespace('ajax', description='Kvantgen API operations') TODOS = { 'todo1': {'task': 'build an API'}, 'todo2': {'task': '?????'}, 'todo3': {'task': 'profit!'}, } todo = api.model('Todo', { 'task': fields.String(required=True, description='The task details') }) listed_todo = api.model('ListedTodo', { 'id': fields.String(required=True, description='The todo ID'), 'todo': fields.Nested(todo, description='The Todo')
if local_ee_auth == 'local': ee.Initialize() else: # else assume you have an EE_private_key env. variable with authorisation service_account = os.environ['EE_USER'] credentials = ee.ServiceAccountCredentials(service_account, BASE_DIR + '/privatekey.pem') ee.Initialize(credentials, 'https://earthengine.googleapis.com') app = Flask(__name__) cors = CORS(app) api = Api(app, version='1.0', title='Minimum API example', description='A simple start point to build a microservice in flask, using '\ 'Earth Engine, with automatic Swagger UI',) ns = api.namespace('Endpoints', description='Operations and supporting information') todo = api.model( 'Todo', { 'id': fields.Integer(readOnly=True, description='The task unique identifier'), 'task': fields.String(required=True, description='The task details') }) class TodoDAO(object): def __init__(self): self.counter = 0 self.todos = []
title='Archive API', description='A service to ingest and archive BagIt ' '(https://tools.ietf.org/html/draft-kunze-bagit-17) resources', prefix='/storage/v1') config_obj = config.ArchiveAPIConfig( development=(os.environ.get('FLASK_ENV') == 'development') ) app.config.from_object(config_obj) daiquiri.setup(level=os.environ.get('LOG_LEVEL', 'INFO')) logger = daiquiri.getLogger() api.namespaces.clear() ns_ingests = api.namespace('ingests', description='Ingest requests') # We can't move this import to the top because the models need the ``api`` # instance defined in this file. import models # noqa @ns_ingests.route('') @ns_ingests.doc(description='Request the ingest of a BagIt resource.') @ns_ingests.param( 'payload', 'The ingest request specifying the uploadUrl where the BagIt resource can be found', _in='body') class IngestCollection(Resource): @ns_ingests.expect(models.IngestRequest, validate=True) @ns_ingests.response(202, 'Ingest created')
from flask_restplus import Api, Resource, fields, reqparse app = Flask(__name__) #app.config.SWAGGER_UI_OPERATION_ID = True app.config.SWAGGER_UI_REQUEST_DURATION = True api = Api(app, version='1.0', title='Bigdata', doc='/swagger-ui.html', description='Bigdata APIs', default_label=None, default=None, contact_email='*****@*****.**', contact='Alex') ns = api.namespace('刷题王测试数据', description='King Test Data', path='/api/v1') def trans_time(time_stamp): time_stamp = int(time_stamp / 1000) return time.strftime("%Y%m%d", time.localtime(time_stamp)) def data_df_xueqing(): client = pymongo.MongoClient('192.168.5.52', 50000) db = client['king'] pk10 = db['game'] pk11 = db['student'] game_data = pk10.find() projection_fields = { '_id': False,
def get_parser(self, prog_name): parser = super(RestAPIServe, self).get_parser(prog_name) parser.add_argument('--port', metavar='<port>', help='port for HTTP serving.') return parser def take_action(self, parsed_args): app = Flask('Tutorial') API.init_app(app) return app.run(debug=True, host='0.0.0.0', port=getattr(parsed_args, 'port', 8080)) ns = API.namespace('sub1') @ns.route('/api/v1/sub1/cmd1', methods=['GET', 'POST', 'DELETE']) class Sub1Cmd1(Resource): @ns.doc('get') @ns.param('arg1', 'String value') @ns.param('arg2', 'String value') def get(self): parser = reqparse.RequestParser() parser.add_argument('arg1', required=True, type=str, location='args') parser.add_argument('arg2', required=True, type=str, location='args') args = parser.parse_args() ss = StringStream() ret = TutorialSub1Command1(Tutorial(stdout=ss), args,
app = Flask(__name__) app_ = Api(app=app, version='1.0', title='Imobiliaria', description='Sistema de venda de imóveis') app.config[ 'SQLALCHEMY_DATABASE_URI'] = 'postgresql://*****:*****@localhost:5432/Imobiliaria' app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False app.debug = True app.secret_key = "alquimia" db = SQLAlchemy(app) CORS(app) ########### ÁREAS DO SWAGGER ########### cliente = app_.namespace('Clientes', descrition='Cliente') transacao = app_.namespace('Transacao', descrition='transacao') imoveis = app_.namespace('Imoveis', descrition='Imoveis') pessoas = app_.namespace('Pessoas', descrition='Dados pessoais dos clientes') enderecos = app_.namespace('Endereco', descrition='Imoveis') ########### CLASSES PARA A CRIAÇÃO DAS TABELAS ########### class Tipo(db.Model): __tablename__ = 'tipo' id_tipo = db.Column(db.Integer, primary_key=True, autoincrement=True, unique=True) tipo = db.Column(db.String)
file = open("aws-credentials.txt", "r") contents = file.read() dictionary = ast.literal_eval(contents) file.close() print(type(dictionary)) print(dictionary) # # Flask # app = Flask(__name__) api = Api(app) ns = api.namespace('automation/api/v1.0/prediction/admin', description='administration') @ns.route('/is-alive') # Create a URL route to this resource class HeartBeat(Resource): # Create a RESTful resource def get(self): # Create GET endpoint """Returns an heart beat.""" return {'answer': 'ok'} @ns.route("/models") class Model(Resource): def get(self): """Returns the list of ML models.""" return modelDictionary
from flask import Flask, url_for, jsonify from elasticsearch import Elasticsearch es_host = {"host": "elasticsearch1", "port": 9200} es = Elasticsearch([es_host], retry_on_timeout=True, maxsize=25) app = Flask(__name__) api = Api(app, version='1.0', title='Get Product And \"like\" Product Details', description='Simple Product API Endpoints', prefix="/v1", contact="*****@*****.**", contact_url="www.swarmee.net") app.wsgi_app = ProxyFix(app.wsgi_app) ns = api.namespace('product', description='Simple Product API operations') @ns.route('/search/<searchTerms>') class productSearch(Resource): def get(self, searchTerms): productSearchResponse = es.search( index="products", body="{\"query\": {\"query_string\": {\"query\": \"%s\"}}}" % searchTerms) productSearchClientResponse = [] for row in productSearchResponse["hits"]["hits"]: productSearchClientResponse.append(row["_source"]) return jsonify(productSearchClientResponse)
# @author Alex Gomes # @create date 2020-11-09 21:47:18 # @modify date 2020-11-27 15:26:28 # @desc [Blueprint for the API, including the API and namespaces.] from flask import Blueprint from flask_restplus import Api from modules.apis.v1.db_controller import DBController bp = Blueprint('api', __name__) api = Api(bp, version='1.0', prefix='', title='Double A DBMS API', description='A simple DBMS API linked to an Oracle DB.') ns_crud = api.namespace('crud', description='CREATE | READ | UPDATE | DELETE') ns_stats = api.namespace('stats', description='STATISTICS') dbc = DBController()
from application import app from flask import render_template from application.models import * from flask_restplus import Api, Resource, fields from flask.ext.restplus.reqparse import RequestParser from flask.ext.restplus.inputs import date api = Api(app, version='1.0', title='ElesVotam API') ns = api.namespace('elesvotam', description='ElesVotam operations') votacao_parser = RequestParser() votacao_parser.add_argument('votacaoid', type=int) votacao_fields = {'votacaoid': fields.Integer(), 'sessao_id': fields.Integer(), 'tipo': fields.String(), 'materia': fields.String(), 'ementa': fields.String(), 'resultado': fields.String(), 'presentes': fields.String(), 'sim': fields.Integer(), 'nao': fields.Integer(), 'abstencao': fields.Integer(), 'branco': fields.Integer(), 'notas_rodape': fields.String(), } votacao_model = api.model('Votacao', votacao_fields) @ns.route('/votacao') class ElesVotamVotacaosApi(Resource):
from flask import Flask, request, send_file, jsonify from flask_restplus import Resource, Api from werkzeug.datastructures import FileStorage from threading import Thread from settings import BaseConfig from job_model import JobStatus, Job, JobSchema # Extensions initialization # ========================= app = Flask(__name__) api = Api(app, version='1.0', title='Name classificator study API', description='This service using for training name classification model', ) ns = api.namespace('new-jobs', description='Jobs for ML models study') upload_parser = api.parser() upload_parser.add_argument('file', location=BaseConfig.UPLOAD_DIR, type=FileStorage, required=True) # Data layer - Collections # ======================== jobs = [] # Routes # ====== @ns.route('/') class JobList(Resource): # Shows a list of all jobs, and lets you POST to add new jobs def get(self):
'Hospitals', type=list, required=True, help="The list of hospitals to remove the patient's connection to", location='json') parser.add_argument( 'Tags', type=list, required=True, help= "The tags which the patient has selected to select subsets of their data", location='json') # parser.add_argument('filters', type=list, required=False, help="Any filters that the patient wants to apply to their data, such as episode number", location='json') # Routes hello_space = api.namespace( 'hello', description='Check the Smart Patient Health Record Server is on') rule_space = api.namespace('rules', description='Add, remove, update, and view rules') user_space = api.namespace('users', description='Add and remove users') t_and_d = api.namespace( 'helper', description='Get the tags and doctors for each hospital') get_space = api.namespace( 'api', description='Get the encrypted Smart Patient Health Record') test_space = api.namespace('dev', description='Access to unencrypted data') @hello_space.route('/hello') class ServerCheck(Resource): @api.marshal_with(hello) def get(self): return {"hello": "Welcome to the SPHR API. The server is on"}
#! /usr/bin/env python # -*- coding: utf-8 -*- from flask import Flask from flask_restplus import Api, Resource, fields from subprocess import check_output import sys import os import shutil app = Flask(__name__) api = Api(app, version='0.1', title='Speak API', description='Get phonemes of a text from various TTS backends') ns = api.namespace('speaks', descripton='Speak operations') Backends = { 'espeak': { 'binary': '', 'info': 'http://espeak.sourceforge.net/', 'availability': ['darwin', 'linux', 'win32', 'cygwin'], 'parameters': [ {'name': 'text', 'arg': ' ', 'type': 0, 'required': True}, {'name': 'phoneme', 'arg': '-x'}, {'name': 'quiet', 'arg': '-q'}, ], }, 'flite': { 'binary': '', 'info': 'http://www.festvox.org/flite/',
# Packages to import from flask import Flask, jsonify, request from flask_restplus import Resource from flask_restplus import Api from app.utils.invalidusage import InvalidUsage from app.utils.models import return_features_model from app.mlmodels.automl import features, predict, train, server_status # Initialize de api app = Flask(__name__) api = Api(app=app, title="ML model serving", description="Create rest microservice to serve an ML Model") name_space = api.namespace('ML Model', description='API ML') features_model = return_features_model(api) @api.route('/predict', methods=['POST']) class Predict(Resource): @api.expect(features_model) @api.response(200, 'Value predicted.') @api.response(400, 'Could not predict the value.') def post(self): """Handle request and return prediction in json format.""" # Handle empty requests. if not request.json: raise InvalidUsage('No request received') elif set(request.json.keys()) != set(features): raise InvalidUsage('Wrong features', status_code=418) x_list = request.json try:
routes, api ) app = Flask(__name__, template_folder='src/view/pages', static_folder='src/view/static') config_module = 'local_config' if os.path.isfile('local_config.py') else 'config' app.config.from_object(config_module) restplus_api = Api(app, version='1.0', title='bubup !' ) ns = restplus_api.namespace(name='api', description='WOW bubup !') mongo_instance = Database(app) api.initialize(ns, restplus_api, mongo_instance) routes.initialize(app, mongo_instance) if __name__ == '__main__': # for x in app.url_map.iter_rules(): # print x app.run(threaded=True, debug=True, use_reloader=False, host='192.168.56.101', port=5001)
++ The Application can also be called (GET) with the ID & if ID exists in the DB (list_of_names) name etc info is returned. """ #Importing Flask & Flask Restplus from flask import Flask, request from flask_restplus import Api, Resource, fields flask_app = Flask(__name__) app = Api(app=flask_app, version="1.0", title="Bank Account Recorder", description="Manage names of bank Accounts") # Note the below will be the root of the URL http://localhost:5000/bank/{id} (GET, POST etc) bank_space = app.namespace("bank", description="Bank Namespace") #In the MVC, the below is defining our Model aka the database. bank_model_dict = { "name": fields.String(required=True, description="Name of the Account", help="Name cannot be blank") } model = app.model("Bank Model", bank_model_dict) #Dictionary which will act as in-memory DB list_of_names = {} #The root expects that a id (Integer) is sent.
from flask import Flask, json, jsonify, render_template, request from bson import json_util from datetime import datetime from urlparse import urlparse, parse_qs from pymongo import MongoClient from flask_restplus import Api, Resource, fields, swagger app = Flask(__name__) api = Api(app, version="1.0", title="My API", description="Flask-RestPlus 사용해보자") client = MongoClient("mongodb://t.com:27017") db = client.mydb ns = api.namespace("Member", description="MemberAPI") @ns.route("/<string:name>") @api.doc(params={"name": "member name"}) class Member(Resource): @app.route("/Member/<name>", methods=["POST"]) def post(name): data = {"age": 30, "name": name, "cdate": datetime.now()} db.member.insert(data) return name @app.route("/Member/<name>") def get(name): data = json_util.dumps(db.member.find({"name": name})) return render_template("user.html", users=json.loads(data))
import base64 import mysql.connector from threading import Lock from flask import Flask, request from flask_cors import CORS from flask_restplus import Resource, Api, fields from common import * app = Flask(__name__) api = Api(app, title='Book Barter Favourites API') CORS(app) ns = api.namespace('Favourites', description='Favourites operations') lock = Lock() connection = mysql.connector.connect(host='localhost', user='******', password='******', database='favourites') cursor = connection.cursor(buffered=True, dictionary=True) favourites_fields = api.model('Favourites', { 'bookId': fields.String, }) @api.route('/favourite') class Favourite(Resource):
TOKEN_EXPIRES_IN_SECONDS = 180 ACCESS_TOKEN = "access_token_cookie" app = Flask(__name__, static_url_path = "") api_app = Api(app = app, version = "0.1", title = "Project app API", description = "REST-full API for library", doc="/api") db = redis.Redis(host = "redis", port = 6379, decode_responses = True) app.secret_key = os.environ.get(SECRET_KEY) app.config["JWT_SECRET_KEY"] = os.environ.get(SECRET_KEY) app.config["JWT_TOKEN_LOCATION"] = ["cookies", "headers"] app.config["JWT_ACCESS_TOKEN_EXPIRES"] = TOKEN_EXPIRES_IN_SECONDS jwt = JWTManager(app) CORS(app) login_namespace = api_app.namespace("api/log", description = "Login API") registration_namespace = api_app.namespace("api/register", description = "Registration API") user_namespace = api_app.namespace("api/user", description = "User API") @user_namespace.route("/<string:username>") class User(Resource): def __init__(self, args): super().__init__(args) new_user_model = api_app.model("User model", { "login": fields.String(required = True, description = "Login", help = "Login cannot be null", example = "login") }) def get(self, username): username = username.encode("utf-8")
from settings import BaseConfig from job import JobStatus, Job, JobSchema from classificator_config import ModelConfig, ModelConfigSchema # Extensions initialization # ========================= app = Flask(__name__) api = Api( app, version='1.0', title='Name classificator API', description='This service using for product by name classification', ) ns_jobs = api.namespace('jobs', description='Jobs for classification by name') ns_ml_models = api.namespace('ml-models', description='Domain for controlling ML models') upload_parser = api.parser() upload_parser.add_argument('file', location=BaseConfig.UPLOAD_DIR, type=FileStorage, required=True) upload_parser2 = api.parser() upload_parser2.add_argument('file', location=BaseConfig.ML_MODELS_DIR, type=FileStorage, required=True)
title='API for users management', description='A demonstration of a Flask RestPlus powered API') os_user = api.model( 'User', { 'username': fields.String(required=True, description='username to be created', example='operativos'), 'password': fields.String(required=True, description='password for the username', example='mysecurepass'), }) ns = api.namespace('v1.0/users', description='Operations related to create users') @ns.route('/') #@api.route(api_url+'/users') class UserCollection(Resource): @api.response(200, 'List of users successfully returned.') def get(self): """ returns a list of users """ list = {} list["users"] = get_all_users() return json.dumps(list), 200 @api.response(201, 'User successfully created.') @api.expect(os_user) def post(self):
from keras.preprocessing.image import img_to_array from keras.models import load_model from flask_restplus import Api, Resource, fields from flask import Flask, jsonify, request, make_response, abort, render_template, redirect, url_for from firebase_admin import credentials, firestore, initialize_app import datetime import numpy as np from werkzeug.datastructures import FileStorage from PIL import Image from keras.models import model_from_json import tensorflow as tf application = app = Flask(__name__) api = Api(app, version='1.0', title='MNIST Classification', description='CNN for Mnist') ns = api.namespace('Make_School', description='Methods') # Initialize Firestore DB cred = credentials.Certificate('key.json') default_app = initialize_app(cred) db = firestore.client() todo_ref = db.collection('mnist_responses') single_parser = api.parser() single_parser.add_argument('file', location='files', type=FileStorage, required=True) # CNN model can be found here # https://www.kaggle.com/raymonddashwu/ds2-2-hw2-mnist-mlp-cnn model = load_model('mnist_cnn.h5') graph = tf.get_default_graph()
import werkzeug werkzeug.cached_property = werkzeug.utils.cached_property from flask import Flask from flask_restplus import Api, Resource from connector import construct_con_str from logic import crimes_between_dates, total_burglary from decorators import Decorators import configparser app = Flask(__name__) app.config["SQLALCHEMY_DATABASE_URI"] = construct_con_str() app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False api = Api(app) ns = api.namespace("rest", description="Assignment Rest") @ns.route("/<string:fromdate>=<string:todate>") @api.response(404, "Nothing here but us lemmings") class ResToFrom(Resource): def get(self, fromdate, todate): return crimes_between_dates(fromdate, todate) def post(self, fromdate, todate): # I don't see the point in making a post method here as per the assignment desc... return None, 201 @ns.route("/burglary") @api.response(404, "Nothing here but us lemmings")
authorizations = { 'Basic Auth': { 'type': 'basic', 'in': 'header', 'name': 'Authorization' } } api = Api(app, authorizations=authorizations, version='1.0', title='Projects & Actions Api', description="Storing user's projects and actions") namespace = api.namespace('', description='Main API Routes') post_fields = namespace.model("Register", { 'email': fields.String, 'password': fields.String }) @namespace.route("/api/users/register") class Users(Resource): @namespace.doc(description='Add a user') @namespace.expect(post_fields) def post(self): req = request.get_json() email = req.get('email') password = req.get('password')
access_logger.access(log_data) return self.app(environ, start_response) app = Flask(__name__) app.config.SWAGGER_UI_DOC_EXPANSION = 'list' app.wsgi_app = LoggerMiddleware(app.wsgi_app) api = Api(app, version='1.0', title='Gateway helper', description='Gateway support APIs', doc='/') to_line = api.namespace('toLINE', description='To LINE APIs') from_addr = api.namespace('internal/addr', description='From Addr APIs') #TODO: check parser param # https://flask-restplus.readthedocs.io/en/stable/api.html parser = api.parser() #TODO: make model file line_header_fields = api.model('LineHeaderModel', { 'botId': fields.String(description='Caller LINE bot id', required=True), }) get_line_profile_model = api.model('GetLineProfileModel', { 'uuid': fields.Integer(description='uuid', required=True), })
from flask_restplus import fields from flask_sqlalchemy import SQLAlchemy # what's happening # welcome to flask: http://flask.pocoo.org/ # working with sqlalchemy & swagger: # http://michal.karzynski.pl/blog/2016/06/19/building-beautiful-restful-apis-using-flask-swagger-ui-flask-restplus/ # simple flask app definitions application = Flask(__name__) api = Api(application) application.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///db.sqlite' db = SQLAlchemy(application) # renames namespace ns = api.namespace('api', description='Store where you can add your own items and search through them') ''' json marshaller (object <-> json) ''' # input item item = api.model('item', { 'name': fields.String(required=True, description='item name'), 'description': fields.String(required=True, description='item description'), 'price': fields.Float(required=True, description='item price'), 'size': fields.Integer(required=True, description='item size'), 'color': fields.String(required=True, description='item color'), 'availability': fields.String(required=True, description='item availability'), }) # item with ID
# -*- coding: utf-8 -*- from application import app from flask import render_template from application.models import * from flask_restplus import Api, Resource, fields from flask.ext.restplus.reqparse import RequestParser from flask.ext.restplus.inputs import date import application.script_creator2 as sc import json import random api = Api(app, version='1.0', title=u'Mobiliário Urbano API', doc='/api') ns = api.namespace('MobUrb', description=u'Mobiliário Urbano Operations') video_parser = RequestParser() video_parser.add_argument('video_id', type=int) video_fields = {'id': fields.Integer(), 'name': fields.String(), 'duration': fields.Float(), 'high_def': fields.String(), 'standard_def_big': fields.String(), 'standard_def_small': fields.String(), } video_model = api.model('Video', video_fields) @app.route('/roteiro') @app.route('/roteiro/<slug>') def roteiro(slug=None):
from flask import Flask, request, jsonify, make_response from flask_restplus import Api, Resource, fields from sklearn.externals import joblib import numpy as np import sys flask_app = Flask(__name__) app = Api(app=flask_app, version="1.0", title="ML React App", description="Predict results using a trained model") name_space = app.namespace('prediction', description='Prediction APIs') model = app.model( 'Prediction params', { 'Recency': fields.Float(required=True, description="Recency Value", help="Recency Value cannot be blank"), 'Frequency': fields.Float(required=True, description="Frequency Value", help="Frequency Value cannot be blank"), 'Monetary': fields.Float(required=True, description="Monetary Value", help="Monetary Value cannot be blank"), }) classifier = joblib.load('classifier.joblib')
from flask_restplus import Api, Resource, fields, reqparse import summarize import textrank import datetime from app import app description = """ An API to generate summaries of submitted text """ api = Api(app, version='1.0', title='Summarizer API', description=description,) # URLs for this namespace are prefixed with /api/ ns = api.namespace('api', description='Summary Generation operations') # Defines a model for Summaries # based on the dataframe already generate by Crawler summary = api.model('Summary', { 'article_summary': fields.String, 'algorithm': fields.String, 'utc_date_generated': fields.DateTime()}) @ns.route('/summarize') class Summary(Resource): """ Returns a summary from entered text : article_summary: Shortened text algorithm: algorithm used utc_date_generated: Timezone aware timestamp (UTC)
from flask import Flask from flask_restplus import Api, Resource, fields from werkzeug.contrib.fixers import ProxyFix app = Flask(__name__) app.wsgi_app = ProxyFix(app.wsgi_app) api = Api( app, version='1.0', title='TodoMVC API', description='A simple TodoMVC API', ) ns = api.namespace('todos', description='TODO operations') todo = api.model( 'Todo', { 'id': fields.Integer(readOnly=True, description='The task unique identifier'), 'task': fields.String(required=True, description='The task details') }) class TodoDAO(object): def __init__(self): self.counter = 0 self.todos = []
from flask import Flask, request, jsonify, make_response from flask_restplus import Api, Resource, fields from sklearn.externals import joblib flask_app = Flask(__name__) app = Api(app = flask_app, version = "1.0", title = "ML React App", description = "Predict results using a trained model") name_space = app.namespace('prediction', description='Prediction APIs') model = app.model('Prediction params', {'textField1': fields.String(required = True, description="Text Field 1", help="Text Field 1 cannot be blank"), 'textField2': fields.String(required = True, description="Text Field 2", help="Text Field 2 cannot be blank"), 'select1': fields.Integer(required = True, description="Select 1", help="Select 1 cannot be blank"), 'select2': fields.Integer(required = True, description="Select 2", help="Select 2 cannot be blank"), 'select3': fields.Integer(required = True, description="Select 3", help="Select 3 cannot be blank")}) # classifier = joblib.load('classifier.joblib')
from flask import Flask, request from flask_restplus import Api, Resource, fields from werkzeug.utils import cached_property import logging as logger logger.basicConfig(level="DEBUG") app = Flask(__name__) # Flask App 생성한다 api = Api(app, version='1.0', title='상품 관리 API', description='상품 등록,수정,삭제,조회 API입니다') # API 만든다 ns = api.namespace('goods', description='상품 등록,수정,삭제,조회') # /goods/ 네임스페이스를 만든다 # REST Api에 이용할 데이터 모델을 정의한다 model_goods = api.model( 'row_goods', { 'id': fields.Integer( readOnly=True, required=True, description='상품번호', help='상품번호는 필수'), 'goods_name': fields.String(required=True, description='상품명', help='상품명은 필수') }) class GoodsDAO(object): '''상품정보 Data Access Object''' def __init__(self): self.counter = 0
summarizer.stop_words = get_stop_words(self.LANGUAGE) summary = " ".join([obj._text for obj in summarizer(parser.document, length)]) return summary app = Flask(__name__) api = Api(app, version='1.0', title='Summary API', description='A simple review summarization API which uses Python\'s sumy library' ) app.config.SWAGGER_UI_DOC_EXPANSION = 'list' ns = api.namespace('sum/v1.0', 'Text Summary v1.0 ') parser = api.parser() parser.add_argument('reviews', required=True, location='json', help='Input Format -> {"reviews":[ {"reviewer_id":"string","reviewee_id":"string","score":"string","feedback":"string"}]}') parser_sum = api.parser() parser_sum.add_argument('sentences', required=True, location='json', help='Input Format -> {"sentences":["sentence1"]') ###### Definition of data model for documentation summary_marshaller = api.model('summary_marshaller',{ 'summary': fields.String(description='Summary of the review') }) message_marshaller = api.model('message_marshaller',{ 'message': fields.String(description='Api call status', required=True)
# -*- coding: utf-8 -*- from flask import Blueprint from flask_restplus import Api app = Blueprint('api', __name__) api = Api(app, version='1.0', title='GST API', description='GST API for Game Manager', catch_all_404s=True) ns_users = api.namespace('users') ns_posts = api.namespace('posts')
from flask import Flask from flask_restplus import Api, Resource VERSION = '0.1.0' app = Flask(__name__) api = Api(app, version=VERSION, title='Fibonacci Sequence API', description='An API that returns the first n integers of the Fibonacci Sequence.', validate=True ) ns = api.namespace('fibonacci', description='fibonacci operation') @ns.route('/<path:input>') @api.response(200, 'Success - sequence returned') @api.response(400, 'Invalid Input') @api.doc(params={'input': 'The count of Fibonacci sequence numbers to return.'}) class Fibonappi(Resource): '''Get the desired count of numbers in the Fibonacci sequence.''' def abort_if_non_int(self, input): try: return int(input) except ValueError: api.abort(400, 'Invalid input {}. Integer required.'.format(input)) def abort_on_negative(self, number): if number < 0: api.abort(400, "The number {} does not work for the Fibonacci sequence.".format(number))
# Disable CSRF protection for this example. In almost every case, # this is a bad idea. See examples/csrf_protection_with_cookies.py # for how safely store JWTs in cookies app.config['JWT_COOKIE_CSRF_PROTECT'] = False # Set the secret key to sign the JWTs with app.config['JWT_SECRET_KEY'] = 'super-secret' # Change this! jwt = JWTManager(app) # Use the set_access_cookie() and set_refresh_cookie() on a response # object to set the JWTs in the response cookies. You can configure # the cookie names and other settings via various app.config options ns = api.namespace('token', description='Operations related to blog categories') xy = ns.model( 'auth', { 'username': fields.String(attribute='username'), 'password': fields.String(attribute='password') }) yz = ns.model('refresh', { 'xy': fields.String(attribute='xy'), }) userDict = {} # initialize users at startup - fetch this from db ## This is used to register a new user
### API Controllers ### # And create the flask-restplus API api = Api(module_one, doc='/doc/', version='1.0', title='Module One API', description="""\ This is the API for Module One. It does the following: * Records greetings for users given by user name * Looks up the greeting for a user given by user name """) # This is the route namespace for the API ns = api.namespace("api", description="Module One API") # Describe the model used by the API m1 = api.model("Module One", { "user_name": fields.String(required=True, description="The name of the user"), "greeting": fields.String(description="A specific greeting for a user"), }) # the data store :) class UserGreetings(dict): def validate(self, data): if "user_name" not in data: abort(400, "Invalid request") user_greetings = UserGreetings()
''' import sqlite3 import datetime import requests import json from flask import Flask from flask_restplus import Resource, Api, fields, reqparse app = Flask(__name__) api = Api(app) db_file_name = 'data.db' indicator = api.model('indicator', {'indicator_id': fields.String('NY.GDP.MKTP.CD')}) ns = api.namespace("collections", description="Operations related to collections of data") def create_db(db_file): conn = sqlite3.connect(db_file) c = conn.cursor() c.execute( """CREATE TABLE IF NOT EXISTS collections (collection_id varchar(20) ,indicator varchar(20), indicator_value varchar(20), creation_time varchar(20), country varchar(20), date varchar(20), value real(20))""") conn.commit() return conn
from flask import Flask from flask_restplus import Api, Resource, fields from werkzeug.contrib.fixers import ProxyFix app = Flask(__name__) app.wsgi_app = ProxyFix(app.wsgi_app) api = Api(app, version='1.0', title='TodoMVC API', description='A simple TodoMVC API', ) ns = api.namespace('todos', description='TODO operations') todo = api.model('Todo', { 'id': fields.Integer(readOnly=True, description='The task unique identifier'), 'task': fields.String(required=True, description='The task details') }) class TodoDAO(object): def __init__(self): self.counter = 0 self.todos = [] def get(self, id): for todo in self.todos: if todo['id'] == id: return todo api.abort(404, "Todo {} doesn't exist".format(id)) def create(self, data): todo = data
__author__ = 'Denys.Meloshyn' from flask_restplus import Api from flask_passlib import Passlib from flask_restful import reqparse from flask_sqlalchemy import SQLAlchemy db = SQLAlchemy() passlib = Passlib() api = Api() user_name_space = api.namespace('user', description='User requests') team_expense_name_space = api.namespace('', description='Team expense requests') synchronise_name_space = api.namespace('synchronise', description='Synchronisation requests') parser = reqparse.RequestParser() parser.add_argument('task', type=str) token_secretKey = 'MY_SECRET_KEY'