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'
