예제 #1
0
파일: app.py 프로젝트: joansanchez/asw
from google_login import validate_token
from persistence import Persistence
from token_generator import encode_auth_token, decode_auth_token
from user import User
from usercommentvoted import UserCommentVoted
from usercontributionvoted import UserContributionVoted

app = Flask(__name__, static_folder='./static')
CORS(app)

SWAGGER_URL = '/api/docs'
swagger_path = os.environ['SWAGGER']

swagger_yml = load(open(swagger_path, 'r'), Loader=Loader)

blueprint = get_swaggerui_blueprint(SWAGGER_URL, swagger_path, config={'spec': swagger_yml})

app.register_blueprint(blueprint, url_prefix=SWAGGER_URL)


@app.route('/')
def home():
    contributions = Contribution.get_news_home(repository)
    username = decode_auth_token(request.cookies.get('token'))
    if username is not None:
        contributions_voted = UserContributionVoted.get_voted(repository, username)
        for c in contributions:
            c.voted = c['id'] in [cv['contribution_id'] for cv in contributions_voted]
            aux = Comment.get_number_comments_by_contribution(repository, str(c['id']))
            c['n_comments'] = aux[0]['n_comments']
        user = User.get(repository, username)
예제 #2
0
from app import app
from flask import Blueprint, jsonify
from flask_swagger import swagger
from flask_swagger_ui import get_swaggerui_blueprint


SWAGGER_URL = "/api/docs"
API_URL = "http://*****:*****@swag.route("/spec")
def spec():
    return jsonify(swagger(app))


swaggerui_blueprint = get_swaggerui_blueprint(
    SWAGGER_URL,
    API_URL,
    config={
        "app_name": "Fidelio"
    }
)
예제 #3
0
from flask_swagger_ui import get_swaggerui_blueprint

SWAGGER_URL = "/swagger-ui"  # URL for exposing Swagger UI
API_URL = "/swagger/"

# Call factory function to create our blueprint
swaggerui_blueprint = get_swaggerui_blueprint(
    SWAGGER_URL,
    API_URL,
    config={
        "layout": "BaseLayout",
        "deepLinking": "true",
    },  # Swagger UI config overrides
    oauth_config={
        "clientId": "Zeu4TO3koxp6ubeebSMbgb0DRLbjLT69",
        "scopeSeparator": " ",
        "additionalQueryStringParams": {},
    },
)
예제 #4
0
from flask_swagger_ui import get_swaggerui_blueprint
#from flask_swagger import swagger
#from wtforms import StringField, PasswordField, BooleanField, SubmitField
#from pyppeteer import launch
from flask_restplus import Resource, Api
from pyppe import html_to_pdf
import asyncio
#import json

app = Flask(__name__)
api = Api(app, version='1.0', title='Sample API', description='A sample API')

SWAGGER_URL = '/swagger'
API_URL = '/static/swagger.yml'

SWAGGERUI_BLUEPRINT = get_swaggerui_blueprint(
    SWAGGER_URL, API_URL, config={'app_name': "HTML to PDF"})
app.register_blueprint(SWAGGERUI_BLUEPRINT, url_prefix=SWAGGER_URL)

app.config['SECRET_KEY'] = '123'

# model = api.model('Name Model',
# 		  {'path_page': fields.String(required = True,
# 					 description="Page URL",
# 					 help="")})


@app.route('/', methods=['GET', 'POST'])
def index():
    form = InterfaceForm()
    if form.validate_on_submit():
        flash('Path is: {}'.format(form.path.data))
예제 #5
0
from flask_swagger_ui import get_swaggerui_blueprint
from flask import Flask
from sqlalchemy import create_engine, MetaData

app = Flask(__name__, instance_relative_config=True)
app.config.from_pyfile('config.py')

# swagger specific #
SWAGGER_URL = '/swagger'
API_URL = '/static/swagger.yaml'
SWAGGERUI_BLUEPRINT = get_swaggerui_blueprint(
    SWAGGER_URL,
    API_URL,
    config={
        'app_name': "GENE-SEARCH-REST-API"
    }
)
app.register_blueprint(SWAGGERUI_BLUEPRINT, url_prefix=SWAGGER_URL)
# end swagger specific #
connection = "mysql://{user}@{host}:{port}/{database}".format(user=app.config['USER'], host=app.config['HOST'],
                                                              port=app.config['PORT'], database=app.config['DATABASE'])
engine = create_engine(connection)
metadata = MetaData(bind=engine)
from app import views
예제 #6
0
import datetime
from app import app
from db_conf import mysql
from flask import jsonify
from flask import flash, request, Flask
from flask_restful import Resource, Api
from flask_swagger_ui import get_swaggerui_blueprint
import os

app = Flask(__name__)
api = Api(app, prefix="/api/v1")

### swagger specific ###
SWAGGER_URL = '/api/v1/swagger'
API_URL = '/schema/swagger.json'
SWAGGERUI_BLUEPRINT = get_swaggerui_blueprint(
    SWAGGER_URL, API_URL, config={'app_name': "Contact_API_Code_Challenge"})
app.register_blueprint(SWAGGERUI_BLUEPRINT, url_prefix=SWAGGER_URL)

### end swagger specific ###
#app.register_blueprint(request_api.get_blueprint())

# 1 Operations: POST / GET / PUT / PATCH / DELETE
# 2 Delete operation just updates the status in DB (Soft Delete).
# 3 All queries involving the active flow (GET / PUT / PATCH)  will ignore all such entries with the condition ‘del_flag = true’
# 4 By default when a new record is created in database. del_flag is set to False
# 5 PUT and PATCH operation do not allow updating the primary fields(first_name, last_name, dob and gender)


#This class holds the functions for adding and retreiving Contact Collections. Input body is expected to be an arry
class Contact_Collection(Resource):
    #This function adds Contact identifocation information in Identification table, gets the id and adds cmmunication and address information against that identification id.
예제 #7
0
import json
from ir_eval.ranking.main import ranked_retrieval
from ir_eval.ranking.movie_search import ranked_movie_search
import re
import time
from ir_eval.preprocessing import preprocess
from api.utils.cache import ResultsCache
from query_completion.model import predict_next_word

app = Flask(__name__)
CORS(app)

SWAGGER_URL = '/api/docs'
API_URL = '/static/swagger.json'

swaggerui_blueprint = get_swaggerui_blueprint(
    SWAGGER_URL, API_URL, config={'app_name': "TTDS Movie Search"})
app.register_blueprint(swaggerui_blueprint, url_prefix=SWAGGER_URL)

db = get_db_instance()
cache = ResultsCache.instance(
)  # Usage: cache.get(params, which_cache), cache.store(params, output, which_cache)
QUOTES_CACHE = 'quotes'
MOVIES_CACHE = 'movies'


@app.route('/')
def home():
    return 'Hello, World!'


def merge_lists(l1, l2, key):
예제 #8
0
app.config.from_mapping({
    "CACHE_TYPE": "simple",
    "CACHE_DEFAULT_TIMEOUT": 3600,
})
cache = Cache(app)

##################################################
# SWAGGER DOCUMENTATION

SWAGGER_URL = '/docs'
API_DEF_URL = "http://%s:%s/swagger.json" % (config['swagger']['host'],
                                             config['swagger']['port'])

swaggerui_blueprint = get_swaggerui_blueprint(
    SWAGGER_URL,
    API_DEF_URL,
    config={'app_name': "CDLI Numeral Conversion"},
)
app.register_blueprint(swaggerui_blueprint, url_prefix=SWAGGER_URL)

##################################################
# DECORATORS to enforce proper request format
# and allow JSONP GET requests:


def enforce_params(required=[]):
    """
    Decorator to enforce that a flask endpoint only
    accepts json-formatted queries, and to enforce
    that required parameters are present.
예제 #9
0
    def init_app(self,
                 app,
                 host="localhost",
                 port=5000,
                 prefix="",
                 app_db=None,
                 json_encoder=SAFRSJSONEncoder,
                 swaggerui_blueprint=True,
                 **kwargs):
        """
            API and application initialization
        """
        if not isinstance(app, Flask):
            raise TypeError("'app' should be Flask.")

        if app_db is None:
            self.db = DB

        app.json_encoder = json_encoder
        app.request_class = SAFRSRequest
        app.response_class = SAFRSResponse
        app.url_map.strict_slashes = False

        if app.config.get("DEBUG", False):
            log.setLevel(logging.DEBUG)

        # Register the API blueprint
        if swaggerui_blueprint is True:
            swaggerui_blueprint = get_swaggerui_blueprint(
                prefix,
                "{}/swagger.json".format(prefix),
                config={
                    "docExpansion": "none",
                    "defaultModelsExpandDepth": -1
                })
            app.register_blueprint(swaggerui_blueprint, url_prefix=prefix)
            swaggerui_blueprint.json_encoder = JSONEncoder

        for conf_name, conf_val in kwargs.items():
            setattr(self, conf_name, conf_val)

        for conf_name, conf_val in app.config.items():
            setattr(self, conf_name, conf_val)

        self.config.update(app.config)

        @app.before_request
        def handle_invalid_usage():
            return

        @app.before_request
        def init_ja_data():
            # ja_data holds all data[] that will be encoded
            g.ja_data = set()
            g.ja_included = set()

        # pylint: disable=unused-argument,unused-variable
        @app.teardown_appcontext
        def shutdown_session(exception=None):
            """cfr. http://flask.pocoo.org/docs/0.12/patterns/sqlalchemy/"""
            self.db.session.remove()
예제 #10
0
"""A Python Flask REST API BoilerPlate (CRUD) Style"""

import argparse
import os
from flask import Flask, jsonify, make_response
from flask_cors import CORS
from flask_swagger_ui import get_swaggerui_blueprint
from routes import request_api
import settings

APP = Flask(__name__)

### swagger specific ###
SWAGGER_URL = '/swagger'
API_URL = '/static/swagger.json'
SWAGGERUI_BLUEPRINT = get_swaggerui_blueprint(
    SWAGGER_URL, API_URL, config={'app_name': "rest-api-demo"})
APP.register_blueprint(SWAGGERUI_BLUEPRINT, url_prefix=SWAGGER_URL)
### end swagger specific ###

APP.register_blueprint(request_api.get_blueprint())


@APP.errorhandler(400)
def handle_400_error(_error):
    """Return a http 400 error to client"""
    return make_response(jsonify({'error': 'Misunderstood'}), 400)


@APP.errorhandler(401)
def handle_401_error(_error):
    """Return a http 401 error to client"""
예제 #11
0
def create_app(config: Configuration, tnc_pool: TNCPool, sids_relay: SIDSRelay) -> Flask:
    """ Creates a flask app for the api. """

    log = logging.getLogger(__name__)

    static_folder = os.path.join(util.get_root(), config.get_conf("Client", "static-files-path"))

    app = Flask(__name__, static_url_path="", static_folder=static_folder)
    CORS(app)

    if not config.get_conf("Client", "debug-log"):
        server_log = logging.getLogger("werkzeug")
        server_log.setLevel(logging.WARN)

    # swagger specific
    swagger_url = "/api/docs"
    api_url = "/api/static/swagger.yaml"
    swaggerui_blueprint = get_swaggerui_blueprint(
        swagger_url,
        api_url,
        config={
            "app_name": "Estcube 2 Telemetry API"
        }
    )
    app.register_blueprint(swaggerui_blueprint, url_prefix=swagger_url)

    # end swagger specific

    @app.route("/api/sids/status", methods=["GET"])
    def get_sids_status():
        return jsonify(sids_relay.get_status()), 200

    @app.route("/api/sids/toggle", methods=["POST"])
    def toggle_relay():
        response_json = request.get_json()
        current_relay_status = response_json["Mission Control"]["relay-enabled"]
        config.set_conf(section="Mission Control", element="relay-enabled", value=current_relay_status)
        if current_relay_status:
            threading.Thread(target=sids_relay.relay_unrelayed_packets, daemon=True).start()
        return response_json, 200

    @app.route("/api/tnc/<name>/status", methods=["GET"])
    def get_tnc_connection_check(name: str):
        if tnc_pool is None:
            return jsonify({"error": "TNC Pool is not defined."}), 500

        res = tnc_pool.check_tnc(name)
        return jsonify({"name": name, "status": res.name}), 200

    @app.route("/api/tnc/Main/start", methods=["POST"])
    def post_tnc_main_start():
        if tnc_pool is None:
            return jsonify({"error": "TNC Pool is not defined."}), 500

        tnc_pool.connect_main_tnc()
        return "", 204

    @app.route("/api/tnc/<name>/stop", methods=["POST"])
    def post_tnc_connection_stop(name: str):
        if tnc_pool is None:
            return jsonify({"error": "TNC Pool is not defined."}), 500

        tnc_pool.stop_tnc(name)
        return "", 204

    @app.route("/api/conf", methods=["GET"])
    def getconf():
        """ Returns the whole current configuration object. """
        res = config.get_all_conf()
        return jsonify(res)

    @app.route("/api/conf/constraints", methods=["GET"])
    def get_constraints():
        """ Returns all of the constraints for the configuration. """
        constrs = config.get_constraints()
        return jsonify(constrs)

    @app.route("/api/conf/full", methods=["GET"])
    def get_full_conf():
        res = config.get_conf_with_constraints()
        return res

    @app.route("/", methods=["GET"])
    def get_index():
        return send_file(os.path.join(static_folder, "index.html"))

    @app.errorhandler(404)
    def not_found(e):
        return send_file(os.path.join(static_folder, "index.html"))

    @app.route("/api/static/<path:path>")
    def send_static(path):
        return send_from_directory("static", path)

    @app.route("/api/conf", methods=["POST"])
    def post_set_conf():
        some_json = request.get_json()
        try:
            for i in some_json:
                for j in some_json[i]:
                    config.set_conf(section=i, element=j, value=some_json[i][j])
        except:
            _, error, _ = sys.exc_info()
            return jsonify({"Error": "{err}".format(err=error)}), 500
        return jsonify(some_json), 200

    return app
예제 #12
0
from flask import Flask, request, jsonify
from flask_cors import CORS
from bs4 import BeautifulSoup
import requests
from flask_swagger_ui import get_swaggerui_blueprint

app = Flask(__name__)
CORS(app)

### swagger ###
SWAGGER_URL = '/swagger'
API_URL = '/static/swagger.json'
SWAGGERUI_BLUEPRINT = get_swaggerui_blueprint(
    SWAGGER_URL,
    API_URL,
    config={
        'app_name': "socialmedia-image-scapel"
    }
)
app.register_blueprint(SWAGGERUI_BLUEPRINT, url_prefix=SWAGGER_URL)
### end swagger ###

@app.route('/dribbble/', methods=['GET'])
def dribbble():
    # Retrieve the username from url parameter
    name = request.args.get("name", None)

    # For debugging
    print(f"got name {name}")

    source = requests.get(f"https://dribbble.com/{name}").text
예제 #13
0
try:
    my_ip = get_node_ip()
except:
    pass
else:
    SWAGGER_URL = '/api/docs'
    swagger_address = getenv("SWAGGER_HOST", my_ip)

    if settings['use_ssl']:
        API_URL = 'https://{}/api/swagger.json'.format(swagger_address)
    elif LISTEN == '127.0.0.1' or swagger_address != my_ip:
        API_URL = "http://{}/api/swagger.json".format(swagger_address)
    else:
        API_URL = "http://{}:{}/api/swagger.json".format(swagger_address, PORT)

    swaggerui_blueprint = get_swaggerui_blueprint(
        SWAGGER_URL, API_URL, config={'app_name': "Screenly API"})
    app.register_blueprint(swaggerui_blueprint, url_prefix=SWAGGER_URL)

################################
# Views
################################


@app.route('/')
@auth_basic
def viewIndex():
    player_name = settings['player_name']
    my_ip = get_node_ip()
    resin_uuid = getenv("RESIN_UUID", None)

    ws_addresses = []
예제 #14
0
import argparse
import os
from flask import Flask, jsonify, make_response
from flask_cors import CORS
from flask_swagger_ui import get_swaggerui_blueprint
import request_api

APP = Flask(__name__)

### swagger specific ###
SWAGGER_URL = '/swagger'
API_URL = '/static/swagger.json'
SWAGGERUI_BLUEPRINT = get_swaggerui_blueprint(
    SWAGGER_URL,
    API_URL,
    config={'app_name': "Rebecca-Flask-Rest-UserManagement"})
APP.register_blueprint(SWAGGERUI_BLUEPRINT, url_prefix=SWAGGER_URL)
### end swagger specific ###

APP.register_blueprint(request_api.get_blueprint())


@APP.errorhandler(400)
def handle_400_error(_error):
    """Return a http 400 error to client"""
    return make_response(jsonify({'error': 'Misunderstood'}), 400)


@APP.errorhandler(401)
def handle_401_error(_error):
    """Return a http 401 error to client"""
예제 #15
0
def setup_swaggerui(app):
    SWAGGER_URL = '/swagger'
    API_URL = '/static/swagger.json'
    SWAGGERUI_BLUEPRINT = get_swaggerui_blueprint(
        SWAGGER_URL, API_URL, config={'app_name': "Auth Server"})
    app.register_blueprint(SWAGGERUI_BLUEPRINT, url_prefix=SWAGGER_URL)
예제 #16
0
from flask import Flask
from flask_cors import CORS
from flask_swagger_ui import get_swaggerui_blueprint

app = Flask(__name__)
app.config['SECRET_KEY'] = 'the quick brown fox jumps over the lazy dog'
CORS(app)

SWAGGER_URL = '/swagger'
API_URL = '../static/swagger.json'
SWAGGERUI_BLUEPRINT = get_swaggerui_blueprint(
    SWAGGER_URL,
    API_URL,
    config={
        'app_name': "Backend Info"
    }
)
app.register_blueprint(SWAGGERUI_BLUEPRINT, url_prefix=SWAGGER_URL)

from backend.routing import routes
예제 #17
0

HOST = sys.argv[1] if len(sys.argv) > 1 else "0.0.0.0"
PORT = 5000

# Create the database
db.create_all()

with app.app_context():
    # Create a user
    user = User(name="test", email="em@il")

    api = Api(app,
              api_spec_url="/api/swagger",
              host="{}:{}".format(HOST, PORT),
              schemes=["http"])
    # Expose the User object
    api.expose_object(User)
    # Set the JSON encoder used for object to json marshalling
    app.json_encoder = SAFRSJSONEncoder
    # Register the API at /api/docs
    swaggerui_blueprint = get_swaggerui_blueprint("/api", "/api/swagger.json")
    app.register_blueprint(swaggerui_blueprint, url_prefix="/api")

    @app.route("/")
    def goto_api():
        return redirect("/api")

    print("Starting API: http://{}:{}/api".format(HOST, PORT))
    # app.run(host=HOST, port = PORT)
예제 #18
0
    conf = config.DevelopmentConfig
app.config.from_object(conf)
cors = CORS(app, resources={r"/*": {"origins": "*"}})
"""
    API Routes 
"""
api.add_resource(Account, '/account')
api.add_resource(Login, '/login')
api.add_resource(Todolist, '/lists')
api.add_resource(TodolistId, '/lists/<int:id_list>')
api.add_resource(TodolistIdTodo, '/lists/todos/<int:id_list>')
api.add_resource(TodolistIdTodoId, '/lists/todos/<int:id_list>/<int:id_todo>')
"""
    Swagger
"""


@app.route("/swagger")
def swaggerController():
    swag = swagger(app)
    swag['info']['version'] = config.APP_VERSION
    swag['info']['title'] = config.API_NAME
    return jsonify(swag)


swaggerui_blueprint = get_swaggerui_blueprint(
    conf.SWAGGER_URL,
    conf.DATA_SWAGGER,
    config={'app_name': "Flask API"},
)
app.register_blueprint(swaggerui_blueprint, url_prefix=conf.SWAGGER_URL)
예제 #19
0
# Register Routes
app.register_blueprint(orderRoutes)


### Swagger Documentation ###
@app.route('/swagger.json')  
def send_file():  
    return send_from_directory(app.static_folder, 'swagger.json')

SWAGGER_URL = '/api-docs'
API_URL = '/swagger.json'
SWAGGERUI_BLUEPRINT = get_swaggerui_blueprint(
    SWAGGER_URL,
    API_URL,
    config={
        'app_name': "Orders-API"
    }
)
app.register_blueprint(SWAGGERUI_BLUEPRINT, url_prefix=SWAGGER_URL)
### end swagger specific ###


#### App ####
if __name__ == '__main__':
    ip = '0.0.0.0'
    port = app.config['APP_PORT']
    debug = app.config['DEBUG']

    # execute flask web server
    app.run(
예제 #20
0
        SQLALCHEMY_DATABASE_URI=
        'mysql+mysqlconnector://root:Meh@8567@user_db/user'
        # SQLALCHEMY_DATABASE_URI='mysql+mysqlconnector://root:Meh@8567@localhost:3306/user'
    ))

models.db_init_app(app)
models.ma_init_app(app)
models.create_tables(app)

app.register_blueprint(user_api_blueprint)

SWAGGER_URL = '/api/docs'
API_URL = '/api/user/docs.json'

swaggerui_blueprint = get_swaggerui_blueprint(
    SWAGGER_URL,
    API_URL,
)
app.register_blueprint(swaggerui_blueprint, url_prefix=SWAGGER_URL)


@login_manager.user_loader
def load_user(user_id):
    return models.User.query.filter_by(id=user_id).first()


@login_manager.request_loader
def load_user_from_request(request):

    # try to login using Basic Auth
    api_key = request.headers.get('Authorization')
    if api_key:
예제 #21
0
app.config['SECRET_KEY'] = 'secret!'
socketio = SocketIO(app, cors_allowed_origins="*")

SWAGGER_URL = '/api/docs'  # URL for exposing Swagger UI (without trailing '/')
# Our API url (can of course be a local resource)
API_URL = 'http://localhost:5000/static/swagger.json'

# Call factory function to create our blueprint
swaggerui_blueprint = get_swaggerui_blueprint(
    # Swagger UI static files will be mapped to '{SWAGGER_URL}/dist/'
    SWAGGER_URL,
    API_URL,
    config={  # Swagger UI config overrides
        'app_name': "Test application"
    },
    # oauth_config={  # OAuth config. See https://github.com/swagger-api/swagger-ui#oauth2-configuration .
    #    'clientId': "your-client-id",
    #    'clientSecret': "your-client-secret-if-required",
    #    'realm': "your-realms",
    #    'appName': "your-app-name",
    #    'scopeSeparator': " ",
    #    'additionalQueryStringParams': {'test': "hello"}
    # }
)

app.register_blueprint(swaggerui_blueprint)


@app.before_first_request
def init_database():
    db.create_all()
    print("frist")
예제 #22
0
import os
import traceback
from flask import Flask, jsonify, request, Response
from flask_swagger_ui import get_swaggerui_blueprint

application = Flask(__name__)

### swagger specific ###
SWAGGER_URL = "/documentation"
API_URL = "/static/openapi.json"
SWAGGERUI_BLUEPRINT = get_swaggerui_blueprint(
    SWAGGER_URL, API_URL, config={"app_name": "CARAMLService"})
application.register_blueprint(SWAGGERUI_BLUEPRINT, url_prefix=SWAGGER_URL)
### end swagger specific ###


@application.route("/", methods=["GET", "POST"])
def welcome():
    response_text = """<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
        <title>CARA ML Service</title>
        <h2>Welcome to  !</h2>
        <p></p>"""
    return response_text


@application.route("/do_stuff", methods=["POST"])
def do_stuff():
    content = request.get_json(silent=True)
    try:
        # do something
        return jsonify(content), 200
예제 #23
0
from .serializers import KqueenJSONEncoder
from .storages.etcd import EtcdBackend
from flask import Flask
from flask_jwt import JWT
from flask_swagger_ui import get_swaggerui_blueprint
from werkzeug.contrib.cache import SimpleCache

import logging

logger = logging.getLogger(__name__)
cache = SimpleCache()
swagger_url = '/api/docs'
api_url = '/api/v1/swagger'

swaggerui_blueprint = get_swaggerui_blueprint(swagger_url,
                                              api_url,
                                              config={'docExpansion': 'list'})


def create_app(config_file=None):
    app = Flask(__name__, static_folder='./asset/static')
    app.json_encoder = KqueenJSONEncoder

    app.register_blueprint(api, url_prefix='/api/v1')
    app.register_blueprint(metrics, url_prefix='/metrics')
    app.register_blueprint(swaggerui_blueprint, url_prefix=swagger_url)

    # load configuration
    config = current_config(config_file)
    config.setup_policies()
예제 #24
0
        # Create a user and a book and add the book to the user.books relationship
        user = User(name="thomas", email="em@il")
        book = Book(name="test_book")

        for i in range(100):
            user = User(name="test_name_" + str(i))
            user.books.append(book)

        api = Api(app,
                  api_spec_url=API_PREFIX + "/swagger",
                  host="{}:{}".format(HOST, PORT))
        # Expose the database objects as REST API endpoints
        api.expose_object(User)
        api.expose_object(Book)
        # Set the JSON encoder used for object to json marshalling
        app.json_encoder = SAFRSJSONEncoder

        @app.route("/")
        def goto_api():
            """Create a redirect from / to /api"""
            return redirect(API_PREFIX)

        # Register the API at /api/docs
        swaggerui_blueprint = get_swaggerui_blueprint(
            API_PREFIX, API_PREFIX + "/swagger.json")
        app.register_blueprint(swaggerui_blueprint, url_prefix=API_PREFIX)
        print("Starting API: http://{}:{}{}".format(HOST, PORT, API_PREFIX))
        print(dir(api))
        print(api.endpoints)
        app.run(host=HOST, port=PORT)
예제 #25
0
from flask_migrate import Migrate
# from flask_restful import Api
from flask_sqlalchemy import SQLAlchemy, get_debug_queries
from flask_swagger_ui import get_swaggerui_blueprint

import config

app = Flask(__name__)
app.config.from_object(config.Config)
db = SQLAlchemy(app)
migrate = Migrate(app, db)
api = flask_restful.Api(app)

SWAGGER_URL = '/swagger'
API_URL = '/static/swagger.json'
SWAGGERUI_BLUEPRINT = get_swaggerui_blueprint(
    SWAGGER_URL, API_URL, config={'app_name': 'IMDb приложение'})
app.register_blueprint(
    SWAGGERUI_BLUEPRINT,
    url_prefix=SWAGGER_URL)  # привязыв. наш URL '/swagger' к нашему приложению

app.debug = True


def sql_debug(response):
    queries = list(get_debug_queries())
    total_duration = 0.0
    for q in queries:
        total_duration += q.duration

    print('=' * 80)
    print(' SQL Queries - {0} Queries Executed in {1}ms'.format(
예제 #26
0
app.register_blueprint(blueprint_nlp, url_prefix="/api/v1/ner")
with app.test_request_context():
    # register all swagger documented functions here
    for fn_name in app.view_functions:
        if fn_name == "static":
            continue
        print(f"Loading swagger docs for function: {fn_name}")
        view_fn = app.view_functions[fn_name]
        spec.path(view=view_fn)


@app.route("/api/swagger.json")
def create_swagger_spec():
    return jsonify(spec.to_dict())


if __name__ == "__main__":
    ####################
    # FOR DEVELOPMENT
    ####################
    """Definition of the Swagger UI Blueprint."""
    SWAGGER_URL = "/api/docs"
    API_URL = "/api/swagger.json"

    # Call factory function to create our blueprint
    swagger_ui_blueprint = get_swaggerui_blueprint(
        SWAGGER_URL, API_URL, config={"app_name": "My App"}
    )
    app.register_blueprint(swagger_ui_blueprint, url_prefix=SWAGGER_URL)
    app.run(host="0.0.0.0", port=3001, debug=True)
예제 #27
0
from flask import Flask, request, render_template, session
from flask import redirect
from functools import wraps
import os
from flask_swagger_ui import get_swaggerui_blueprint
app = Flask(__name__)
app.secret_key = "secretkey"
app.config["UPLOADED_PHOTOS_DEST"] = "static"
### swagger specific ###
SWAGGER_URL = "/swagger"
API_URL = "/static/swagger.json"
SWAGGERUI_BLUEPRINT = get_swaggerui_blueprint(
    SWAGGER_URL, API_URL, config={
        "app_name": "Seans-Python-Flask-REST-Boilerplate"}
)
app.register_blueprint(SWAGGERUI_BLUEPRINT, url_prefix=SWAGGER_URL)
### end swagger specific ###
books = [
    {
        "author": "Hernando de Soto",
        "country": "Peru",
        "language": "English",
        "pages": 209,
        "title": "The Mystery of Capital",
        "year": 1970,
    },
    {
        "author": "Hans Christian Andersen",
        "country": "Denmark",
        "language": "Danish",
        "pages": 784,
예제 #28
0
def create_app(char_limit=-1,
               req_limit=-1,
               batch_limit=-1,
               ga_id=None,
               debug=False,
               frontend_language_source="en",
               frontend_language_target="en",
               frontend_timeout=500):
    from app.init import boot
    boot()

    from app.language import languages
    app = Flask(__name__)

    # For faster access
    language_map = {}
    for l in languages:
        language_map[l.code] = l.name

    if debug:
        app.config['TEMPLATES_AUTO_RELOAD'] = True

    # Map userdefined frontend languages to argos language object.
    if frontend_language_source == "auto":
        frontend_argos_language_source = type('obj', (object, ), {
            'code': 'auto',
            'name': 'Auto Detect'
        })
    else:
        frontend_argos_language_source = next(
            iter([l for l in languages if l.code == frontend_language_source]),
            None)

    frontend_argos_language_target = next(
        iter([l for l in languages if l.code == frontend_language_target]),
        None)

    # Raise AttributeError to prevent app startup if user input is not valid.
    if frontend_argos_language_source is None:
        raise AttributeError(
            f"{frontend_language_source} as frontend source language is not supported."
        )
    if frontend_argos_language_target is None:
        raise AttributeError(
            f"{frontend_language_target} as frontend target language is not supported."
        )

    if req_limit > 0:
        from flask_limiter import Limiter
        limiter = Limiter(app,
                          key_func=get_remote_address,
                          default_limits=["%s per minute" % req_limit])

    @app.errorhandler(400)
    def invalid_api(e):
        return jsonify({"error": str(e.description)}), 400

    @app.errorhandler(500)
    def server_error(e):
        return jsonify({"error": str(e.description)}), 500

    @app.errorhandler(429)
    def slow_down_error(e):
        return jsonify({"error": "Slowdown: " + str(e.description)}), 429

    @app.route("/")
    def index():
        return render_template('index.html',
                               gaId=ga_id,
                               frontendTimeout=frontend_timeout)

    @app.route("/languages")
    def langs():
        """
        Retrieve list of supported languages
        ---
        tags:
          - translate
        responses:
          200:
            description: List of languages
            schema:
              id: languages
              type: array
              items:
                type: object
                properties:
                  code:
                    type: string
                    description: Language code
                  name:
                    type: string
                    description: Human-readable language name (in English)
          429:
            description: Slow down
            schema:
              id: error-slow-down
              type: object
              properties:
                error:
                  type: string
                  description: Reason for slow down
        """
        return jsonify([{'code': l.code, 'name': l.name} for l in languages])

    # Add cors
    @app.after_request
    def after_request(response):
        response.headers.add('Access-Control-Allow-Origin', '*')
        response.headers.add('Access-Control-Allow-Headers',
                             "Authorization, Content-Type")
        response.headers.add('Access-Control-Expose-Headers', "Authorization")
        response.headers.add('Access-Control-Allow-Methods', "GET, POST")
        response.headers.add('Access-Control-Allow-Credentials', "true")
        response.headers.add('Access-Control-Max-Age', 60 * 60 * 24 * 20)
        return response

    @app.route("/translate", methods=['POST'])
    def translate():
        """
        Translate text from a language to another
        ---
        tags:
          - translate
        parameters:
          - in: formData
            name: q
            schema:
              oneOf:
                - type: string
                  example: Hello world!
                - type: array
                  example: ['Hello world!']
            required: true
            description: Text(s) to translate
          - in: formData
            name: source
            schema:
              type: string
              example: en
            required: true
            description: Source language code
          - in: formData
            name: target
            schema:
              type: string
              example: es
            required: true
            description: Target language code
        responses:
          200:
            description: Translated text
            schema:
              id: translate
              type: object
              properties:
                translatedText:
                  oneOf:
                    - type: string
                    - type: array
                  description: Translated text(s)
          400:
            description: Invalid request
            schema:
              id: error-response
              type: object
              properties:
                error:
                  type: string
                  description: Error message
          500:
            description: Translation error
            schema:
              id: error-response
              type: object
              properties:
                error:
                  type: string
                  description: Error message
          429:
            description: Slow down
            schema:
              id: error-slow-down
              type: object
              properties:
                error:
                  type: string
                  description: Reason for slow down
        """

        if request.is_json:
            json = request.get_json()
            q = json.get('q')
            source_lang = json.get('source')
            target_lang = json.get('target')
        else:
            q = request.values.get("q")
            source_lang = request.values.get("source")
            target_lang = request.values.get("target")

        if not q:
            abort(400, description="Invalid request: missing q parameter")
        if not source_lang:
            abort(400, description="Invalid request: missing source parameter")
        if not target_lang:
            abort(400, description="Invalid request: missing target parameter")

        batch = isinstance(q, list)

        if batch and batch_limit != -1:
            batch_size = len(q)
            if batch_limit < batch_size:
                abort(400,
                      description=
                      "Invalid request: Request (%d) exceeds text limit (%d)" %
                      (batch_size, batch_limit))

        if char_limit != -1:
            if batch:
                chars = sum([len(text) for text in q])
            else:
                chars = len(q)

            if char_limit < chars:
                abort(
                    400,
                    description=
                    "Invalid request: Request (%d) exceeds character limit (%d)"
                    % (chars, char_limit))

        if source_lang == 'auto':
            candidate_langs = list(
                filter(lambda l: l.lang in language_map, detect_langs(q)))

            if len(candidate_langs) > 0:
                candidate_langs.sort(key=lambda l: l.prob, reverse=True)

                if debug:
                    print(candidate_langs)

                source_lang = next(
                    iter([
                        l.code for l in languages
                        if l.code == candidate_langs[0].lang
                    ]), None)
                if not source_lang:
                    source_lang = 'en'
            else:
                source_lang = 'en'

            if debug:
                print("Auto detected: %s" % source_lang)

        src_lang = next(iter([l for l in languages if l.code == source_lang]),
                        None)
        tgt_lang = next(iter([l for l in languages if l.code == target_lang]),
                        None)

        if src_lang is None:
            abort(400, description="%s is not supported" % source_lang)
        if tgt_lang is None:
            abort(400, description="%s is not supported" % target_lang)

        translator = src_lang.get_translation(tgt_lang)

        try:
            if batch:
                return jsonify({
                    "translatedText":
                    [translator.translate(text) for text in q]
                })
            else:
                return jsonify({"translatedText": translator.translate(q)})
        except Exception as e:
            abort(500, description="Cannot translate text: %s" % str(e))

    @app.route("/frontend/settings")
    def frontend_settings():
        """
        Retrieve frontend specific settings
        ---
        tags:
          - frontend
        responses:
          200:
            description: frontend settings
            schema:
              id: frontend-settings
              type: object
              properties:
                charLimit:
                  type: integer
                  description: Character input limit for this language (-1 indicates no limit)
                frontendTimeout:
                  type: integer
                  description: Frontend translation timeout
                language:
                  type: object
                  properties:
                    source:
                      type: object
                      properties:
                        code:
                          type: string
                          description: Language code
                        name:
                          type: string
                          description: Human-readable language name (in English)
                    target:
                      type: object
                      properties:
                        code:
                          type: string
                          description: Language code
                        name:
                          type: string
                          description: Human-readable language name (in English)
        """
        return jsonify({
            'charLimit': char_limit,
            'frontendTimeout': frontend_timeout,
            'language': {
                'source': {
                    'code': frontend_argos_language_source.code,
                    'name': frontend_argos_language_source.name
                },
                'target': {
                    'code': frontend_argos_language_target.code,
                    'name': frontend_argos_language_target.name
                }
            }
        })

    swag = swagger(app)
    swag['info']['version'] = "1.0"
    swag['info']['title'] = "LibreTranslate"

    @app.route("/spec")
    def spec():
        return jsonify(swag)

    SWAGGER_URL = '/docs'  # URL for exposing Swagger UI (without trailing '/')
    API_URL = '/spec'

    # Call factory function to create our blueprint
    swaggerui_blueprint = get_swaggerui_blueprint(SWAGGER_URL, API_URL)

    app.register_blueprint(swaggerui_blueprint)

    return app
예제 #29
0
from hashlib import sha256
from flask_cors import CORS, cross_origin
from flask_swagger_ui import get_swaggerui_blueprint

# ************************** authentification JWT microservice **************************#
# inputs : username/email , password                                                     #
# outputs : access_token , refresh_token                                                 #
# ***************************************************************************************#

app = Flask(__name__)

### swagger specific ###
SWAGGER_URL = '/auth/swagger'
API_URL = '/static/swagger.json'
SWAGGERUI_BLUEPRINT = get_swaggerui_blueprint(
    SWAGGER_URL,
    API_URL,
    config={'app_name': "JWT Authentification microservice"})
app.register_blueprint(SWAGGERUI_BLUEPRINT, url_prefix=SWAGGER_URL)
### end swagger specific ###

cors = CORS(app, resources={r"/*": {"origins": "*"}})

api = Api(app, prefix="/auth")

# cros config
app.config['CORS_HEADERS'] = 'application/json'

# JWT Config

app.config['JWT_SECRET_KEY'] = '4Si_S8A'
jwt = JWTManager(app)
예제 #30
0
    pass
else:
    SWAGGER_URL = '/api/docs'
    swagger_address = getenv("SWAGGER_HOST", my_ip)

    if settings['use_ssl']:
        API_URL = 'https://{}/api/swagger.json'.format(swagger_address)
    elif LISTEN == '127.0.0.1' or swagger_address != my_ip:
        API_URL = "http://{}/api/swagger.json".format(swagger_address)
    else:
        API_URL = "http://{}:{}/api/swagger.json".format(swagger_address, PORT)

    swaggerui_blueprint = get_swaggerui_blueprint(
        SWAGGER_URL,
        API_URL,
        config={
            'app_name': "Screenly API"
        }
    )
    app.register_blueprint(swaggerui_blueprint, url_prefix=SWAGGER_URL)


################################
# Views
################################


@app.route('/')
@auth_basic
def viewIndex():
    player_name = settings['player_name']
예제 #31
0
#!/usr/bin/python3

import json
from flask import Flask, jsonify, request, Response
from flask_swagger_ui import get_swaggerui_blueprint
import MemUsageMonitor

app = Flask(__name__)

### swagger specific ###
SWAGGER_URL = '/api'
API_URL = '/static/swagger_3.json'
SWAGGERUI_BLUEPRINT = get_swaggerui_blueprint(
    SWAGGER_URL,  # Swagger UI static files will be mapped to '{SWAGGER_URL}/dist/'
    API_URL,
    config={'app_name': "Memory usage API"})
app.register_blueprint(SWAGGERUI_BLUEPRINT, url_prefix=SWAGGER_URL)
### end swagger specific ###

mum = MemUsageMonitor.MemUsageMonitor()

# curl -d '{"threshold":40}' -H "Content-Type: application/json" -X POST http://<IP>:5000/memusage


@app.route('/')
def index():
    helpMsg = {
        "/": "This help message",
        "/memusage": "Memory usage",
        "/memusage POST data {'threshold' : 40}": "Change mem usage threshold"
    }