def create_app(userdb, **kwargs):
'''
This method instantiates the RESTful web service app
and returns it.
Production mode: called from the .wsgi file.
Standalone mode: used by developers to do local service testing
'''
app = Flask(__name__)
api = restful.Api(app)
api.add_resource(RootHandler, '/')
api.add_resource(GeocodeService, '/geocoder/')
if hasattr(app, 'api'):
errmsg = 'app already has api attribute'
_logger.error(errmsg)
raise Exception(errmsg)
else:
app.api = api
_logger.debug('returning app')
# configure app to use specified user db and app secret key
# ( required for flask-login module)
app.config['userdb'] = userdb
app.secret_key = "\xa9\xb6\xbb\xa9;XF>\x7fHd-@z!|\x7f\xa7'V\x1c6K\xe6"
# use login manager to manage api requests
# set request_user method as login manager's request loader (will be called
# when a method is decorated with @login_required
login_manager = LoginManager()
login_manager.request_loader(request_user)
login_manager.init_app(app)
return app
def configure(app, formula_prefix='/formula', **ctx):
app.register_blueprint(blueprint, url_prefix=formula_prefix)
app.register_blueprint(static_blueprint)
api = restful.Api(app, prefix=formula_prefix)
api.add_resource(FormulaResource,
'/<formula_type>/<formula_id>',
'/<formula_type>/<formula_id>/',
'/<formula_type>/<formula_id>/<path:opstr>')
class DocularServer:
app = Flask(__name__)
api = restful.Api(app)
def __init__(self):
# Initialize logger
logging_config = config_util.Config("./config/logging.json")
log_formatter = logging.Formatter(logging_config["formatting"])
handler1 = RotatingFileHandler(
logging_config["logFileName"],
maxBytes=logging_config["maxLogSize"],
backupCount=logging_config["rollingLogFileCount"])
handler2 = logging.StreamHandler()
handler1.setFormatter(log_formatter)
handler2.setFormatter(log_formatter)
self.app.logger.addHandler(handler1)
self.app.logger.addHandler(handler2)
handler1.setLevel(logging_config["level"])
handler2.setLevel(logging_config["level"])
self.app.logger.setLevel(logging_config["level"])
# Initialize the models and workers
self.app.logger.info("Loading Models...")
self.app.models = modelbase.Base(self.app.logger)
self.app.logger.info("Loading Content Extractor...")
self.app.content_extractor = workers.contentextractor.ContentExtractor(
)
# Set routing for the API
self.api.add_resource(DocumentController, "/api/documents",
"/api/documents/<string:id>")
self.api.add_resource(PayloadController,
"/api/documents/<string:id>/payload")
self.api.add_resource(ThumbnailController,
"/api/documents/<string:id>/thumbnail")
self.api.add_resource(CategoryController, "/api/categories",
"/api/categories/<string:id>")
def run(self):
try:
self.app.logger.info("Server starting up...")
self.app.run(debug=True, host='0.0.0.0', port=5002)
self.app.logger.info("Server started.")
except (KeyboardInterrupt, SystemExit):
self.stop()
except Exception as ex:
self.app.logger.exception(ex)
self.stop(1)
def stop(self, exit_code=0):
func = request.environ.get('werkzeug.server.shutdown')
if func is not None:
func()
exit(exit_code)
@app.errorhandler(404)
def serve_index(self, arg):
return self.app.send_static_file('index.html')
def Api(app):
api = restful.Api(app)
api.add_resource(Hello, '/')
api.add_resource(Users, '/users')
api.add_resource(User, '/users/<string:username>')
api.add_resource(Sites, '/sites/<string:username>')
api.add_resource(Site, '/sites/<string:username>/<string:sitename>')
return api
def Api(app):
api = restful.Api(app)
api.add_resource(card_api.CardsApi, '/cards')
api.add_resource(card_api.CardApi, '/cards/<int:card_id>')
api.add_resource(game_api.GameApi, '/game')
api.add_resource(game_api.VoteApi, '/game/vote')
api.add_resource(player_api.PlayersApi, '/game/players')
api.add_resource(player_api.PlayerApi, '/game/players/<string:player_id>')
def add_api(app):
"""Add JSON API to Flask app."""
api = restful.Api(app, '/api')
api.add_resource(Info, '/info')
api.add_resource(Login, '/login')
api.add_resource(Logout, '/logout')
api.add_resource(Run, '/run')
api.add_resource(Jobs, '/jobs')
api.add_resource(Job, '/jobs/<int:job_id>')
api.add_resource(File, '/files/', endpoint='fr', defaults={'p': ''})
api.add_resource(File, '/files/<path:p>')
def setUp(self):
self.setup_app()
testcase = self
class Routes(restful.Resource):
def get(self):
return testcase.return_data
self.api = restful.Api(self.app)
self.api.add_resource(Routes, '/')
def setup_app(app):
"""Setup api extension."""
api = restful.Api()
api.init_app(app)
app.extensions['restful'] = api
modules = autodiscover_modules(['invenio'],
related_name_re='.+_restapi\.py')
for m in modules:
register_func = getattr(m, 'register_restapi', None)
if register_func and callable(register_func):
register_func(app, api)
def add_to_sheer(app):
api = restful.Api(app)
class QueryResource(restful.Resource):
def get(self, name):
query_finder = default_query_finder()
query = getattr(query_finder, name) or flask.abort(404)
request = flask.request
return query.search()
api.add_resource(QueryResource, '/api/v1/q/<name>.json')
api.representations.update({'application/json': custom_json_output})
def setUp(self):
self.setup_app()
testcase = self
testcase.json_data = None
class Routes(restful.Resource):
def get(self):
return testcase.json_data
self.api = restful.Api(self.app)
self.api.add_resource(Routes, '/')
restful_extend.enhance_json_encode(self.api)
def setup_app(app):
"""Setup api extension."""
api = restful.Api(app=app)
app.extensions['restful'] = api
class RestfulRegistry(ModuleAutoDiscoveryRegistry):
setup_func_name = 'setup_app'
def register(self, module, *args, **kwargs):
return super(RestfulRegistry,
self).register(module, app, api, *args, **kwargs)
app.extensions['registry']['restful'] = RestfulRegistry('restful',
app=app,
with_setup=True)
def __init__(self, device_command_listener):
self.app = Flask(__name__)
self.app.debug = True
self.device_command_listener = device_command_listener
ServerConstants.device_command_listener = device_command_listener
api = restful.Api(self.app)
api.add_resource(User.Login, '/login')
api.add_resource(User.RegisterUser, '/register')
api.add_resource(Device.RegisterInsight, '/register_insight')
api.add_resource(Device.SendCommand, '/insight/command')
api.add_resource(Device.DeviceInfo, '/insight/status')
api.add_resource(Events.List, '/events/list')
api.add_resource(Events.GetData, '/events/data')
api.add_resource(User.ListInsight, '/insight_list')
api.add_resource(HelloWorld, '/') # to check if site is up
def main():
app = Flask(__name__)
api = restful.Api(app)
# Apache API SSHDConfigAPI
api.add_resource(ApacheServiceAPI, api_services + 'apache/<string:action>',
api_services + 'apache')
api.add_resource(ApacheConfigAPI, api_services_conf + 'apache')
# SSHD API
api.add_resource(SSHDServiceAPI, api_services + 'ssh/<string:action>',
api_services + 'ssh')
api.add_resource(SSHDConfigAPI, api_services_conf + 'ssh')
# MySQL API
api.add_resource(MySQLServiceAPI, api_services + 'mysql/<string:action>',
api_services + 'mysql')
api.add_resource(MySQLConfigAPI, api_services_conf + 'mysql')
# vsFTPD API
api.add_resource(vsFTPServiceAPI, api_services + 'vsftpd/<string:action>',
api_services + 'vsftpd')
api.add_resource(vsFTPConfigAPI, api_services_conf + 'vsftpd')
# BIND API
api.add_resource(BINDServiceAPI, api_services + 'bind/<string:action>',
api_services + 'bind')
api.add_resource(BINDConfigAPI, api_services_conf + 'bind')
# Basic Task API
api.add_resource(TaskBasicAPI, api_task + '<string:action>')
api.add_resource(ClientInfoAPI, api_task + 'info')
# Connection API
api.add_resource(ConnectAPI, '/api/connect')
app.config.update(DEBUG=True, PROPAGATE_EXCEPTIONS=True)
app.run(debug=debug,
ssl_context=context,
port=9000,
host='0.0.0.0',
threaded=True)
def __init__(self):
self.app = Flask("DjoroRegulationServer")
self.api = restful.Api(self.app)
hw = HelloWorld.makeResource()
self.api.add_resource(hw, '/site/<int:siteId>')
um = FetchMeteo.makeResource()
self.api.add_resource(um, '/site/<int:siteId>/meteo/fetch')
cc = CalculeConsigne.makeResource()
self.api.add_resource(
cc, '/site/<int:siteId>/device/<int:deviceId>/setpoints/calc')
cs = CostSavings.makeResource()
self.api.add_resource(
cs, '/site/<int:siteId>/device/<int:deviceId>/moneysaved/calc')
def test_converter(self):
register_model_converter(self.TestModel, self.app)
testcase = self
class Routes(restful.Resource):
def get(self, model):
# test to_python
testcase.assertEquals(model, testcase.TestModel.query.get(1))
# test to_url
testcase.assertEqual(
url_for('routes', model=testcase.TestModel.query.get(2)),
'/2')
api = restful.Api(self.app)
api.add_resource(Routes, '/<TestModel:model>')
self.client.get('/1')
def test_flask_restful_resource(self):
app, limiter = self.build_app(
global_limits=["1/hour"]
)
api = restful.Api(app)
class Va(Resource):
decorators = [limiter.limit("2/second")]
def get(self):
return request.method.lower()
def post(self):
return request.method.lower()
class Vb(Resource):
decorators = [limiter.limit("1/second, 3/minute")]
def get(self):
return request.method.lower()
class Vc(Resource):
def get(self):
return request.method.lower()
api.add_resource(Va, "/a")
api.add_resource(Vb, "/b")
api.add_resource(Vc, "/c")
with hiro.Timeline().freeze() as timeline:
with app.test_client() as cli:
self.assertEqual(200, cli.get("/a").status_code)
self.assertEqual(200, cli.get("/a").status_code)
self.assertEqual(429, cli.get("/a").status_code)
self.assertEqual(429, cli.post("/a").status_code)
self.assertEqual(200, cli.get("/b").status_code)
timeline.forward(1)
self.assertEqual(200, cli.get("/b").status_code)
timeline.forward(1)
self.assertEqual(200, cli.get("/b").status_code)
timeline.forward(1)
self.assertEqual(429, cli.get("/b").status_code)
self.assertEqual(200, cli.get("/c").status_code)
self.assertEqual(429, cli.get("/c").status_code)
def start_server():
_LOG.info('Clueless server starting..')
app = Flask(__name__)
api = restful.Api(app)
api.add_resource(resources.PlayersResource, '/players')
api.add_resource(resources.PlayerResource, '/players/<string:username>')
api.add_resource(resources.GamesResource, '/games')
api.add_resource(resources.GameResource, '/games/<string:game_id>')
api.add_resource(resources.MovePlayerResource, '/moveplayer')
api.add_resource(resources.SuggestionResource, '/suggestion')
api.add_resource(resources.SuggestionResponseResource,
'/suggestionresponse')
api.add_resource(resources.AccusationResource, '/accusation')
api.add_resource(resources.EndTurnResource, '/endturn')
app.run(host="0.0.0.0", debug=True)
def get_app():
"""
Access the app so we can hopefully get it working with uwsgi in another script
:return: flask app
:rtype: flask.Flask
"""
args = get_args()
if args.cache:
use_caching(is_read_only=args.read_only,
is_write_only=args.write_only,
shouldnt_compute=args.no_compute)
set_global_num_processes(args.processes)
app = Flask(__name__)
api = restful.Api(app)
register_resources(api)
return app
def __init__(self,
frycook,
bind='127.0.0.1',
port=5000,
api_prefix='/api/v0.1',
debug=False):
if debug:
logging.basicConfig(level=logging.DEBUG)
else:
logging.basicConfig(level=logging.ERROR)
self.frycook = frycook
global chef
chef = frycook
self.app = Flask(__name__)
self.api = restful.Api(self.app)
self.prefix = api_prefix
logging.debug(resources)
for res in resources:
self.api.add_resource(resources[res], api_prefix + res)
self.app.run(debug=debug)
def create_app(env='dev', services=dict()):
# Create the flask app
app = Flask(__name__)
register_error_handlers(app)
# Do everything in the app context
with app.app_context():
from flask import current_app, g
g._env = env
# Load the config
current_app.config.from_object('app.config.config_%s.Config' % env)
# Load all services
for name, obj in services.iteritems():
app.config['SERVICE'].add(name, obj)
# Get the database connection object
from odm import loadOdm
loadOdm()
# Configure the Applications API
g._api = restful.Api(current_app)
g._api.decorators = [
#authenticate(node_key_allowed=current_app.config['NODE_KEY_ALLOWED'], node_key_cache_dir=current_app.config['NODE_KEY_CACHE_DIR']),
cors.crossdomain(origin=current_app.config['CORS_ORIGIN'],
methods=current_app.config['CORS_METHODS'],
headers=current_app.config['CORS_HEADERS'])
]
# Load all further resources
from views import loadViews
from resources import loadResources
loadResources()
loadViews()
return app
# -*- coding: utf-8 -*-
from flask import Flask
from flask import render_template
from flask.ext import restful
import os
import time
from datetime import datetime
app = Flask(__name__)
api = restful.Api(app)
@app.route('/')
def index():
return render_template('index.html')
class DataUpdate(restful.Resource):
def _is_updated(self, request_time):
"""
Returns if resource is updated or it's the first
time it has been requested.
args:
request_time: last request timestamp
"""
return os.stat('data.txt').st_mtime > request_time
from flask import request, render_template
from pony import orm
from flask import Flask
import flask.ext.restful as rest
from core.models import Device, Transmission
from core.settings import DATABASE as db, FLASK_DEBUG
app = Flask(__name__, template_folder='core/templates')
app.static_folder = 'core/static'
api = rest.Api(app)
db.generate_mapping(create_tables=True)
class APIWhitelist(rest.Resource):
def get(self):
with orm.db_session:
return {dev.id: {'name': dev.name} for dev in Device.select()}
def post(self):
with orm.db_session:
data = request.get_json(force=True)
if data['id'] and data['name']:
Device(id=data['id'].upper(), name=data['name'])
return {}, 200
return {}, 400
def delete(self, id):
with orm.db_session:
dev = Device.select(lambda d: d.id.upper() == id).first()
if dev:
def configure(app, formula_prefix='/monster', **ctx):
app.register_blueprint(blueprint, url_prefix=formula_prefix)
app.register_blueprint(static_blueprint)
api = restful.Api(app, prefix=formula_prefix)
api.add_resource(MonsterResource, '/<species>/<monster_id>')
stdout_handler.setLevel(logging.DEBUG)
app.logger.addHandler(stdout_handler)
app.logger.setLevel(logging.DEBUG)
if app.config['LOG_FILENAME']:
file_handler = logging.FileHandler(app.config['LOG_FILENAME'])
file_handler.setFormatter(
logging.Formatter(
'%(asctime)s %(levelname)s - %(filename)s %(funcName)s: %(message)s'
))
file_handler.setLevel(logging.INFO)
app.logger.addHandler(file_handler)
app.logger.info('Will output log to %s', app.config['LOG_FILENAME'])
# global instance of flask-restful, used by resources
rest_api = restful.Api(app, catch_all_404s=True)
# monkey patch WTForm classes
import wtforms_json
wtforms_json.init()
# Import app/resources
from resources import *
# Register Home Blueprint
from .home import home as home_blueprint
app.register_blueprint(home_blueprint)
# Register Admin Blueprint
from flask.ext import restful
from flask.ext.restful import fields
from flask.ext.restful.reqparse import RequestParser
from .models import Revenue, RevenueCode
from gastosabertos.extensions import db
# Blueprint for Receita
receita = Blueprint('receita',
__name__,
template_folder='templates',
static_folder='static',
static_url_path='/receita/static')
# Create the restful API
receita_api = restful.Api(receita, prefix="/api/v1")
class Date(fields.Raw):
def format(self, value):
return str(value)
# Parser for RevenueAPI arguments
revenue_list_parser = RequestParser()
revenue_list_parser.add_argument('page', type=int, default=0)
revenue_list_parser.add_argument('per_page_num', type=int, default=100)
revenue_list_parser.add_argument('years', type=int, action='append')
# Fields for RevenueAPI data marshal
revenue_fields = {
from flask.blueprints import Blueprint
import os
from flask.ext import restful
from aireadManager.utils.restful import Resource
from flask import abort
__author__ = 'airead'
path = os.path.splitext(os.path.basename(__file__))[0]
blueprint = Blueprint(path, __name__, url_prefix='/' + path)
api = restful.Api(blueprint)
class TestRestfuls(Resource):
def get(self):
return 'test get'
def post(self):
return 'test post'
class TestRestful(Resource):
def get(self, rid):
return 'get %s' % rid
def post(self, rid): # just for [put, delete] method allow by post
abort(405)
def put(self, rid):
return 'put %s' % rid
from collections import defaultdict
from flask import jsonify
from flask.ext.cors import cross_origin
import flask_app_builder
from flask.ext import restful
flask_app = flask_app_builder.build_flask_app()
api = restful.Api(flask_app)
import checks
@flask_app.route("/")
def index():
return "Welcome to the DashBoard server"
# @flask_app.route("/app/<path:file>")
# def app(file):
# return ""
@flask_app.route("/status")
@cross_origin()
def status():
data = defaultdict(dict)
# data["archimedes"] = {
# "webcamtest1" : {
# "text": "First webcam is working",
# "status": "OK",
# "date": "2015-02-23",
db.init_app(app)
cors.CORS(app)
class FlaskRestParser(FlaskParser):
def handle_error(self, error):
message = error.messages
status_code = getattr(error, 'status_code', 422)
raise exceptions.ApiError(message, status_code)
parser = FlaskRestParser()
app.config['APISPEC_WEBARGS_PARSER'] = parser
v1 = Blueprint('v1', __name__, url_prefix='/v1')
api = restful.Api(v1)
# Encode using ujson for speed and decimal encoding
api.representations['application/json'] = util.output_json
app.register_blueprint(v1)
@app.errorhandler(exceptions.ApiError)
def handle_error(error):
response = jsonify(error.to_dict())
response.status_code = error.status_code
return response
# api.data.gov
def configure_api(app):
api = restful.Api(app)
api.add_resource(PinValidationError, '/')
from flask.ext import restful
from flask.ext.restful import fields
from flask.ext.restful.reqparse import RequestParser
from .models import Contrato
from gastosabertos.extensions import db
# Blueprint for Contrato
contratos = Blueprint('contratos',
__name__,
template_folder='templates',
static_folder='static',
static_url_path='/contrato/static')
# Create the restful API
contratos_api = restful.Api(contratos, prefix="/api/v1")
# receita_api.decorators = [cors.crossdomain(origin='*')]
# class Date(fields.Raw):
# def format(self, value):
# return str(value)
# Parser for RevenueAPI arguments
contratos_list_parser = RequestParser()
contratos_list_parser.add_argument('cnpj')
contratos_list_parser.add_argument('orgao')
contratos_list_parser.add_argument('modalidade')
contratos_list_parser.add_argument('evento')
contratos_list_parser.add_argument('objeto')
contratos_list_parser.add_argument('processo_administrativo')
contratos_list_parser.add_argument('nome_fornecedor')
