def setUp(self): class CustomParser1(parsers.BaseParser): media_type = '*/*' def parse(self, stream, media_type, content_length=None): return 'custom parser 1' class CustomParser2(parsers.BaseParser): media_type = '*/*' def parse(self, stream, media_type, content_length=None): return 'custom parser 2' app = FlaskAPI(__name__) app.config['DEFAULT_PARSERS'] = [CustomParser1] @app.route('/custom_parser_1/', methods=['POST']) def custom_parser_1(): return {'data': request.data} @app.route('/custom_parser_2/', methods=['POST']) @set_parsers([CustomParser2]) def custom_parser_2(): return {'data': request.data} @app.route('/custom_parser_2_as_args/', methods=['POST']) @set_parsers(CustomParser2, CustomParser1) def custom_parser_2_as_args(): return {'data': request.data} self.app = app
def setUp(self): class CustomRenderer1(renderers.BaseRenderer): media_type = 'application/example1' def render(self, data, media_type, **options): return 'custom renderer 1' class CustomRenderer2(renderers.BaseRenderer): media_type = 'application/example2' def render(self, data, media_type, **options): return 'custom renderer 2' app = FlaskAPI(__name__) app.config['DEFAULT_RENDERERS'] = [CustomRenderer1] app.config['PROPAGATE_EXCEPTIONS'] = True @app.route('/custom_renderer_1/', methods=['GET']) def custom_renderer_1(): return {'data': 'example'} @app.route('/custom_renderer_2/', methods=['GET']) @set_renderers([CustomRenderer2]) def custom_renderer_2(): return {'data': 'example'} @app.route('/custom_renderer_2_as_args/', methods=['GET']) @set_renderers(CustomRenderer2) def custom_renderer_2_as_args(): return {'data': 'example'} self.app = app
def test_render_browsable_encoding(self): app = FlaskAPI(__name__) @app.route('/_love', methods=['GET']) def love(): return {"test": "I <3 Python"} with app.test_client() as client: response = client.get('/_love', headers={"Accept": "text/html"}) html = str(response.get_data()) self.assertTrue('I <3 Python' in html) self.assertTrue('<h1>Love</h1>' in html) self.assertTrue('/_love' in html)
def test_render_browsable_linking(self): app = FlaskAPI(__name__) @app.route('/_happiness', methods=['GET']) def happiness(): return {"url": "http://example.org", "a tag": "<br />"} with app.test_client() as client: response = client.get('/_happiness', headers={"Accept": "text/html"}) html = str(response.get_data()) self.assertTrue('<a href="http://example.org">http://example.org</a>' in html) self.assertTrue('<br />'in html) self.assertTrue('<h1>Happiness</h1>' in html) self.assertTrue('/_happiness' in html)
def _run_mocked(): app = FlaskAPI(__name__) app.url_map.converters['regex'] = RegexConverter app.debug = True app.register_blueprint(api, url_prefix=DEFAULT_PREFIX) @app.after_request def print_mock(response): from pprint import pformat # noinspection PyUnresolvedReferences logger.debug(pformat(dagor_focus.mock_calls, indent=4)) return response app.run("0.0.0.0")
from flask.templating import render_template from flask_api import FlaskAPI from flask_api.decorators import set_renderers from flask_api.renderers import HTMLRenderer application = FlaskAPI(__name__) @application.route("/", methods=['GET']) @application.route("/home", methods=['GET']) @set_renderers(HTMLRenderer) def home(): params_tpl = {} return render_template('index.html', params_tpl=params_tpl) @application.route("/login", methods=['GET']) @set_renderers(HTMLRenderer) def login(): params_tpl = {} return render_template('login.html', params_tpl=params_tpl) @application.route("/panels_wells", methods=['GET']) @set_renderers(HTMLRenderer) def panels_wells(): params_tpl = {} return render_template('panels-wells.html', params_tpl=params_tpl) @application.route("/buttons", methods=['GET']) @set_renderers(HTMLRenderer)
from flask import request, url_for, render_template from flask_api import FlaskAPI, status, exceptions app = FlaskAPI(__name__) import pickle loaded_model = pickle.load(open('finalized_model_svm_2.sav', 'rb')) # calculate TF def compute_TF(word_dict, bow): tf_dict = {} bow_count = len(bow) for word in word_dict: tf_dict[word] = word_dict[word] / (float(bow_count)+1) return tf_dict def compute_IDF(doc_list): import math idf_dict = {} N = len(doc_list) # count number of documents that contain this word idf_dict = dict.fromkeys(doc_list[0].keys(), 0) for doc in doc_list: for word in doc: if doc[word] > 0: idf_dict[word] += 1
from flask_api import FlaskAPI import os app = FlaskAPI("Optic") @app.route('/') def index(): return "hi world" app.run(port=os.environ['OPTIC_API_PORT'] if 'OPTIC_API_PORT' in os.environ else 4003)
from flask import request, jsonify from flask_api import FlaskAPI from flask_cors import CORS, cross_origin import random from statistics import mean from datetime import datetime app = FlaskAPI(__name__) cors = CORS(app) app.config['CORS_HEADERS'] = 'Content-Type' criterio = 1 seleccion = 1 data = [] generacion = 0 tam_poblacion = 10 tam_solucion = 4 class Nodo: def __init__(self, solucion = [], fitness = 0): self.solucion = solucion self.fitness = fitness def mutar(solucion): if random.uniform(0, 1) <= 0.5: index = 0 while index < tam_solucion: if random.uniform(0, 1) <= 0.5: solucion[index] = round(random.uniform(-2, 2), 5) index += 1
from flask_api import FlaskAPI from flask import request from flask_cors import CORS, cross_origin import os from datetime import datetime import moment from .blueprints.ranking import ranking_blueprint from .blueprints.retencao import retencao_blueprint # def create_app(setting=None): # Inicia uma aplicacap flask app = FlaskAPI(__name__) if 'FLASK_CONFIG' in os.environ.keys(): app.config.from_object('app.settings.' + os.environ['FLASK_CONFIG']) else: app.config.from_object('app.settings.Development') # if setting: # # atribui as configuracoes na aplicacao # app.config.from_object(setting) # configura cors # Essa configuracao permite que todas as requisicoes possam ser feitas, # eliminando os erros de Requests que ocorrem em alguns navegadores cors = CORS(app, resources={r"/*": {"origins": "*"}})
logger.debug("CONFIGURATION SETTING[aws_region]: %s " % config.get_aws_region()) logger.debug("CONFIGURATION SETTING[block_cypher_token]: %s " % config.get_block_cypher_token()) logger.debug("CONFIGURATION SETTING[block_cypher_url]: %s " % config.get_block_cypher_url()) logger.debug("CONFIGURATION SETTING[coin_network]: %s " % config.get_coin_network()) logger.debug("CONFIGURATION SETTING[db_url]: %s " % config.get_db_url()) logger.debug("CONFIGURATION SETTING[debug_log]: %s " % config.get_debug_log()) logger.debug("CONFIGURATION SETTING[key_id]: %s " % config.get_key_id()) logger.debug("CONFIGURATION SETTING[local_db_url]: %s " % config.get_local_db_url()) logger.debug("CONFIGURATION SETTING[local_server_url]: %s " % config.get_local_server_url()) logger.debug("CONFIGURATION SETTING[remote_db_url]: %s " % config.get_remote_db_url()) logger.debug("CONFIGURATION SETTING[remote_server_url]: %s " % config.get_remote_server_url()) logger.debug("CONFIGURATION SETTING[wallet_type]: %s " % config.get_wallet_type()) logger.debug("-------------------------ENVIRONMENT--------------------------") keyId = config.get_key_id() application = FlaskAPI(__name__) wallet = wallet.create_wallet(config.get_wallet_type(), config, logger) account_service = AccountService(wallet, logger) notarization_service = NotarizationService(wallet, logger) secure_message = SecureMessage(wallet) def convert_account(): file_encryption_key = wallet.decrypt_from_hex(g.account_data['file_encryption_key']) converted_account = dict(g.account_data) converted_account['file_encryption_key'] = file_encryption_key del converted_account['nonce'] del converted_account['account_status'] del converted_account['public_key'] del converted_account['address'] return converted_account
from flask import request from flask_api import FlaskAPI, status from services.mailgun import MailgunEmailService from services.pool import PooledEmailService from services.sendgrid import SendgridEmailService from email_message import EmailMessage import logging app = FlaskAPI(__name__) pool = PooledEmailService() logging.basicConfig(level=logging.INFO) def domain_repr(domain, is_root_admin=False, list_endpoint_urls=False): dom = pool.enabled_domains.get(domain) if dom is None: return None out = {"domain": domain, "url": request.host_url + domain} if is_root_admin and list_endpoint_urls: out["services"] = list(map(lambda x: { "name": x.name, "priority": x.priority, "api_key": x.api_key, "url_toggle_failure": "{}{}/{}/fail".format(request.host_url, domain, x.name) }, dom['enabled_services'])) elif is_root_admin: out["services"] = list( map(lambda x: {"name": x.name, "priority": x.priority, "api_key": x.api_key}, dom['enabled_services']))
from bokeh.io import export_png from datetime import timedelta import datetime from bokeh.models import Range1d import matplotlib.pyplot as plt logging.basicConfig(level=logging.INFO) logger = logging.getLogger(__name__) warnings.simplefilter(action='ignore', category=FutureWarning) plt.switch_backend('agg') app = FlaskAPI(__name__) app.args = {} api_url = 'https://www.isyatirim.com.tr/_Layouts/15/IsYatirim.Website/Common/ChartData.aspx/IndexHistoricalAll?period=1440&from=%s000000&to=%s235959&endeks=%s.E.BIST' @app.route('/', methods=['GET']) def home(): return render_template('index.html') @app.route('/stock-names', methods=['GET']) def stock_names(): search = request.args.get('search') with open(os.path.join('.', 'data', 'stock_names.json')) as f: names = json.load(f)
def create_app(db_file=None): """create app.""" app = FlaskAPI(__name__) per_page = int( os.getenv('BUKUSERVER_PER_PAGE', str(views.DEFAULT_PER_PAGE))) per_page = per_page if per_page > 0 else views.DEFAULT_PER_PAGE app.config['BUKUSERVER_PER_PAGE'] = per_page url_render_mode = os.getenv('BUKUSERVER_URL_RENDER_MODE', views.DEFAULT_URL_RENDER_MODE) if url_render_mode not in ('full', 'netloc'): url_render_mode = views.DEFAULT_URL_RENDER_MODE app.config['BUKUSERVER_URL_RENDER_MODE'] = url_render_mode app.config['SECRET_KEY'] = os.getenv( 'BUKUSERVER_SECRET_KEY') or os.urandom(24) disable_favicon = os.getenv('BUKUSERVER_DISABLE_FAVICON', 'false') app.config['BUKUSERVER_DISABLE_FAVICON'] = \ False if disable_favicon.lower() in ['false', '0'] else bool(disable_favicon) open_in_new_tab = os.getenv('BUKUSERVER_OPEN_IN_NEW_TAB', 'false') app.config['BUKUSERVER_OPEN_IN_NEW_TAB'] = \ False if open_in_new_tab.lower() in ['false', '0'] else bool(open_in_new_tab) app.config['BUKUSERVER_DB_FILE'] = os.getenv( 'BUKUSERVER_DB_FILE') or db_file reverse_proxy_path = os.getenv('BUKUSERVER_REVERSE_PROXY_PATH') if reverse_proxy_path: if not reverse_proxy_path.startswith('/'): print('Warning: reverse proxy path should include preceding slash') if reverse_proxy_path.endswith('/'): print( 'Warning: reverse proxy path should not include trailing slash' ) app.config['REVERSE_PROXY_PATH'] = reverse_proxy_path ReverseProxyPrefixFix(app) bukudb = BukuDb(dbfile=app.config['BUKUSERVER_DB_FILE']) app.app_context().push() setattr(flask.g, 'bukudb', bukudb) @app.shell_context_processor def shell_context(): """Shell context definition.""" return {'app': app, 'bukudb': bukudb} app.jinja_env.filters['netloc'] = lambda x: urlparse(x).netloc # pylint: disable=no-member Bootstrap(app) admin = Admin(app, name='buku server', template_mode='bootstrap3', index_view=views.CustomAdminIndexView( template='bukuserver/home.html', url='/')) # routing # api tag_api_view = ApiTagView.as_view('tag_api') app.add_url_rule('/api/tags', defaults={'tag': None}, view_func=tag_api_view, methods=['GET']) app.add_url_rule('/api/tags/<tag>', view_func=tag_api_view, methods=['GET', 'PUT']) bookmark_api_view = ApiBookmarkView.as_view('bookmark_api') app.add_url_rule('/api/bookmarks', defaults={'rec_id': None}, view_func=bookmark_api_view, methods=['GET', 'POST', 'DELETE']) app.add_url_rule('/api/bookmarks/<int:rec_id>', view_func=bookmark_api_view, methods=['GET', 'PUT', 'DELETE']) app.add_url_rule('/api/bookmarks/refresh', 'refresh_bookmark', refresh_bookmark, defaults={'rec_id': None}, methods=['POST']) app.add_url_rule('/api/bookmarks/<int:rec_id>/refresh', 'refresh_bookmark', refresh_bookmark, methods=['POST']) app.add_url_rule('/api/bookmarks/<int:rec_id>/tiny', 'get_tiny_url', get_tiny_url, methods=['GET']) app.add_url_rule('/api/network_handle', 'network_handle', handle_network, methods=['POST']) bookmark_range_api_view = ApiBookmarkRangeView.as_view( 'bookmark_range_api') app.add_url_rule('/api/bookmarks/<int:starting_id>/<int:ending_id>', view_func=bookmark_range_api_view, methods=['GET', 'PUT', 'DELETE']) bookmark_search_api_view = ApiBookmarkSearchView.as_view( 'bookmark_search_api') app.add_url_rule('/api/bookmarks/search', view_func=bookmark_search_api_view, methods=['GET', 'DELETE']) # non api admin.add_view( views.BookmarkModelView(bukudb, 'Bookmarks', page_size=per_page, url_render_mode=url_render_mode)) admin.add_view(views.TagModelView(bukudb, 'Tags', page_size=per_page)) admin.add_view( views.StatisticView(bukudb, 'Statistic', endpoint='statistic')) return app
def create_app(config_name): bot_id = 'UMTM6Q95F' app = FlaskAPI(__name__, instance_relative_config=False) app.config.from_object(app_env[config_name]) app.config.from_pyfile('../config/env.py') redis_client = redis.from_url(os.environ.get("REDIS_URL")) @app.route('/sendall', methods=['GET']) def sendall(): slackhelper = SlackHelper() request = slackhelper.get_users_in_channel() if request['ok']: for item in request['members']: print(item['id']) slackhelper.post_message('Morning, where are you located today?\nPlease write your location in one line (city, building, floor...)\nIf you need to search for a user, use his username with the @.\nThank you! :smile:', item['id']) response_body = {'text': ':)'} response = jsonify(response_body) response.status_code = 200 return response @app.route('/send', methods=['GET']) def send(): slackhelper = SlackHelper() slackhelper.post_message('Morning, where are you located today?\nPlease write your location in one line (city, building, floor...)\nIf you need to search for a user, use his username with the @.\nThank you! :smile:', 'DN036B2PJ') response_body = {'text': ':)'} response = jsonify(response_body) response.status_code = 200 return response @app.route('/clean', methods=['GET']) def clean(): redis_client.flushdb() response_body = {'text': ':)'} response = jsonify(response_body) response.status_code = 200 return response @app.route('/spotbot', methods=['POST']) def hackabot(): command_text = request.data.get('text') command_text = command_text.split(' ') slack_uid = request.data.get('user_id') slackhelper = SlackHelper() slack_user_info = slackhelper.user_info(slack_uid) actions = Actions(slackhelper, slack_user_info) if command_text[0] not in allowed_commands: response_body = {'text': 'Invalid Command Sent - `/spotbot info` for available commands'} if command_text[0] == 'info': response_body = actions.info() response = jsonify(response_body) response.status_code = 200 return response @app.route('/change', methods=['POST']) def change(): text = request.data.get('text') slack_uid = request.data.get('user_id') slackhelper = SlackHelper() slack_user_info = slackhelper.user_info(slack_uid) user_name = slack_user_info['user']['name'] redis_client.set(user_name.encode('utf8'), text) response_body = "Your location is stored succesfully as %s" % (text) response = jsonify(response_body) response.status_code = 200 return response @app.route('/locate', methods=['POST']) def locate(): text = request.data.get('text') text = text.split(' ') user = text[0] print(user) if not user.startswith('@'): response_body = {'text': 'The username must start with @'} else: location = redis_client.get(user[1:]).decode('utf8') or '%s hasn\'t set his location yet' % (user) response_body = "%s: %s" % (user, location) response = jsonify(response_body) response.status_code = 200 return response @app.route('/reaction', methods=['POST']) def reaction(): type = request.data.get('type') event = request.data.get('event') user_id = event['user'] channel = event['channel'] text = event['text'] if type == 'url_verification': response_body = request.data.get('challenge') else: response_body = 'Hi!' if not user_id == bot_id: slackhelper = SlackHelper() slack_user_info = slackhelper.user_info(user_id) user_name = slack_user_info['user']['name'] clean_user_name = slack_user_info['user']['profile']['real_name_normalized'] words_to_check = [' close to ',' near ',' next to ',' beside ',' in front of ',' behind ',' on ',' in ',' at ',' on ',' top of ',' within ',' beneath ',' under ','building','bau','basel','kau','kaiseraugst','floor','home','wfh'] print (text) if re.search("@(?!\W)", text): m = re.findall(r'[@]\w+', text) print(m) user = m[0] print('username: '******'user: '******'user']['profile']['real_name_normalized'] location = redis_client.get(user[1:]) or 'The user hasn\'t set the location yet' if location == 'The user hasn\'t set the location yet': slackhelper.post_message(location, channel) else: slackhelper.post_message("%s: %s" % (search_clean_user_name, location.decode('utf8')), channel) elif any(word.lower() in text.lower() for word in words_to_check): slackhelper = SlackHelper() print(user_name) redis_client.set(user_id, text) slackhelper.post_message('Thank you! :smile: I have recorded your location.\nHave a good day!', channel) elif 'list' in text: if len(redis_client.keys()) > 0: list = '' print(redis_client.keys()) for user in redis_client.keys(): print(user) print(slackhelper.user_info(user)) name = slackhelper.user_info(user)['user']['profile']['real_name_normalized'] list = list + name + ': '+ redis_client.get(user).decode('utf8') + '\n' slackhelper.post_message(list, user_id) else: slackhelper.post_message('Sorry, there are no users registered', user_id) else: slackhelper.post_message('Sorry :disappointed:, I didn\'t understand your request.\n - If you want to add your location, please say in one line where are you located (city, building, floor...)\nIf you need to search for a user use his username with the @.\nThank you! :smile:', channel) else: print("nothing") response = jsonify(response_body) response.status_code = 200 return response return app
def create_app(config_name): app = FlaskAPI(__name__, instance_relative_config=True) app.config.from_pyfile('config.py') app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False app.config.from_object(app_config[config_name]) # for removing trailing slashes enforcement app.url_map.strict_slashes = False db.init_app(app) from .models import ExpenseTracker, User @app.route('/expenses/', methods=['POST', 'GET']) def expense(): # Get the access token from the header auth_header = request.headers.get('Authorization') if auth_header is None: response = jsonify({ 'message': f'Authorization header missing', 'status': 'error' }) response.status_code = 401 return response if auth_header == '': response = jsonify({ 'message': f'Please insert Bearer token', 'status': 'error' }) response.status_code = 401 return response access_token = auth_header.split(" ") if len(access_token) < 2: response = jsonify({ 'message': f'Authorization token should start with keyword Bearer', 'status': 'error' }) response.status_code = 401 return response access_token = auth_header.split(" ")[1] if access_token: # Attempt to decode the token and get the User ID user_id = User.decode_token(access_token) if not isinstance(user_id, str): # Go ahead and handle the request, the user is authenticated if request.method == "POST": name = str(request.data.get('name', '')) amount = str(request.data.get('amount', '')).strip() try: amount_num = float(amount) except ValueError: response = jsonify({ 'message': f'the amount entered is not a valid number', 'status': 'error' }) response.status_code = 400 return response date_of_expense = str( request.data.get('date_of_expense', '')).strip() try: date = datetime.datetime.strptime( date_of_expense, '%d-%m-%Y') except ValueError: response = jsonify({ 'message': f'The date {date_of_expense} does not match the format DD-MM-YYYY', 'status': 'error' }) response.status_code = 400 return response if not name: response = jsonify({ 'message': 'PLease enter a valid name', 'status': 'error' }) response.status_code = 400 return response expense = ExpenseTracker(name=name, amount=amount_num, date_of_expense=date, belongs_to=user_id) expense.save() response = jsonify({ 'id': expense.id, 'name': expense.name, 'amount': expense.amount_spent, 'date_of_expense': expense.date_of_expense.strftime('%d-%m-%Y'), 'date_created': expense.date_created, 'date_modified': expense.date_modified, 'belongs_to': expense.belongs_to }) response.status_code = 201 return response else: # GET results = [] # get the query string for limit if it exists and for pagination # if the query parameter for limit doesn't exist, 20 is used by default limit = request.args.get( 'limit', str(Config.DEFAULT_PAGINATION_LIMIT)) try: limit = int(limit) except ValueError: # if limit value is gibberish, default to 20 limit = Config.DEFAULT_PAGINATION_LIMIT # if limit supplied is greater than 100, display only 100 if limit > Config.MAXIMUM_PAGINATION_LIMIT: limit = Config.MAXIMUM_PAGINATION_LIMIT # set the default page to display to 1 page = request.args.get('page', '1') try: page = int(page) except ValueError: # if page value is gibberish, default to 1 page = 1 if limit < 1 or page < 1: return abort(404, 'Page or Limit must be greater than 1') queries = [] search_str = request.args.get('name') if search_str: queries.append( ExpenseTracker.name.ilike(f'%{search_str}%')) start_date_str = request.args.get('start_date') if start_date_str: try: start_date = datetime.datetime.strptime( start_date_str, '%d-%m-%Y') except ValueError: response = jsonify({ 'message': f'The date {start_date_str} does not match the format DD-MM-YYYY', 'status': 'error' }) response.status_code = 400 return response queries.append( ExpenseTracker.date_of_expense >= start_date) end_date_str = request.args.get('end_date') if end_date_str: try: end_date = datetime.datetime.strptime( end_date_str, '%d-%m-%Y') except ValueError: response = jsonify({ 'message': f'The date {end_date_str} does not match the format DD-MM-YYYY', 'status': 'error' }) response.status_code = 400 return response queries.append( ExpenseTracker.date_of_expense <= end_date) expenses = ExpenseTracker.query.filter_by( belongs_to=user_id).filter(*queries).paginate( page, limit) if page == 1: prev_page = None else: prev_page = url_for( 'expense') + f'?limit={limit}&page={page - 1}' if page < expenses.pages: next_page = url_for( 'expense') + f'?limit={limit}&page={page + 1}' else: next_page = None for expense in expenses.items: obj = { 'id': expense.id, 'name': expense.name, 'amount': expense.amount_spent, 'date_of_expense': expense.date_of_expense.strftime('%d-%m-%Y'), 'date_created': expense.date_created, 'date_modified': expense.date_modified, 'belongs_to': expense.belongs_to } results.append(obj) return make_response( jsonify({ 'items': results, 'total_items': expenses.total, 'total_pages': expenses.pages, 'prev_page': prev_page, 'next_page': next_page, })), 200 else: # user is not legit, so the payload is an error message message = user_id response = {'message': message} return make_response(jsonify(response)), 401 else: response = jsonify({ 'message': f'Please enter an access code', 'status': 'error' }) response.status_code = 401 return response @app.route('/expenses/<int:id>', methods=['GET', 'PUT', 'DELETE']) def expense_manipulation(id, **kwargs): auth_header = request.headers.get('Authorization') if auth_header is None: response = jsonify({ 'message': f'Authorization header missing', 'status': 'error' }) response.status_code = 401 return response if auth_header == '': response = jsonify({ 'message': f'Please insert Bearer token', 'status': 'error' }) response.status_code = 401 return response access_token = auth_header.split(" ") if len(access_token) < 2: response = jsonify({ 'message': f'Authorization token should start with keyword Bearer', 'status': 'error' }) response.status_code = 401 return response access_token = auth_header.split(" ")[1] if access_token: # Get the user id related to this access token user_id = User.decode_token(access_token) if not isinstance(user_id, str): # If the id is not a string(error), we have a user id # Get the bucketlist with the id specified from the URL (<int:id>) expense = ExpenseTracker.query.filter_by( id=id, belongs_to=user_id).first() if not expense: response = jsonify({ 'message': f'The Expense with this ID: {id} does not exist', 'status': 'error' }) response.status_code = 404 return response if request.method == 'DELETE': expense.delete() return { "message": "Expense {} deleted successfully".format(expense.id) }, 200 elif request.method == 'PUT': name = str(request.data.get('name', '')) amount = str(request.data.get('amount', '')).strip() if amount: try: amount_num = float(amount) except ValueError: response = jsonify({ 'message': f'the amount entered is not a valid number', 'status': 'error' }) response.status_code = 400 return response expense.amount_spent = amount_num date_of_expense = str( request.data.get('date_of_expense', '')).strip() if date_of_expense: try: date = datetime.datetime.strptime( date_of_expense, '%d-%m-%Y') except ValueError: response = jsonify({ 'message': f'The date {date_of_expense} does not match the format DD-MM-YYYY', 'status': 'error' }) response.status_code = 400 return response expense.date_of_expense = date if name: expense.name = name else: response = jsonify({ 'message': 'PLease enter a valid name', 'status': 'error' }) response.status_code = 400 return response expense.save() response = jsonify({ 'id': expense.id, 'name': expense.name, 'amount': expense.amount_spent, 'date_of_expense': expense.date_of_expense.strftime('%d-%m-%Y'), 'date_created': expense.date_created, 'date_modified': expense.date_modified, 'belongs_to': expense.belongs_to }) response.status_code = 200 return response else: # GET response = jsonify({ 'id': expense.id, 'name': expense.name, 'amount': expense.amount_spent, 'date_of_expense': expense.date_of_expense, 'date_created': expense.date_created, 'date_modified': expense.date_modified, 'belongs_to': expense.belongs_to }) response.status_code = 200 return response else: response = jsonify({ 'message': f'Please enter an access token', 'status': 'error' }) response.status_code = 401 return response @app.route('/monthly_report', methods=['GET']) def month_expense(): auth_header = request.headers.get('Authorization') if auth_header is None: response = jsonify({ 'message': f'Authorization header missing', 'status': 'error' }) response.status_code = 401 return response if auth_header == '': response = jsonify({ 'message': f'Please insert Bearer token', 'status': 'error' }) response.status_code = 401 return response access_token = auth_header.split(" ") if len(access_token) < 2: response = jsonify({ 'message': f'Authorization token should start with keyword Bearer', 'status': 'error' }) response.status_code = 401 return response access_token = auth_header.split(" ")[1] if access_token: # Get the user id related to this access token user_id = User.decode_token(access_token) if not isinstance(user_id, str): # If the id is not a string(error), we have a user id # Get the bucketlist with the id specified from the URL (<int:id>) expenses = ExpenseTracker.query.filter_by( belongs_to=user_id).first() month = request.args.get('month') if month: try: date = datetime.datetime.strptime(month, '%m-%Y') except ValueError: response = jsonify({ 'message': f'The date {month} does not match the format MM-YYYY', 'status': 'error' }) response.status_code = 400 return response else: response = jsonify({ 'message': f'Please enter a Month', 'status': 'error' }) response.status_code = 400 return response expenses = ExpenseTracker.query.with_entities( func.sum(ExpenseTracker.amount_spent), ExpenseTracker.date_of_expense) \ .filter_by(belongs_to=user_id) \ .filter(extract('year', ExpenseTracker.date_of_expense) == date.year) \ .filter(extract('month', ExpenseTracker.date_of_expense) == date.month) \ .group_by(ExpenseTracker.date_of_expense)\ .order_by(ExpenseTracker.date_of_expense.desc())\ .all() # # results = dict() # for expense in expenses: # expense_date = expense.date_of_expense.strftime('%d/%m/%Y') # if expense_date in results: # results[expense_date] += expense.amount_spent # else: # results[expense_date] = expense.amount_spent # # results = [] consolidated_total = 0.0 # expenses.sort(key=lambda tup: tup[1], reverse=True) for total_amount, expense_date in expenses: consolidated_total += total_amount obj = { 'date': expense_date.strftime('%d/%m/%Y'), 'total_expenses': total_amount } results.append(obj) return make_response( jsonify({ 'items': results, 'consolidated_total': consolidated_total })), 200 else: response = jsonify({ 'message': f'Please enter an access token', 'status': 'error' }) response.status_code = 401 return response @app.route('/yearly_report', methods=['GET']) def year_expense(): auth_header = request.headers.get('Authorization') if auth_header is None: response = jsonify({ 'message': f'Authorization header missing', 'status': 'error' }) response.status_code = 401 return response if auth_header == '': response = jsonify({ 'message': f'Please insert Bearer token', 'status': 'error' }) response.status_code = 401 return response access_token = auth_header.split(" ") if len(access_token) < 2: response = jsonify({ 'message': f'Authorization token should contain the keyword "Bearer" followed' f' by a space and then the access token', 'status': 'error' }) response.status_code = 401 return response access_token = auth_header.split(" ")[1] if access_token: # Get the user id related to this access token user_id = User.decode_token(access_token) if not isinstance(user_id, str): # If the id is not a string(error), we have a user id # Get the bucketlist with the id specified from the URL (<int:id>) expenses = ExpenseTracker.query.filter_by( belongs_to=user_id).first() year = request.args.get('year') if year: try: date = datetime.datetime.strptime(year, '%Y') except ValueError: response = jsonify({ 'message': f'The date {year} does not match the format YYYY', 'status': 'error' }) response.status_code = 400 return response else: response = jsonify({ 'message': f'Please enter a Year', 'status': 'error' }) response.status_code = 400 return response expenses = ExpenseTracker.query.with_entities( func.sum(ExpenseTracker.amount_spent).label("total_amount"), extract('month', ExpenseTracker.date_of_expense), extract('year', ExpenseTracker.date_of_expense)) \ .filter_by(belongs_to=user_id) \ .filter(extract('year', ExpenseTracker.date_of_expense) == date.year) \ .group_by(extract('year', ExpenseTracker.date_of_expense), extract('month', ExpenseTracker.date_of_expense)) \ .all() consolidated_total = 0.0 results = [] for total_amount, month, year in expenses: consolidated_total += total_amount obj = { 'month': f'{int(month)}-{int(year)}', 'total_expenses': total_amount } results.append(obj) return make_response( jsonify({ 'months': results, 'consolidated_total': consolidated_total })), 200 else: response = jsonify({ 'message': f'Please enter an access token', 'status': 'error' }) response.status_code = 401 return response from .auth import auth_blueprint app.register_blueprint(auth_blueprint) return app
# coding: utf-8 from flask import request, url_for from flask_api import FlaskAPI, status, exceptions #FlaskAPI docs avilable at http://www.flaskapi.org/ from flask import Flask, render_template from flask_googlemaps import GoogleMaps from flask_googlemaps import Map, icons import json, requests port = 5000 debug = True reload = True app = FlaskAPI(__name__, template_folder="templates") # you can set key as config app.config['GOOGLEMAPS_KEY'] = os.environ["GOOGLE_MAPS_API_KEY"] # you can also pass key here GoogleMaps(app, key=os.environ["GOOGLE_MAPS_API_KEY"]) #begin Auxiliary Functions def LLR(): table = [] llr_table = [] count = 0 with open('MODIS_C6_Global_24h.json', 'r') as data_file: for line in data_file: try:
Description: Initializes the Flask backend object and connectes pyrebase to the backend by creating a pyrebase instance. Authors: Imran, Sharan, Nour """ ####### External imports ####### # import pyrebase for Firebase interaction import pyrebase # import supporting flask backend packages from flask_api import FlaskAPI from flask.cli import FlaskGroup # define the Flask backend object and set configuration parameters app = FlaskAPI(__name__) app.config["CORS_HEADERS"] = "Content-Type" cli = FlaskGroup(app) # initalize a firebase connection to the databse using pyrebase firebase = pyrebase.initialize_app( { "apiKey": "AIzaSyDtxf_1m144v64a8gJra4khyQZXnyNYfEk", "authDomain": "cse110-bitfit.firebaseapp.com", "databaseURL": "https://cse110-bitfit.firebaseio.com", "projectId": "cse110-bitfit", "storageBucket": "cse110-bitfit.appspot.com", "messagingSenderId": "140684277401", "appId": "1:140684277401:web:42a04b6e00773d52856a08", "measurementId": "G-PHN7BE72HF", }
import logging import uuid from flask import Flask, jsonify, request from werkzeug.exceptions import HTTPException from flask_cors import CORS from flask_api import FlaskAPI from functools import wraps log = logging.getLogger(__name__) #app = Flask(__name__) app = FlaskAPI(__name__) # Allows OPTIONS requests everywhere. cors = CORS(app) # Default settings settings = { "host": "0.0.0.0", "port": 9000, "threaded": True, # Do not use debug settings here, as this will spawn new processes of the salt-minion } @app.errorhandler(Exception) def handle_error(e): log.error('exception occurred: {:}'.format(e)) code = 500 if isinstance(e, HTTPException): code = e.code
from flask import request, url_for from flask_api import FlaskAPI, status, exceptions import time app = FlaskAPI(__name__) notes = { 0: 'do the shopping', 1: 'build the codez', 2: 'paint the door', } def note_repr(key): return { 'url': request.host_url.rstrip('/') + url_for('notes_detail', key=key), 'text': notes[key] } @app.route("/", methods=['GET', 'POST']) def notes_list(): """ List or create notes. """ if request.method == 'POST': note = str(request.data.get('text', '')) idx = max(notes.keys()) + 1 notes[idx] = note return note_repr(idx), status.HTTP_201_CREATED
from werkzeug.security import safe_str_cmp from flask_jwt import JWT, jwt_required, current_identity from peewee import * from backend.ingredients import getingredients from .product import containspalm, getname from backend.carbon import get_carbon_footprint, get_car_footprint from backend.train import calctrainfromdistance from backend.plane import calcflightfromdistance from flask import request from flask_api import FlaskAPI, status from playhouse.flask_utils import FlaskDB from flask_cors import CORS import datetime app = FlaskAPI(__name__) CORS(app) db_wrapper = FlaskDB(app, 'sqlite:///my_app.db') from .models import * # noqa app.config.from_object(__name__) app.config["SECRET_KEY"] = "ligma" def authenticate(username, password): user = User.get_or_none(username=username) if user is None: return None if user.verify_password(password): return user else: return None
from flask import Response from flask_api import FlaskAPI from flask import request import markdown from api import OpenPaymentsBL app = FlaskAPI(__name__) @app.route("/specialties/", methods=['GET']) def get_specialties(): """Returns list of distinct specialties from the data source""" specialties = OpenPaymentsBL.OpenPaymentsBL.get_specialties() if specialties is None: return Response(status=500, response='Error in get specialties') return specialties @app.route("/kol/<string:specialty>", methods=['GET']) def get_kol(specialty): """Returns the top Key opinion leaders for a given specialty Arguments: :param specialty - the specialty to look for limit (optional) - how many rows to return (default = 5) """ if 'limit' in request.args: limit = int(request.args['limit']) results = OpenPaymentsBL.OpenPaymentsBL.get_kol_by_specialty(specialty, limit) else: results = OpenPaymentsBL.OpenPaymentsBL.get_kol_by_specialty(specialty)
from flask import Flask, Response, request from flask_api import FlaskAPI, exceptions from flask_sqlalchemy import SQLAlchemy import os, datetime, dateparser, iso8601 app = FlaskAPI(__name__) DB_PATH = os.environ['DB_PATH'] DEFAULT_FROM = os.environ['DEFAULT_FROM'] app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.abspath( DB_PATH + '/worst-tweets-db.sqlite') app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False db = SQLAlchemy(app) class Record(db.Model): id = db.Column(db.Integer, primary_key=True) key = db.Column(db.String(10)) timestamp = db.Column(db.DateTime) sentiment = db.Column(db.Float) text = db.Column(db.String(140)) def __init__(self, key, timestamp, sentiment, text): self.key = key self.timestamp = timestamp self.sentiment = sentiment self.text = text
from flask import request, url_for from flask_api import FlaskAPI, status, exceptions import tasktiger from redis import Redis from gsoa_task import call_gsoa # imports GSOA from R app = FlaskAPI(__name__) # redis stores all the quque information conn = Redis(host="redis") tiger = tasktiger.TaskTiger(connection=conn) NECESSARY_FIELDS = ['dataFilePath', 'classFilePath', 'gmtFilePath', 'outFilePath'] ACCEPTED_FIELDS = ['classificationAlgorithm', 'numCrossValidationFolds', 'numRandomIterations', 'numCores', 'removePercentLowestExpr', 'removePercentLowestVar', 'checkbox'] + NECESSARY_FIELDS # makes sure the feilds are present def validate_input(request_data): if set(NECESSARY_FIELDS) - set(request_data.keys()): print("necessary fields not added") if set(ACCEPTED_FIELDS) - set(request_data.keys()) - set(ACCEPTED_FIELDS): print("invalid fields passed : {}".format(set(ACCEPTED_FIELDS) - set(request_data.keys()) - set(ACCEPTED_FIELDS))) # puts gsoa jobs into the task tiger queque @app.route("/", methods=['GET', 'POST']) def gsoa_process(): """ List or create notes. """
def create_app(config_name): from app.models import Bucketlist, User app = FlaskAPI(__name__, instance_relative_config=True) app.config.from_object(app_config[config_name]) app.config.from_pyfile('config.py') app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False db.init_app(app) @app.route('/bucketlists', methods=['POST', 'GET']) def bucketlists(): # Get the access token from the header auth_header = request.headers.get('Authorization') access_token = auth_header.split(" ")[1] if access_token: # Attempt to decode the token and get the User ID user_id = User.decode_token(access_token) if not isinstance(user_id, str): # Go ahead and handle the request, the user is authenticated if request.method == "POST": name = str(request.data.get('name', '')) if name: bucketlist = Bucketlist(name=name, created_by=user_id) bucketlist.save() response = jsonify({ 'id': bucketlist.id, 'name': bucketlist.name, 'date_created': bucketlist.date_created, 'date_modified': bucketlist.date_modified, 'created_by': user_id }) return make_response(response), 201 else: # GET all the bucketlists created by this user bucketlists = Bucketlist.query.filter_by( created_by=user_id) results = [] for bucketlist in bucketlists: obj = { 'id': bucketlist.id, 'name': bucketlist.name, 'date_created': bucketlist.date_created, 'date_modified': bucketlist.date_modified, 'created_by': bucketlist.created_by } results.append(obj) return make_response(jsonify(results)), 200 else: # user is not legit, so the payload is an error message message = user_id response = {'message': message} return make_response(jsonify(response)), 401 @app.route('/bucketlists/<int:id>', methods=['GET', 'PUT', 'DELETE']) def bucketlist_manipulation(id, **kwargs): # Get the access token from the header auth_header = request.headers.get('Authorization') access_token = auth_header.split(" ")[1] if access_token: # Attempt to decode the token and get the User ID user_id = User.decode_token(access_token) if not isinstance(user_id, str): # Go ahead and handle the request, the user is authenticated # retrieve a buckelist using it's ID bucketlist = Bucketlist.query.filter_by(id=id).first() if not bucketlist: # Raise an HTTPException with a 404 not found status code abort(404) if request.method == 'DELETE': bucketlist.delete() return { "message": "bucketlist {} deleted successfully".format( bucketlist.id) }, 200 elif request.method == 'PUT': name = str(request.data.get('name', '')) bucketlist.name = name bucketlist.save() response = jsonify({ 'id': bucketlist.id, 'name': bucketlist.name, 'date_created': bucketlist.date_created, 'date_modified': bucketlist.date_modified }) response.status_code = 200 return response else: # GET response = jsonify({ 'id': bucketlist.id, 'name': bucketlist.name, 'date_created': bucketlist.date_created, 'date_modified': bucketlist.date_modified }) response.status_code = 200 return response else: # user is not legit, so the payload is an error message message = user_id response = {'message': message} return make_response(jsonify(response)), 401 # import the authentication blueprint and register it on the app from .auth import auth_blueprint app.register_blueprint(auth_blueprint) return app
# from .api.processing_block import BP as PROCESSING_BLOCK # from .api.processing_block_list import BP as PROCESSING_BLOCK_LIST # from .api.scheduling_block import BP as SCHEDULING_BLOCK # from .api.scheduling_block_list import BP as SCHEDULING_BLOCK_LIST LOG = logging.getLogger('SIP.EC.PCI') HANDLER = logging.StreamHandler(stream=sys.stdout) HANDLER.setFormatter(logging.Formatter( '%(name)s(%(levelname).6s) %(message)s')) HANDLER.setLevel(os.getenv('SIP_PCI_LOG_LEVEL', 'WARN')) LOG.addHandler(HANDLER) LOG.setLevel(os.getenv('SIP_PCI_LOG_LEVEL', 'WARN')) APP = FlaskAPI(__name__) CORS(APP, resources={r"/api/*": {"origins": "*"}}) # needed for the Web GUI? PREFIX = '/' APP.register_blueprint(HOME, url_prefix=PREFIX) APP.register_blueprint(HEALTH, url_prefix=PREFIX) APP.register_blueprint(SUBARRAY_LIST, url_prefix=PREFIX) # APP.register_blueprint(SUBARRAY, url_prefix=PREFIX) # APP.register_blueprint(SCHEDULING_BLOCK_LIST, url_prefix=PREFIX) # APP.register_blueprint(SCHEDULING_BLOCK, url_prefix=PREFIX) # APP.register_blueprint(PROCESSING_BLOCK_LIST, url_prefix=PREFIX) # APP.register_blueprint(PROCESSING_BLOCK, url_prefix=PREFIX) @APP.route('/') def home(): """Temporary helper function to link to the API routes"""
def create_app(): _app = FlaskAPI(__name__) return _app
from flask import request, url_for from flask_api import FlaskAPI, status, exceptions import LED_controller import time import json hostIP = "0.0.0.0" app = FlaskAPI(__name__) led = LED_controller.rgb([5, 4, 12]) @app.route("/", methods=['GET', 'POST']) def get_request(): if request.method == 'POST': return_val = {} payload = request.get_json(silent=True) if (payload.has_key('rgb')): led.set(payload['rgb']) print payload['rgb'] return_val = {'value': 'success'} if (payload.has_key('on') and not payload['on']): led.set([0, 0, 0]) return json.dumps(return_val) if __name__ == "__main__": app.run(host=hostIP) led.end
import os from flask import redirect, request, url_for, jsonify from flask_api import FlaskAPI, exceptions, status from werkzeug.utils import secure_filename import settings import prediction import buySuggestion UPLOAD_FOLDER = os.getenv("UPLOAD_FOLDER") ALLOWED_EXTENSIONS = set(['png', 'jpg', 'jpeg', 'gif']) app = FlaskAPI(__name__) app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER def allowed_file(filename): return '.' in filename and \ filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS def response(data, uri): return { 'url': uri + url_for('upload_file'), 'data': { 'predictions': [float(idx) for idx in data["predictions"]], 'classes': int(data["classes"]), 'max_prob': float(data["max_prob"]) }
from flask_api import FlaskAPI from flask_api import status from search.util.dataGrabber import grab_and_validate_symbol from search.service.stockSearch import stock_API_Response app = FlaskAPI(__name__) @app.route('/') def root(): return ("Welcome to Stock Searcher!<br/>" "To search stock please browse:<br/>" "https://stock-searcher.appspot.com/Stock_Symbol<br/>" "Example: https://stock-searcher.appspot.com/AMZN<br/>" "<br/>" "To Check status<br/>" "https://stock-searcher.appspot.com/status") @app.route('/<string:stock_symbol>') def stock_api(stock_symbol): return stock_API_Response(stock_symbol) @app.route('/status') def status_check(): if not grab_and_validate_symbol("AMZN"): return status.HTTP_404_NOT_FOUND return "Server Running"
import os import pandas as pd from flask import request, url_for, send_from_directory from flask_api import FlaskAPI, status, exceptions from werkzeug.utils import secure_filename from sklearn.preprocessing import normalize from scipy import stats import numpy as np import outliers import warnings import datetime warnings.filterwarnings('ignore') app = FlaskAPI(__name__) BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) app.config['UPLOAD_FOLDER'] = os.path.join(BASE_DIR,'ddc-api/upload/') tokenList = pd.read_csv(os.path.join(BASE_DIR,'ddc-api/data/tokens.csv')) def clean_filename(userid, file_filename): now = datetime.datetime.now() now_string = now.isoformat().replace(':','-').replace('.','-') return now_string + '_' + userid + '_' + secure_filename(file_filename) def is_jaccard(selected, medication_name): tuples = selected[['frequency','dose']].values # sufix _1 counts = selected[['count']].values # Rebuild Original Distribution and Normalization hist_freq = [] hist_dose = [] pd_hist = pd.DataFrame(columns=['freq','dose'])
import os import sys # import traceback from flask_api import FlaskAPI, status from flask_cors import CORS from flask_graphql import GraphQLView sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from lib.blame import BlameManager from lib.graphql.schema import schema app = FlaskAPI(__name__) # app.config['DEFAULT_RENDERERS'] = [ # 'flask_api.renderers.JSONRenderer', # 'flask_api.renderers.BrowsableAPIRenderer', # ] CORS(app, supports_credentials=True, origins=['http://localhost:8080']) app.add_url_rule('/graphql', view_func=GraphQLView.as_view('graphql', schema=schema, graphiql=False)) # Optional, for adding batch query support (used in Apollo-Client) # app.add_url_rule('/graphql/batch', view_func=GraphQLView.as_view('graphql', schema=schema, batch=True)) # TODO: this should probably be an argument to a track-commit or analysis mutation # excluded_exts = set() # ext_whitelist = ( # ".go", ".proto", ".c", ".h", ".sh", ".md", ".xml", ".wixproj", ".wsx", ".cs"
from flask_api import FlaskAPI from settings import config from controller import ProcessPayment app = FlaskAPI(__name__) app.config.from_object(config['development']) app.add_url_rule( '/process-payment', view_func=ProcessPayment.as_view('payment_request'), methods=['GET', 'POST'], ) if __name__ == "__main__": app.run()
def create_app(config_name): from app.models import Bucketlist app = FlaskAPI(__name__, instance_relative_config=True) app.config.from_object(app_config[config_name]) app.config.from_pyfile('config.py') app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False db.init_app(app) @app.route('/bucketlists/', methods=['POST','GET']) def bucketlists(): if request.method == 'POST': name=str(request.data.get('name', '')) if name: bucketlist = Bucketlist(name=name) bucketlist.save() response = jsonify({ 'id': bucketlist.id, 'name': bucketlist.date_created, 'date_created': bucketlist.date_created, 'date_modiified': bucketlist.date_modified }) response.status_code = 201 return response else: bucketlists = Bucketlist.get_all() results = [] for bucketlist in bucketlists: obj = { 'id': bucketlist.id, 'name': bucketlist.name, 'date_created': bucketlist.date_created, 'date_modified':bucketlist.date_modified } results.append(obj) response = jsonify(results) response.status_code = 200 return response @app.route('/bucketlists/<int:id>', methods = ['GET', 'PUT', 'DELETE']) def bucketlist_manipulation(id, **kwargs): bucketlist = Bucketlist.query.filter_by(id=id).first() if not bucketlist: abort(404) if request.method == 'DELETE': bucketlist.delete() return { "message": "bucketlist {} deleted successfully".format(bucketlist.id)}, 200 elif request.method == 'PUT': name = str(request.data.get('name', '')) bucketlist.name = name bucketlist.save() response = jsonify({ 'id': bucketlist.id, 'name': bucketlist.name, 'date_created': bucketlist.date_created, 'date_modified': bucketlist.date_modified }) response.status_code = 200 return response else: response = jsonify({ 'id': bucketlist.id, 'name': bucketlist.name, 'date_created': bucketlist.date_created, 'date_modified': bucketlist.date_modified }) response.status_code = 200 return response return app
def create_app(config_name): app = FlaskAPI(__name__, instance_relative_config=True) # overriding Werkzeugs built-in password hashing utilities using Bcrypt. bcrypt = Bcrypt(app) app.config.from_object(app_config[config_name]) app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False db.init_app(app) @app.route('/api/real/login/account', methods=['POST']) def login(): password = request.data.get('password', '') userName = request.data.get('userName', '') user = User.get_all().filter(User.userName == userName).first() if user is not None: response = jsonify({ 'status': 'ok', 'type': 'account', 'userId': user.id, 'currentAuthority': 'admin' }) loggedinuser = user.id session = Session(user.id) session.save() print('saved') return make_response(response), 200 return make_response( jsonify({ 'status': 'error', 'type': 'account', 'currentAuthority': 'guest' })), 200 @app.route('/api/real/logout', methods=['POST']) def logout(): Session.delete_all() return make_response(jsonify({'status': 'ok'})), 200 @app.route('/api/real/currentUser', methods=['GET']) def currentUser(): session = Session.get_all().first() if session == None: return make_response( jsonify({ 'status': 'ok', 'type': 'account', 'currentAuthority': 'guest' })), 200 print(session.userId) user = User.get_all().filter(User.id == session.userId).first() res = user.serialise() res['favourites'] = [] #for fav in user.favourites: # res['favourites'].append(Card.get_all().filter(Card.id == fav.cardId).first().serialise()) response = jsonify(res) return make_response(response), 200 @app.route('/api/real/pages', methods=['GET']) def getPages(): pages = Page.query.filter(Page.url == "dashboard/crossfiltermap") results = [] for page in pages: results.append(page.serialise()) return make_response(jsonify({'list': results})), 200 @app.route('/api/real/cardpositions', methods=['GET', 'POST']) def getCardPositions(): url = request.data.get('url', "/dashboard/analysis") userId = request.data.get('userId', 0) problemsetId = request.data.get('problemset', 0) position = request.data.get('position', None) page = Page.query.filter(Page.url == url).first() records = CardPosition.query.filter( CardPosition.key["id"].astext == str(problemsetId)).all() print(records) #get all cards for this page, with optional position parameter if position == None: cardpositions = CardPosition.query.filter( CardPosition.userId == userId).filter( CardPosition.key["type"].astext == "problemset").filter( CardPosition.key["id"].astext == str(problemsetId)) else: cardpositions = CardPosition.query.filter( CardPosition.userId == userId).filter(CardPosition.position == position).filter( CardPosition.key["type"].astext == "problemset").filter( CardPosition.key["id"].astext == str(problemsetId)) results = [] for cardposition in cardpositions.all(): results.append(cardposition.serialise()) return make_response(jsonify({'list': results})), 200 @app.route('/api/real/cardpositions/new', methods=['POST']) def newCardPositions(): cardId = request.data.get('cardId', 0) position = request.data.get('position', 0) key = request.data.get('key', {}) cardposition = CardPosition(1, cardId, 1, 4, position, key) cardposition.save() return make_response(jsonify(cardposition.serialise())), 200 @app.route('/api/real/favourites', methods=['GET']) def getFavourites(): favs = Favourite.query.all() results = [] for fav in favs: results.append(page.serialise()) return make_response(jsonify({'list': results})), 200 @app.route('/api/real/favourites', methods=['POST']) def create_fav(): userId = request.data.get('userId', 0) cardId = request.data.get('cardId', 0) fav = Favourite(userId, cardId) fav.save() favs = Favourite.get_all().all() results = [] for fav in favs: results.append(fav.serialise()) return make_response(jsonify({'list': results})), 200 @app.route('/api/real/admin/cardmappings', methods=['POST']) def list_cardmappings(): url = request.data.get('url', '') userId = request.data.get('userId', 0) page = Page.get_all().filter(Page.url == url).one() mappings = PageCard.get_all().filter( PageCard.pageId == page.id).filter( PageCard.userId == userId).order_by(PageCard.id).all() results = [] for mapping in mappings: results.append(mapping.serialise()) return make_response(jsonify({'list': results})), 200 @app.route('/api/real/admin/cardmappings/<id>', methods=['POST']) def update_cardmapping(id): enabled = request.data.get('enabled', 'N') url = request.data.get('url', '') userId = request.data.get('userId', 0) mapping = PageCard.get_all().filter(PageCard.id == id).one() mapping.enabled = enabled mapping.save() page = Page.get_all().filter(Page.url == url).one() mappings = PageCard.get_all().filter(PageCard.userId == userId).filter( PageCard.pageId == page.id).order_by(PageCard.id).all() results = [] for mapping in mappings: results.append(mapping.serialise()) return make_response(jsonify({'list': results})), 200 @app.route('/api/real/cards', methods=['POST']) def list_cards(): userid = request.data.get('userid', '0') url = request.data.get('url', '') type = request.data.get('type', '') id = str(request.data.get('id', '')) sql = text('select id from cards where key->> \'type\' = \'' + type + '\' and key->>\'id\' = \'' + id + '\'') print(sql) result = db.engine.execute(sql) cardids = [] for row in result: cardids.append(row[0]) cards = Card.get_all().filter(Card.id.in_(cardids)).all() results = [] for card in cards: results.append(card.serialise()) return make_response(jsonify({'list': results})), 200 @app.route('/api/real/cards/new', methods=['POST']) def new_card(): card = Card(request.data.get('component'), request.data.get('key', {}), request.data.get('data', {})) card.save() import time time.sleep(1) return make_response(jsonify(card.serialise())), 200 @app.route('/api/real/cards/save', methods=['POST']) def save_card(): id = str(request.data.get('id', '')) card = Card.get_all().filter(Card.id == id).one() card.data = request.data.get('data', {}) card.save() results = [] return make_response(jsonify({'list': results})), 200 @app.route('/api/real/cards/<id>', methods=['GET']) def get_card(id): cards = Card.get_all().filter(Card.id == id).all() results = [] for card in cards: results.append(card.serialise()) return make_response(jsonify({'list': results})), 200 @app.route('/api/real/favourites/clear', methods=['POST']) def clearfav(): userid = request.data.get('userId', '0') Favourite.delete_all(userid) return make_response(jsonify({'status': 'ok'})), 200 @app.route('/api/real/imports/countries', methods=['GET']) def import_countries(): with urllib.request.urlopen( "https://raw.githubusercontent.com/iancoleman/cia_world_factbook_api/master/data/2018-05-28_factbook.json" ) as url: data = json.loads(url.read().decode()) for country in data['countries']: country = Country(data['countries'][country]['data'], {}) country.save() #print (data['countries'][country]['data']['name']) return make_response(jsonify({'status': 'imported'})), 200 return app
def create_app(config_filename=None): """create app.""" app = FlaskAPI(__name__) per_page = int(os.getenv('BUKUSERVER_PER_PAGE', str(views.DEFAULT_PER_PAGE))) per_page = per_page if per_page > 0 else views.DEFAULT_PER_PAGE app.config['BUKUSERVER_PER_PAGE'] = per_page url_render_mode = os.getenv('BUKUSERVER_URL_RENDER_MODE', views.DEFAULT_URL_RENDER_MODE) if url_render_mode not in ('full', 'netloc'): url_render_mode = views.DEFAULT_URL_RENDER_MODE app.config['BUKUSERVER_URL_RENDER_MODE'] = url_render_mode app.config['SECRET_KEY'] = os.getenv('BUKUSERVER_SECRET_KEY') or os.urandom(24) bukudb = BukuDb() app.app_context().push() setattr(flask.g, 'bukudb', bukudb) @app.shell_context_processor def shell_context(): """Shell context definition.""" return {'app': app, 'bukudb': bukudb} app.jinja_env.filters['netloc'] = lambda x: urlparse(x).netloc # pylint: disable=no-member Bootstrap(app) admin = Admin( app, name='Buku Server', template_mode='bootstrap3', index_view=views.CustomAdminIndexView( template='bukuserver/home.html', url='/' ) ) # routing # api app.add_url_rule('/api/tags', 'get_tags', tag_list, methods=['GET']) app.add_url_rule('/api/tags/<tag>', 'update_tag', tag_detail, methods=['GET', 'PUT']) app.add_url_rule('/api/network_handle', 'networkk_handle', network_handle_detail, methods=['POST']) app.add_url_rule('/api/bookmarks', 'bookmarks', bookmarks, methods=['GET', 'POST', 'DELETE']) app.add_url_rule('/api/bookmarks/refresh', 'refresh_bookmarks', refresh_bookmarks, methods=['POST']) app.add_url_rule('/api/bookmarks/<id>', 'bookmark_api', bookmark_api, methods=['GET', 'PUT', 'DELETE']) app.add_url_rule('/api/bookmarks/<id>/refresh', 'refresh_bookmark', refresh_bookmark, methods=['POST']) app.add_url_rule('/api/bookmarks/<id>/tiny', 'get_tiny_url', get_tiny_url, methods=['GET']) app.add_url_rule('/api/bookmarks/<id>/long', 'get_long_url', get_long_url, methods=['GET']) app.add_url_rule( '/api/bookmarks/<starting_id>/<ending_id>', 'bookmark_range_operations', bookmark_range_operations, methods=['GET', 'PUT', 'DELETE']) app.add_url_rule('/api/bookmarks/search', 'search_bookmarks', search_bookmarks, methods=['GET', 'DELETE']) # non api admin.add_view(views.BookmarkModelView( bukudb, 'Bookmarks', page_size=per_page, url_render_mode=url_render_mode)) admin.add_view(views.TagModelView( bukudb, 'Tags', page_size=per_page)) admin.add_view(views.StatisticView('Statistic', endpoint='statistic')) return app
from flask_api import FlaskAPI from flask_sqlalchemy import SQLAlchemy app = FlaskAPI(__name__) app.config[ "SQLALCHEMY_DATABASE_URI"] = "mysql://*****:*****@localhost/toko_online" db = SQLAlchemy(app) from . import route
#from pymongo import MongoClient import pymongo from bson import Binary, Code from bson.json_util import dumps from bson.objectid import ObjectId import datetime import json import urllib import timeit app = FlaskAPI(__name__) CORS(app) client = pymongo.MongoClient('localhost', 27017) db = client['5303DB'] businessdb = db['yelp.business'] review = db['yelp.review'] userdb = db['yelp.user'] parser = reqparse.RequestParser() """==================================================================================""" """==================================================================================""" """=================================================================================="""
def create_app(config_name): from app.models import Item, Bid, User app = FlaskAPI(__name__, instance_relative_config=True) app.config.from_object(app_config[config_name]) app.config.from_pyfile('config.py') app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False db.init_app(app) @app.route('/') def index(): return 'Auction API' @app.route('/items/all', methods=['GET']) def items_all(): items = Item.get_all() results = [] for item in items: obj = { 'id': item.item_id, 'name': item.name, 'description': item.description, 'start_time': item.start_time, 'end_time': item.end_time, 'start_amount': item.start_amount } results.append(obj) response = jsonify(results) response.status_code = 200 return response @app.route('/items/upcoming', methods=['GET']) def items_upcoming(): current_time = str(datetime.now()) items = Item.query.filter(current_time < Item.start_time).all() results = [] for item in items: obj = { 'id': item.item_id, 'name': item.name, 'description': item.description, 'start_time': item.start_time, 'end_time': item.end_time, 'start_amount': item.start_amount } results.append(obj) response = jsonify(results) response.status_code = 200 return response @app.route('/items/previous', methods=['GET']) def items_previous(): current_time = str(datetime.now()) items = Item.query.filter(current_time > Item.end_time).all() results = [] for item in items: obj = { 'id': item.item_id, 'name': item.name, 'description': item.description, 'start_time': item.start_time, 'end_time': item.end_time, 'start_amount': item.start_amount } results.append(obj) response = jsonify(results) response.status_code = 200 return response @app.route('/item/<int:id>', methods=['GET']) def item_details(id): result = [] current_time = str(datetime.now()) #For previous auctions item = Item.query.filter( and_(Item.item_id == id, current_time > Item.end_time)).first() if item is not None: obj = { 'id': item.item_id, 'name': item.name, 'buyer': '<winner_name>', 'amount': '<highest_bid>', 'status': 'auction complete' } #For ongoing auctions else: item = Item.query.filter( and_(Item.item_id == id, current_time > Item.start_time, current_time < Item.end_time)).first() if item is not None: obj = { 'id': item.item_id, 'name': item.name, 'highest_bid': '<highest_bid>', 'status': 'auction ongoing' } else: obj = {'status': 'auction has not been started yet'} result.append(obj) response = jsonify(result) response.status_code = 200 return response @app.route('/bids/user/<int:id>', methods=['GET']) def bids_by_user(id): result = [] user = User.query.get(id) #If user_id doesn't exist if not user: obj = {'message': 'User not registered'} result.append(obj) response = jsonify(result) response.status_code = 404 return response bids = Bid.query.filter_by(placed_by=user.user_id).all() #If no bid by current user if not bids: obj = {'message': 'No bids placed by this User'} result.append(obj) response = jsonify(result) response.status_code = 404 return response #Display bids by user and item names for bid in bids: item = Item.query.get(bid.bid_on_item) obj = { 'bid_id': bid.bid_id, 'bid_price': bid.bid_amount, 'item_name': item.name } result.append(obj) response = jsonify(result) response.status_code = 200 return response @app.route('/item/bid', methods=['POST']) def bid_on_item(): """Check whether user is logged in or not""" auth_header = request.headers.get('Authorization') access_token = auth_header.split(" ")[1] if access_token: #Attempt to decode the token and get the user_id user_id = User.decode_token(access_token) if not isinstance(user_id, str): #User is authenticated if request.method == 'POST': bid_amount = float(request.data.get('bid_amount', '')) bid_on_item = int(request.data.get('bid_on_item', '')) if bid_amount and bid_on_item: placed_bid = Bid(placed_by=user_id, bid_amount=bid_amount, bid_on_item=bid_on_item) placed_bid.save() item = Item.query.filter_by( item_id=placed_bid.bid_on_item).first() response = jsonify({ 'status': 'bid successfully placed', 'bid_id': placed_bid.bid_id, 'bid_amount': placed_bid.bid_amount, 'placed_on': item.name, }) return make_response(response), 201 else: response = jsonify({ 'status': 'send a POST request with bid_amount and bid_on_item as form data to place bid' }) return make_response(response), 200 else: #User is not legit message = user_id response = {'message': message} return make_response(jsonify(response)), 401 #Register auth blueprint from .auth import auth_blueprint app.register_blueprint(auth_blueprint) return app
from flask_api import FlaskAPI import random app = FlaskAPI(__name__) kelimeler =[] with open('static/kelimeler.txt',encoding='utf-8') as fd: for kelime in fd: kelimeler.append(kelime.strip()) def get_random_kelime(say): if say is None: n = 1 else: n = say if n<1: n = 1 elif n>10: n = 10 sayilar = [] for m in range(n): sayilar.append(random.randrange(len(kelimeler))) kelimelist=[] for m in range(n): kelimelist.append(kelimeler[sayilar[m]]) return kelimelist def kelime_yolla(): return { 'sayı': 0, 'text': get_random_kelime(1)[0] }
def _run(): app = FlaskAPI(__name__) app.url_map.converters['regex'] = RegexConverter app.debug = True app.register_blueprint(api, url_prefix=DEFAULT_PREFIX) app.run("0.0.0.0")
# coding: utf8 from __future__ import unicode_literals from flask import abort, make_response, request from flask_api.decorators import set_renderers from flask_api import exceptions, renderers, status, FlaskAPI import json import unittest app = FlaskAPI(__name__) app.config['TESTING'] = True class JSONVersion1(renderers.JSONRenderer): media_type = 'application/json; api-version="1.0"' class JSONVersion2(renderers.JSONRenderer): media_type = 'application/json; api-version="2.0"' @app.route('/set_status_and_headers/') def set_status_and_headers(): headers = {'Location': 'http://example.com/456'} return {'example': 'content'}, status.HTTP_201_CREATED, headers @app.route('/set_headers/') def set_headers(): headers = {'Location': 'http://example.com/456'} return {'example': 'content'}, headers
VERSION = (0, 2, 0) version = ".".join(map(str, VERSION)) from . import focus, lights, telescope from .utils import RegexConverter, BrowsableAPITitleRenderer MODULES = ( lights, focus, telescope, ) app = FlaskAPI(__name__) app.debug = False app.url_map.converters['regex'] = RegexConverter for module in MODULES: app.register_blueprint(module.api, url_prefix=module.DEFAULT_PREFIX) @set_renderers(BrowsableAPITitleRenderer, JSONRenderer) def dagor_api(): """ API root version: {VERSION} ### Hyperlinks
from flask_api import FlaskAPI app = FlaskAPI(__name__) @app.route('/example/') def example(): return {'hello': 'world'} if __name__ == "__main__": app.run(debug=True)
from flask_api import FlaskAPI from flask import request import json app = FlaskAPI(__name__) @app.route('/get_word_count/', methods=['GET', 'POST']) def get_word_count(): print(request) if request.method == 'GET': return 'Invalid Request' if request.method == 'POST': data = request.get_json() output = {} if not data: output = {'message': 'No Text Received'} return output for key in data.keys(): text = data[key] text = text.split(' ') output[key] = {} for word in text: if word not in output[key]: output[key][word] = 1 else: output[key][word] += 1 return output if __name__ == '__main__':
# coding: utf8 from __future__ import unicode_literals from flask import abort, make_response, request from flask_api.decorators import set_renderers from flask_api import exceptions, renderers, status, FlaskAPI import json import unittest app = FlaskAPI(__name__) app.config["TESTING"] = True class JSONVersion1(renderers.JSONRenderer): media_type = 'application/json; api-version="1.0"' class JSONVersion2(renderers.JSONRenderer): media_type = 'application/json; api-version="2.0"' @app.route("/set_status_and_headers/") def set_status_and_headers(): headers = {"Location": "http://example.com/456"} return {"example": "content"}, status.HTTP_201_CREATED, headers @app.route("/set_headers/") def set_headers(): headers = {"Location": "http://example.com/456"} return {"example": "content"}, headers
from flask_api import FlaskAPI from flask_sqlalchemy import SQLAlchemy app = FlaskAPI(__name__) # SQLALCHEMY_DATABASE_URI = 'sqlite:///dev.db' # RUN_CONFIG = { # 'host': '127.0.0.1', # 'port': 5000, # 'debug': True, # } try: from config import * except Exception as e: print('not found config file') finally: app.config['SQLALCHEMY_DATABASE_URI'] = SQLALCHEMY_DATABASE_URI app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True DB = SQLAlchemy(app) # SESSION = SignallingSession(DB) # session = SESSION() app.config['DEFAULT_RENDERERS'] = [ 'flask.ext.api.renderers.JSONRenderer', 'flask.ext.api.renderers.BrowsableAPIRenderer', ]
def create_app(config_name): from app.models import Users, Location, Restaurant, Category app = FlaskAPI(__name__, instance_relative_config=True) CORS(app) app.config.from_object(app_config[config_name]) app.config.from_pyfile('config.py') app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False db.init_app(app) def token_required(f): @wraps(f) def decorated(*args, **kwargs): if 'x-access-token' in request.headers: token = request.headers['x-access-token'] if not token: return jsonify({'message': 'Access Token not available', 'status': False}) try: data = jwt.decode(token, os.getenv('SECRET')) current_user = Users.query.filter_by(email=data['email']).first() except: return jsonify({'message': 'Invalid token', 'status': False}) return f(current_user, *args, **kwargs) return decorated @app.route('/auth/register', methods=['POST']) def register(): data = request.data.get('email') print(data) email = request.data.get('email') name = request.data.get('name') password = request.data.get('password') if email.isspace() or name.isspace() or password.isspace(): response = jsonify({ 'message': 'all fields are required', 'status': False }) response.status_code = 401 return response else: hashed_password = generate_password_hash(password, method='sha256') new_user = Users(email=email, name=name, role='customer', password=hashed_password) new_user.save() response = jsonify({ 'id': new_user.id, 'email': new_user.email, 'name': new_user.name, 'role': new_user.role }) response.status_code = 201 return response @app.route('/auth/login', methods=['POST']) def login(): email = str(request.data.get('email')) password = str(request.data.get('password')) user = Users.query.filter_by(email=email).first() if user: if check_password_hash(user.password, password): token = jwt.encode({'email': user.email, 'exp': datetime.datetime.utcnow() + datetime.timedelta(days=90)}, os.getenv('SECRET')) response = jsonify({ 'message': 'successfully logged in', 'status': True, 'token': token.decode('UTF-8') }) response.status_code = 200 return response else: response = jsonify({ 'message': 'password is incorrect', 'status': False }) response.status_code = 401 return response else: response = jsonify({ 'message': 'user not found', 'status': False }) response.status_code = 401 return response @app.route('/users', methods=['GET']) def users(): users = Users.query.all() results = [] for user in users: obj = { 'id': user.id, 'name': user.name, 'email': user.email, 'role': user.role, 'date_created': user.date_created, 'date_modified': user.date_modified } results.append(obj) response = jsonify(results) response.status_code = 200 return response @app.route('/users/<int:id>', methods=['GET']) def get_user(id): user = Users.query.filter_by(id=id).first() if not user: abort(404) response = jsonify({ 'id': user.id, 'name': user.name, 'email':user.email, 'role': user.role, 'date_created': user.date_created, 'date_modified': user.date_modified }) response.status_code = 200 return response @app.route('/users/<int:id>', methods=['PUT']) def edit_user(id): user = Users.query.filter_by(id=id).first() if not user: abort(404) user.name = str(request.data.get('name')) user.email = str(request.data.get('email')) user.role = str(request.data.get('role')) user.save() response = jsonify({ 'id': user.id, 'name': str(request.data.get('name')), 'msg': 'Update successful' }) response.status_code = 200 return response @app.route('/location', methods=['POST']) @token_required def location(current_user): county = str(request.data.get('county')) location = str(request.data.get('location')) user_location = Location(current_user.id, county, location) user_location.save() response = jsonify({ 'message': 'Successfully added user location', 'status': True }) response.status_code = 201 return response @app.route('/restaurant', methods=['POST']) @token_required def restaurant(current_user): if current_user.role != 'admin': response = jsonify({ 'message': 'Unauthorized command', 'status': False }) response.status_code = 401 return response restaurant_name = str(request.data.get('restaurant_name')) restaurant_email = str(request.data.get('restaurant_email')) restaurant_county = str(request.data.get('restaurant_county')) restaurant_location = str(request.data.get('restaurant_location')) restaurant_minorder = str(request.data.get('restaurant_minorder')) restaurant_phone = str(request.data.get('restaurant_phone')) restaurant_mobile = str(request.data.get('restaurant_mobile')) restaurant_about = str(request.data.get('restaurant_about')) restaurant_delivery = str(request.data.get('restaurant_delivery')) if restaurant_name.isspace() or restaurant_email.isspace() or restaurant_county.isspace() or restaurant_location.isspace(): response = jsonify({ 'message': 'All fields are required', 'status': False }) return response elif restaurant_minorder.isspace() or restaurant_phone.isspace() or restaurant_mobile.isspace(): reponse = jsonify({ 'message': 'All fields are required', 'status': False }) return response elif restaurant_about.isspace() or restaurant_delivery.isspace(): response = jsonify({ 'message': 'All fields are required', 'status': False }) return response else: new_restaurant = Restaurant(restaurant_name, restaurant_email, restaurant_county, restaurant_location, restaurant_minorder, restaurant_phone, restaurant_mobile, restaurant_about, restaurant_delivery) new_restaurant.save() response = jsonify({ 'Message': 'Successfully added new Restaurant', 'Status': True }) response.status_code = 201 return response @app.route('/restaurant/category', methods=['POST']) @token_required def add_category(current_user): if current_user.role != 'admin': response = jsonify({ 'message': 'You don\'t have the right permission', 'status': False }) response.status_code = 401 return response new_category = Category(request.data.get('restaurant_id'), request.data.get('category_name')) new_category.save() response = jsonify({ 'message': 'Successfully added new category', 'status': True }) response.status_code = 201 return response @app.route('/restaurant/categories/<int:id>', methods=['GET']) @token_required def get_categories(current_user, id): """Gets the list of categories by restaurant_id.""" categories = [] cats = Category.query.filter_by(restaurant_id=id).all() for cat in cats: category = { 'id': cat.id, 'name': cat.name, 'restaurant': cat.restaurant_id } categories.append(category) response = jsonify({ 'status': True, 'categories': categories }) response.status_code = 200 return response @app.route('/restaurant/category/<int:id>', methods=['PUT']) @token_required def edit_category(current_user, id): """Edits the restaurants menu category.""" restaurant_category = Category.query.filter_by(id=id).first() if not restaurant_category: return jsonify({'message': 'Category not found', 'status': False}) restaurant_category.name = str(request.data.get('category_name')) db.session.commit() @app.route('/restaurant/category/<int:id>', methods=['DELETE']) @token_required def delete_category(current_user, id): """Deletes the category by id.""" restaurant_category = Category.query.filter_by(id=id).first() if not restaurant_category: return jsonify({'message': 'category not found', 'status': False}) db.session.delete(restaurant_category) db.session.commit() return jsonify({'message': 'Category has been successfully deleted', 'status': True}) return app
def create_app(config_name): from app.models import Happycal app = FlaskAPI(__name__, instance_relative_config=True) app.config.from_object(app_config[config_name]) app.config.from_pyfile('config.py') db.init_app(app) @app.route('/happycals/', methods=['POST', 'GET']) def happycals(): if request.method == "POST": name = str(request.data.get('name','')) if name: happycal = Happycal(name=name) happycal.save() response = jsonify({ 'id':happycal.id, 'name':happycal.name, 'date_created':happycal.date_created, 'date_modified':happycal.date_modified }) response.status_code = 201 return response else: #GET happycals = Happycal.get_all() results = [] for happycal in happycals : obj = { 'id':happycal.id, 'name':happycal.name, 'date_created':happycal.date_created, 'date_modified':happycal.date_modified } results.append(obj) response = jsonify(results) response.status_code = 200 return response @app.route('/happycals/<int:id>', methods=['GET','PUT','DELETE']) def happycal_manipulation(id, **kwargs): #retrieve a bucketlist using its ID happycal = Happycal.query.filter_by(id=id).first() if not happycal: #Raise a 404 not found status code abort(404) if request.method == 'DELETE': happycal.delete() return {"message":"happycal {} deleted successfully".format(happycal.id)},200 elif request.method =='PUT': name = str(request.data.get('name','')) happycal.name = name happycal.save() response = jsonify({ 'id':happycal.id, 'name':happycal.name, 'date_created':happycal.date_created, 'date_modified':happycal.date_modified }) response.status_code = 200 return response else: #GET response = jsonify({ 'id':happycal.id, 'name':happycal.name, 'date_created':happycal.date_created, 'date_modified':happycal.date_modified }) response.status_code=200 return response return app
from flask import request, url_for, jsonify from flask_api import FlaskAPI, status, exceptions from flask_cors import CORS, cross_origin from bs4 import BeautifulSoup import PyPDF2 from summarize import summarize import requests import pdfx app = FlaskAPI(__name__) CORS(app) ###################### FLASK APIs ############################################### class InvalidUsage(Exception): def __init__(self, message): super(InvalidUsage, self).__init__() self.message = message @app.route("/sampleGetRequest", methods=['GET']) def get_request(): if request.method == 'GET': sample_data = request.args.get('data') modified_data = sample_data + " modify kar diya." resp = {"modified_data": modified_data}
headers['X-RateLimit-Reset'] = '0' headers['X-Poll-Interval'] = '0' headers['X-Frame-Options'] = 'deny' headers['X-Content-Type-Options'] = 'nosniff' headers['X-Xss-Protection'] = '1; mode=block' headers['Content-Security-Policy'] = "default-src 'self'" headers['access-control-allow-origin'] = '*' headers['strict-transport-security'] = 'max-age=31536000; includeSubdomains; preload' headers['access-control-expose-headers'] = 'X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset, X-Poll-Interval' return output , code , headers app = FlaskAPI(__name__) app.config['DEFAULT_RENDERERS'] = [ 'flask_api.renderers.JSONRenderer', 'flask_api.renderers.BrowsableAPIRenderer', ] @app.route("/") def app_route_root(): root = request.host_url.rstrip('/') return postprocess( { 'url' : root + url_for( 'app_route_root' ) , 'links' : { 'network' : root + url_for( 'app_route_network' ) , 'control' : root + url_for( 'app_route_control' ) , } ,