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')