from flask import Blueprint, request
from flask.ext.restful import Api, Resource, fields, marshal_with
from werkzeug.datastructures import ImmutableDict
from models import Todo, db
api = Api(prefix='/api')
api_bp = Blueprint('api_bp', __name__)
api.init_app(api_bp)
todo_fields = {
'id': fields.Integer,
'task': fields.String,
'date': fields.DateTime,
'done': fields.Boolean
}
class TodoListResource(Resource):
@marshal_with(todo_fields)
def get(self):
return Todo.query.all()
@marshal_with(todo_fields)
def post(self):
new = Todo(request.json['task'], False)
db.session.add(new)
db.session.commit()
return new, 201
def put(self):
tasks = Todo.query.all()
from flask import Flask, make_response, jsonify
from flask.ext.restful import Api
from flask.ext.cors import CORS
from reststub.resources import ItemListAPI
from reststub.resources import ItemAPI
from reststub.globals import auth
# Main app
rest_stub_app = Flask(__name__)
rest_stub_app.debug = True
# Restful extension
api = Api(rest_stub_app)
api.add_resource(ItemListAPI, '/api/items', endpoint='items')
api.add_resource(ItemAPI, '/api/item/<string:name>', endpoint='item')
# Enable CORS for development
CORS(rest_stub_app)
@rest_stub_app.errorhandler(404)
def not_found(error):
return make_response(jsonify({'error': 'Not found'}), 404)
@auth.get_password
def get_password(username):
if username == "tester":
return "auth"
return None
security = Security()
from flask.ext.assets import Environment
assets = Environment()
from flask.ext.admin import Admin
admin = Admin()
from flask.ext.mail import Mail
mail = Mail()
from flask.ext.marshmallow import Marshmallow
ma = Marshmallow()
from flask.ext.restful import Api
rest_extension = Api()
from flask.ext.celery import Celery
celery = Celery()
class Diamond(object):
"""
A Diamond application.
:param app: a Flask app that you created on your own
:type app: Flask
:returns: None
"""
def __init__(self, app=None):
self.app = app
_fields = {
'id':
fields.Integer,
'name':
fields.String,
'bookmarks':
ManyToManyField(Bookmark, {
'id': fields.Integer,
'url': fields.String
})
}
def get(self, id=None):
if not id:
return list(self.get_all())
tag = Tag.query.filter_by(id=id).first()
if not tag:
abort(404)
return marshal(tag, self._fields)
def get_all(self):
for tag in Tag.query.all():
yield marshal(tag, self._fields)
api = Api(app, prefix='/api')
api.add_resource(BookmarkResource, '/bookmarks', '/bookmark/<int:id>')
api.add_resource(TagResource, '/tags', '/tag/<int:id>')
from app import app
from flask.ext.restful import Api
from .TokensApi import TokensList
from .DataApi import DataList
api = Api(app, catch_all_404s=True)
api.add_resource(TokensList,
'/api/v1/tokens',
endpoint='tokens_list_v1_endpoint')
api.add_resource(DataList, '/api/v1/data', endpoint='data_list_v1_endpoint')
"""
Defines the blueprint for the institutions
"""
from flask import Blueprint
from flask.ext.restful import Api
from resources import BceInstitutionResource
BCE_INSTITUTION_BLUEPRINT = Blueprint('bce_institution', __name__)
Api(BCE_INSTITUTION_BLUEPRINT).add_resource(
BceInstitutionResource,
'/bce_institutions/<string:uai>')
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from flask import Blueprint
from flask.ext.restful import Api
Login = Blueprint('Login', __name__)
login_api = Api(Login)
from .views import *
login_api.add_resource(userView, '/v1/user/<id>')
login_api.add_resource(user, '/v1/user')
login_api.add_resource(verify_login, '/v1/login')
login_api.add_resource(megVerif, '/v1/msg/verify')
login_api.add_resource(signUp, '/v1/sign')
login_api.add_resource(perInfor, '/v1/uinfor/<id>')
login_api.add_resource(chPasswd, '/v1/chg/passwd')
login_api.add_resource(imgRes, '/v1/avatar')
location=['form', 'json'],
type=inputs.url)
super().__init__()
@marshal_with(course_fields)
def get(self, id):
return add_reviews(course_or_404(id))
@marshal_with(course_fields)
def put(self, id):
args = self.reqparse.parse_args()
query = models.Course.update(**args).where(models.Course.id == id)
query.execute()
# Return tuple of Body, Status Code, Dictionary of Headers
return (add_reviews(models.Course.get(models.Course.id == id)), 200, {
'Location': url_for('resources.courses.course', id=id)
})
def delete(self, id):
query = models.Course.delete().where(models.Course.id == id)
query.execute()
return ('', 204, {'Location': url_for('resources.courses.courses')})
courses_api = Blueprint('resources.courses', '__name__')
api = Api(courses_api)
api.add_resource(CourseList, '/courses', endpoint='courses')
api.add_resource(Course, '/courses/<int:id>', endpoint='course')
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
from flask import Blueprint
from flask.ext.restful import Api, Resource
#from .models import User, Client
access = Blueprint('access', __name__)
api = Api(access)
class AccessApi(Resource):
def get(self):
return {'module': 'access'}
api.add_resource(AccessApi, '/access')
from flask.ext import restful
from flask.ext.restful import Resource, Api, fields, marshal_with
from fllipit import APP
from models import DB, Team
import pypyodbc
API = Api(APP)
# Get teams from the database
def getTeams():
teams = []
drivers = pypyodbc.drivers()
print(drivers)
if APP.config['TEST_DB']:
# In test mode, use the sqlite database
teams = Team.query.all()
for team in teams:
team.sortScores()
else:
# In production mode, get the data from the Access database
# Create the database connection
print(APP.config['DB_FILE'])
conn = pypyodbc.connect(
r"Driver={Microsoft Access Driver (*.mdb, *.accdb)};" + r"Dbq=" +
APP.config['DB_FILE'] + ";")
cur = conn.cursor()
# Get the data from the database
cur.execute('''
SELECT TeamNumber, TeamName, Affiliation,
Token auth decorator returns 401 if token is not specified or incorrect
"""
@wraps(view_function)
def decorated_function(*args, **kwargs):
if app.config['REQUIRE_AUTH'] == True and app.config['AUTH_TOKEN']:
if request.headers.get('Token') == app.config['AUTH_TOKEN'] or request.args.get('token') == app.config['AUTH_TOKEN']:
return view_function(*args, **kwargs)
else:
app.logger.error("Missing required 'TOKEN'")
abort(401)
else:
return view_function(*args, **kwargs)
return decorated_function
# If Token Auth is required, apply to Flask API
flask_api = Api(app, decorators=[app_key_check])
# Setup API calls for sketching pages
from controllers.controller import CaptureView, CaptureViewList, Eager
flask_api.add_resource(CaptureView, '/api/v1.0/capture/<int:id>')
flask_api.add_resource(CaptureViewList, '/api/v1.0/capture')
flask_api.add_resource(Eager, '/eager')
# Setup Screenshot directory
if not os.path.exists(app.config['LOCAL_STORAGE_FOLDER']):
os.makedirs(app.config['LOCAL_STORAGE_FOLDER'])
@app.route('/files/<filename>')
@app_key_check
def uploaded_file(filename):
from flask import Flask, request, jsonify
from flask.ext.restful import inputs
from flask.ext.restful import reqparse
from flask.ext.restful import marshal, Api, Resource
from time import *
from pygit2 import Repository, clone_repository
FLASK_SERVER_NAME = 'https://api.github.com/repos/slimanir/REST-Service-System'
app = Flask(__name__)
api = Api(app)
results = []
todo = 0
class Server(Resource):
def get(self):
s= Server.query.get()
if not s:
abort(404)
return s
api.add_resource(Server, '/repo')
def post(self):
args = parser.parse_args()
s=Server(**args)
db.session.add(s)
db.commit()
return s
api.add_resource(Server, '/repo')
errors = { 'NotFoundError':{'message':'Not found','status':404,}'FrobnitzError': ...,}
from flask import Flask, send_file, Blueprint
from flask.ext.restful import Api, Resource, reqparse
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.script import Manager
from flask.ext.marshmallow import Marshmallow
app = Flask(__name__)
app.debug = True
app.jinja_env.variable_start_string = '[['
app.jinja_env.variable_end_string = ']]'
app.config['SQLALCHEMY_DATABASE_URI'] = "sqlite:///demo.db"
db = SQLAlchemy(app)
ma = Marshmallow(app)
api = Api(app)
@app.route('/')
def hello_world():
# return 'Hello World!'
return send_file('templates/index.html'), 200
class ApiBaseError(Exception):
'''
基异常类。
'''
status_code = 200
code = 0
import os
import re
import json
def init_parse():
parser = reqparse.RequestParser()
parser.add_argument('file', type=FileStorage, location='files')
parser.add_argument('action', type=str)
parser.add_argument('invoke_rule', type=list, location='json')
parser.add_argument('type', type=str)
return parser
parser = init_parse()
script_bp = Blueprint('script', __name__)
script_api = Api(script_bp)
class ScriptSet(object):
"""
The Set for ScriptBase object.
"""
def __init__(self):
self.pattern = re.compile('(?<=desc\s=\s""")[\s\S]*(?=""")')
self._set = []
self.update()
def __iter__(self):
return iter(self._set)
def update(self):
from flask import Blueprint
from flask.ext.restful import Api
freebase_blueprint = Blueprint('freebase', __name__)
freebase_blueprint_api = Api(freebase_blueprint)
from resource.freebase import FreebaseNameAPI, FreebaseFactAPI
#, 'query', 'num_results'
freebase_blueprint_api.add_resource(FreebaseNameAPI, '/api/v1/freebase/name')
#, 'topic_ids', 'num_results'
freebase_blueprint_api.add_resource(FreebaseFactAPI, '/api/v1/freebase/fact')
app = Flask(__name__)
# Configurations
app.config.from_object(config)
# Logging
log = logging.getLogger('werkzeug')
log.setLevel(logging.ERROR)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler = logging.StreamHandler()
handler.setFormatter(formatter)
app.logger.setLevel(app.config.get('LOG_LEVEL', "INFO"))
app.logger.addHandler(handler)
# swagger
api = swagger.docs(Api(app),
apiVersion=SpiderKeeper.__version__,
api_spec_url="/api",
description='SpiderKeeper')
# Define the database object which is imported
# by modules and controllers
db = SQLAlchemy(app)
# Define apscheduler
scheduler = BackgroundScheduler()
class Base(db.Model):
__abstract__ = True
id = db.Column(db.Integer, primary_key=True)
from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.mail import Mail
from flask.ext.restful import Api
from flask.ext.bcrypt import Bcrypt
from config import config
db = SQLAlchemy()
mail = Mail()
bcrypt = Bcrypt()
api_restful = Api()
def create_app(config_name):
''' Setup Flask app '''
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
db.init_app(app)
mail.init_app(app)
# init brcypt to hass pwasswords
bcrypt.init_app(app)
# init api
api_restful.init_app(app)
# register blueprints
from .api_v1 import api as api_blueprint
app.register_blueprint(api_blueprint, url_prefix='/api/v1')
from flask import Blueprint
from flask.ext.restful import Api
api_bp = Blueprint('api', __name__)
api = Api(api_bp)
from myapi.resources.profile import Profile
api.add_resource(Profile, '/profile')
from myapi.resources.general import general
api.add_resource(general, '/general/<string:method>')
from myapi.resources.image import image, CompressFile
api.add_resource(image, '/image')
api.add_resource(CompressFile, '/compressfile')
from myapi.resources.user import User, ChangePassword, ChangeUserStatus, GetUserList, GetUserMarketList
api.add_resource(User, '/user', '/user/<int:userid>', endpoint='userep')
api.add_resource(ChangePassword, '/changepwd')
api.add_resource(ChangeUserStatus, '/changeuserstatus')
api.add_resource(GetUserList, '/userlist/<int:page>')
api.add_resource(GetUserMarketList, '/usermarketlist/<int:page>')
from myapi.resources.tag import UserTag, UserTags, UserTagList, SearchUserTagsByName, \
WorkTag, WorkTags, WorkTagList, SearchWorkTagsByName
api.add_resource(UserTag, '/usertag', '/usertag/<int:tagid>')
api.add_resource(UserTags, '/<int:userid>/usertags', endpoint='userTags')
api.add_resource(UserTagList, '/usertaglist/<int:page>')
api.add_resource(SearchUserTagsByName, '/search/usertaglist/<string:keyword>')
api.add_resource(WorkTag, '/worktag', '/worktag/<int:tagid>')
FIELDS = {
'name': fields.String,
'owner': fields.String,
'description': fields.String,
'options': fields.Raw,
'pluginName': fields.String,
'body': fields.String,
'chain': fields.String,
'active': fields.Boolean,
'notBefore': fields.DateTime(dt_format='iso8601', attribute='not_before'),
'notAfter': fields.DateTime(dt_format='iso8601', attribute='not_after'),
'id': fields.Integer,
}
mod = Blueprint('authorities', __name__)
api = Api(mod)
class AuthoritiesList(AuthenticatedResource):
""" Defines the 'authorities' endpoint """
def __init__(self):
self.reqparse = reqparse.RequestParser()
super(AuthoritiesList, self).__init__()
@marshal_items(FIELDS)
def get(self):
"""
.. http:get:: /authorities
The current list of authorities
import os
from flask import Flask
from flask.ext.restful import Api
from flask.ext.sqlalchemy import SQLAlchemy
from blog.constants import PROJECT_ROOT
api = Api(prefix='/api/0')
db = SQLAlchemy()
def create_app(**config):
app = Flask(
__name__,
static_folder=os.path.join(PROJECT_ROOT, 'static'),
template_folder=os.path.join(PROJECT_ROOT, 'templates'),
)
app.config['INDUCE_API_DELAY'] = True
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////tmp/blog.db'
app.config['DEBUG'] = True
app.config.update(config)
db.init_app(app)
configure_api_routes(app)
configure_web_routes(app)
user_fields = {
'username': fields.String,
'email': fields.String,
'password': fields.String
}
class UserList(Resource):
def __init__(self):
self.reqparse = reqparse.RequestParser()
self.reqparse.add_argument('username',
required=True,
help='No Username Provided',
location=['form', 'json'])
self.reqparse.add_argument('email',
required=True,
help='No email Provided',
location=['form', 'json'])
self.reqparse.add_argument('password',
required=True,
help='No Password Provided',
location=['form', 'json'])
super().__init__()
def get(self):
users = models.User.select()
users_api = Blueprint('resources.users', __name__)
api = Api(users_api)
api.add_resource(UserList, '/users', endpoint='users')
from flask.ext.restful import Api
from . import views
__all__ = ['api']
api = Api(default_mediatype='application/json')
api.add_resource(views.NetListView, '/nets', endpoint='net-list')
api.add_resource(views.NetView, '/nets/<string:net_key>', endpoint='net')
api.add_resource(views.TokenListView,
'/nets/<string:net_key>/places/<int:place_idx>/tokens',
endpoint='token-list')
api.add_resource(views.ServerInfo, '/server-info', endpoint='server-info')
from flask import Flask, Blueprint from flask.ext.restful import Api from api import OlympicGamesList, IndividualOlympicGames, CountriesList, IndividualCountry, EventsList, IndividualEvent, AthletesList, IndividualAthlete, MedalsList, IndividualMedal, MedalByRankList """ init Flask """ app = Flask(__name__) restful_api = Api(app) restful_api.add_resource(OlympicGamesList, '/scrape/olympics', '/scrape/olympics/') restful_api.add_resource(IndividualOlympicGames, '/scrape/olympics/<int:olympic_id>') restful_api.add_resource(CountriesList, '/scrape/countries', '/scrape/countries/') restful_api.add_resource(IndividualCountry, '/scrape/countries/<int:country_id>') restful_api.add_resource(EventsList, '/scrape/events', '/scrape/events/') restful_api.add_resource(IndividualEvent, '/scrape/events/<int:event_id>') restful_api.add_resource(AthletesList, '/scrape/athletes', '/scrape/athletes/') restful_api.add_resource(IndividualAthlete, '/scrape/athletes/<int:athlete_id>') restful_api.add_resource(MedalsList, '/scrape/medals', '/scrape/medals/') restful_api.add_resource(IndividualMedal, '/scrape/medals/<int:medal_id>') restful_api.add_resource(MedalByRankList, '/scrape/medals/<rank>')
from datetime import date
from flask import Blueprint
from flask import request
from flask.ext.restful import Api
from flask.ext.restful import Resource
from flask.ext.restful import inputs
from flask.ext.restful import reqparse
from .. import models
from .. import utils
from ..oauth import oauth
from ..utils import reqparse
captcha = Blueprint('captcha', __name__)
api = Api(captcha)
class CaptchaAPI(Resource):
def post(self):
""" 发送验证码
**Example Request**:
.. sourcecode:: http
POST /api/captcha
mobile=1
**Example Response**:
from mongoengine import ValidationError
from slugify import slugify_unicode
from . import filters, permissions, route
from .. import helpers, models, services
from ..locations import api
from ..tasks import import_locations
from .forms import (FileUploadForm, generate_location_edit_form,
generate_location_update_mapping_form, DummyForm)
bp = Blueprint('locations',
__name__,
template_folder='templates',
static_folder='static',
static_url_path='/core/static')
location_api = Api(bp)
location_api.add_resource(api.LocationTypeItemResource,
'/api/locationtype/<loc_type_id>',
endpoint='api.locationtype')
location_api.add_resource(api.LocationTypeListResource,
'/api/locationtypes/',
endpoint='api.locationtypes')
location_api.add_resource(api.LocationItemResource,
'/api/location/<location_id>',
endpoint='api.location')
location_api.add_resource(api.LocationListResource,
'/api/locations/',
endpoint='api.locations')
'''
Running:
PYTHONPATH=. python examples/inheritance.py
'''
from flask import Flask
from flask.ext.restful import Api, Resource
from flask_restful_swagger import swagger
app = Flask(__name__, static_folder='../static')
###################################
# This is important:
api = swagger.docs(Api(app), apiVersion='0.1',
basePath='http://localhost:5000',
resourcePath='/',
produces=["application/json", "text/html"],
api_spec_url='/api/spec',
description='Inheritance demonstration')
###################################
class Base(Resource):
def get(self):
pass
def post(self):
pass
def delete(self):
from flask import Blueprint, jsonify, current_app
from flask.ext.restful import Api
from resource import CommonResource
COMMON_BLUEPRINT = Blueprint('common', __name__)
Api(COMMON_BLUEPRINT).add_resource(CommonResource, '/routes')
'args': ("Message", )
},
}
# class DevConfig(Config):
# DEBUG = True
# SQLALCHEMY_DATABASE_URI = 'sqlite:///../database3.db'
login_manager = LoginManager()
login_manager.login_view = "main.login"
login_manager.session_protection = "strong"
login_manager.login_message = "Please login to access this page"
login_manager.login_message_category = "info"
rest_api = Api()
@login_manager.user_loader
def load_user(userid):
from models import User
return User.query.get(userid)
@oid.after_login
def create_or_login(resp):
from models import db, User
username = resp.fullname or resp.nickname or resp.email
if not username:
flash('Invalid login. Please try again.', 'danger')
from flask import Flask, request, make_response, jsonify, abort, g
from flask.ext.restful import Api, Resource
from flask.ext.httpauth import HTTPBasicAuth
from app.models import *
from app import functions
app = Flask(__name__)
app.config.from_object('config')
api = Api(app)
auth = HTTPBasicAuth()
class BaseAPI(Resource):
@app.before_request
def before_request():
print 'Before request'
@app.after_request
def after_request(response):
print 'After request'
return response
@app.errorhandler(404)
"""
Defines the blueprint for the users
"""
from flask import Blueprint
from flask.ext.restful import Api
from resources import DeviceResource
DEVICE_BLUEPRINT = Blueprint('device', __name__)
Api(DEVICE_BLUEPRINT).add_resource(DeviceResource, '/device/<string:_id>')
