import json import logging from logging.handlers import RotatingFileHandler import os import sys import traceback import flask import es_query app_dir = os.path.dirname(__file__) app = flask.Flask(__name__, template_folder=app_dir) if not os.path.exists('log'): os.mkdir('log') handler = RotatingFileHandler('log/explorer.log', maxBytes=10000, backupCount=1) handler.setLevel(logging.ERROR) app.logger.addHandler(handler) @app.route('/') def explorer(): return flask.render_template('explorer.html') @app.route('/res/<path:path>') def send_res(path): return flask.send_from_directory(os.path.join(app_dir, 'res'), path)
import os import subprocess import threading import time import uuid from collections import OrderedDict # params HOST = os.environ['API_POWER_HOST'] PORT = int(os.environ['API_POWER_PORT']) DEBUG = True POWEROFF_COMMAND = "python3 -u poweroff.py -j '{}'" POWERON_COMMAND = "python3 -u poweron.py -j '{}'" # app and state app = flask.Flask('API POWER') tasks = OrderedDict() @app.route('/api/public/power/v1/tasks/') def handle_tasks(): # clean up tasks now = int(time.time()) del_uuids = [] for task in tasks.values(): if now - task['timestamp_start'] > 3 * 24 * 60 * 60: del_uuids.append(task['uuid']) for del_uuid in del_uuids: del tasks[del_uuid] # create list
#!/usr/bin/env python2 import flask import pyautogui # Creating application APP = flask.Flask(__name__) @APP.route('/') def index(): return flask.render_template('index.html') @APP.route('/running', methods=['POST', 'GET']) def run(): print("I am running") pyautogui.moveTo(645, 0) result = "running" return flask.render_template("index.html", result=result) if __name__ == "__main__": APP.debug = True APP.run()
from model import config import torch import flask import time from flask import Flask from flask import request,render_template from model.model import BERTBaseUncased import functools import torch.nn as nn import joblib import transformers import torch.nn as nn app = flask.Flask(__name__,template_folder='tamplates') MODEL = None DEVICE = "cuda" PREDICTION_DICT = dict() def sentence_prediction(sentence): tokenizer = config.TOKENIZER max_len = config.MAX_LEN review = str(sentence) review = " ".join(review.split()) inputs = tokenizer.encode_plus( review, None, add_special_tokens=True, max_length=max_len ) ids = inputs["input_ids"] mask = inputs["attention_mask"] token_type_ids = inputs["token_type_ids"] padding_length = max_len - len(ids)
import datetime, flask, json, pickle app = flask.Flask('first_app') try: with open('post_data.pickle', 'rb') as fin: POST_DATA = pickle.load(fin) except: POST_DATA = [] def write(): with open('post_data.pickle', 'wb') as fout: pickle.dump(POST_DATA, fout) INDEX_HTML = ''' <ul> {} </ul> ''' @app.route('/') def index(): lis = '' for li in POST_DATA: timestamp = li['timestamp'] text = li['text'] lis += f'<li> {timestamp} - {text}</li>\n' content = INDEX_HTML.format(lis)
import os import uuid import flask import logging import pkgutil import multiprocessing from pywren_ibm_cloud.version import __version__ from pywren_ibm_cloud.function import function_invoker from pywren_ibm_cloud.config import DOCKER_FOLDER log_file = os.path.join(DOCKER_FOLDER, 'proxy.log') logging.basicConfig(filename=log_file, level=logging.DEBUG) logger = logging.getLogger('__main__') proxy = flask.Flask(__name__) @proxy.route('/', methods=['POST']) def run(): def error(): response = flask.jsonify({ 'error': 'The action did not receive a dictionary as an argument.' }) response.status_code = 404 return complete(response) sys.stdout = open(log_file, 'w') message = flask.request.get_json(force=True, silent=True)
import flask from flask import request, jsonify, send_from_directory from flask_cors import CORS, cross_origin from flask_sqlalchemy import SQLAlchemy import json import copy import gzip from sys import getsizeof import os import webbrowser from threading import Timer import base64 import requests import datetime # from aws_config.config import S3_KEY, S3_SECRET, S3_BUCKET app = flask.Flask(__name__, static_folder='react/build/static') # database app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///User.sqlite3' # app.config['SQLALCHEMY_DATABASE_URI'] = 'postgres://*****:*****@ec2-52-44-139-108.compute-1.amazonaws.com:5432/d3vfi3i8hpdr55' db = SQLAlchemy(app) # database class Document(db.Model): __tablename__ = 'document' _id = db.Column(db.Integer, primary_key=True, autoincrement=True) document_hash_key = db.Column(db.String(100), unique=True, nullable=False) document_name = db.Column(db.String(100), nullable=True) user_id = db.Column(db.String(100), db.ForeignKey('user.hash_key'))
def test_delayed_configuration(self): app = flask.Flask(__name__) oauth2 = FlaskOAuth2() oauth2.init_app(app, client_id='id', client_secret='secret') self.assertEqual(oauth2.app, app)
def test_explicit_scopes(self): oauth2 = FlaskOAuth2(flask.Flask(__name__), scopes=['1', '2'], client_id='id', client_secret='secret') self.assertEqual(oauth2.scopes, ['1', '2'])
def factory(): app = flask.Flask(__name__) app.config.from_object(config) # Register routes @app.errorhandler(Exception) def handle_exception(e): """Custom error handling""" app.logger.info(traceback.format_exc()) if isinstance(e, BaseError): return flask.jsonify({"message": e.message}), e.status else: # For debugging purpose can log the original error (e) return flask.jsonify({"message": "Unhandled error occured"}), 500 @app.route("/data", methods=["GET"]) @auth() def get_data(): # Get list user response = requests.get(app.config.get("DATA_FETCH_URL"), timeout=30) # Make sure server responded OK if response.status_code == 200: data_dict = response.json() # Processing dictionary, inplace memory processing no need return update_data(data_dict) return flask.jsonify(data_dict) else: raise DataSourceError @app.route("/summary", methods=["GET"]) @auth(admin=True) def get_aggregate(): # Get list user response = requests.get(app.config.get("DATA_FETCH_URL"), timeout=30) # Make sure server responded OK if response.status_code == 200: df = pandas.read_json(response.content) # cleanup data, make sure price data are in correct format df_clean = df[df['price'].apply(lambda x: str(x).isdigit())] # cast price to integer data type df_fix = df_clean.astype({"price": "int64"}) # aggregate data by group data = df_fix.groupby([ pandas.Grouper(key='timestamp', freq='W-MON'), "area_provinsi" ])['price']\ .agg([("Min", "min"), ("Max", "max"), ("Mean", "mean"), ("Median", "median")])\ .reset_index()\ .sort_values("area_provinsi") return flask.jsonify(data.to_dict("records")) else: raise DataSourceError @app.route("/me", methods=["GET"]) def check_token(): claims = validate_token() return flask.jsonify(claims) @app.route("/", methods=["GET"]) def root(): return "Hello there" return app
import flask, os, sys, time from flask import request from flask import render_template interface_path = os.path.dirname(__file__) sys.path.insert(0, interface_path) #将当前文件的父目录加入临时系统变量 print(__name__) server = flask.Flask(__name__, static_folder='res') server = flask.Flask(__name__, static_folder='web') lables_dir = "resjson/" lables = os.listdir(lables_dir) print(lables) @server.route('/<int:id>', methods=['get']) def index(id): if (id >= len(lables) or id < 0): return "do not exist" json_name = lables[id] with open(lables_dir + json_name) as json_file: json = json_file.read() picture_name = json_name.split(".")[0] + '.png' rect_picutre = 'web/' + picture_name return render_template('app_dataset.html', json=json, rect_picutre=rect_picutre, next=id + 1, prev=id - 1,
from gevent.pywsgi import WSGIServer import flask proxy = flask.Flask('__main__') proxy.debug = False name = None @proxy.route('/hello', methods=['GET']) def hello(): return ("\n\nHello %s, from my first FaaS VNF!\n\n" % name) def main(args): global name name = args.get('name', 'stranger') port = int('5000') server = WSGIServer(('', port), proxy, log=None) server.serve_forever()
import flask cv = flask.Flask(__name__) @cv.route('/name') def name(): return '<h1>Goldie Perlmann</h1>' @cv.route('/pic') def pic(): return 'picture' @cv.route('/hobbies') def hobbies(): return '<p></p>' @cv.route('/skills') def skills(): return '<p></p>' if __name__ == "__main__": cv.run()
def get_app(config): """ :param config: the configuration dict :return: A new app """ # First, disable debug. It will be enabled in the configuration, later. config = _put_configuration_defaults(config) mongo_client = MongoClient( host=config.get('mongo_opt', {}).get('host', 'localhost')) database = mongo_client[config.get('mongo_opt', {}).get('database', 'INGInious')] gridfs = GridFS(database) # Init database if needed db_version = database.db_version.find_one({}) if db_version is None: database.submissions.ensure_index([("username", pymongo.ASCENDING)]) database.submissions.ensure_index([("courseid", pymongo.ASCENDING)]) database.submissions.ensure_index([("courseid", pymongo.ASCENDING), ("taskid", pymongo.ASCENDING)]) database.submissions.ensure_index([("submitted_on", pymongo.DESCENDING) ]) # sort speed database.user_tasks.ensure_index([("username", pymongo.ASCENDING), ("courseid", pymongo.ASCENDING), ("taskid", pymongo.ASCENDING)], unique=True) database.user_tasks.ensure_index([("username", pymongo.ASCENDING), ("courseid", pymongo.ASCENDING)]) database.user_tasks.ensure_index([("courseid", pymongo.ASCENDING), ("taskid", pymongo.ASCENDING)]) database.user_tasks.ensure_index([("courseid", pymongo.ASCENDING)]) database.user_tasks.ensure_index([("username", pymongo.ASCENDING)]) flask_app = flask.Flask(__name__) flask_app.config.from_mapping(**config) flask_app.session_interface = MongoDBSessionInterface( mongo_client, config.get('mongo_opt', {}).get('database', 'INGInious'), "sessions", config.get('SESSION_USE_SIGNER', False), True # config.get('SESSION_PERMANENT', True) ) # Init gettext available_translations = { "fr": "Français", "es": "Español", "pt": "Português", "el": "ελληνικά", "vi": "Tiếng Việt", "nl": "Nederlands", "de": "Deutsch" } available_languages = {"en": "English"} available_languages.update(available_translations) l10n_manager = L10nManager() l10n_manager.translations["en"] = gettext.NullTranslations( ) # English does not need translation ;-) for lang in available_translations.keys(): l10n_manager.translations[lang] = gettext.translation( 'messages', get_root_path() + '/frontend/i18n', [lang]) builtins.__dict__['_'] = l10n_manager.gettext if config.get("maintenance", False): template_helper = TemplateHelper(PluginManager(), None, config.get('use_minified_js', True)) template_helper.add_to_template_globals("get_homepath", get_homepath) template_helper.add_to_template_globals("pkg_version", __version__) template_helper.add_to_template_globals("available_languages", available_languages) template_helper.add_to_template_globals("_", _) flask_app.template_helper = template_helper init_flask_maintenance_mapping(flask_app) return flask_app.wsgi_app, lambda: None default_allowed_file_extensions = config['allowed_file_extensions'] default_max_file_size = config['max_file_size'] zmq_context, __ = start_asyncio_and_zmq(config.get('debug_asyncio', False)) # Init the different parts of the app plugin_manager = PluginManager() # Add the "agent types" inside the frontend, to allow loading tasks and managing envs register_base_env_types() # Create the FS provider if "fs" in config: fs_provider = filesystem_from_config_dict(config["fs"]) else: task_directory = config["tasks_directory"] fs_provider = LocalFSProvider(task_directory) default_task_dispensers = { task_dispenser.get_id(): task_dispenser for task_dispenser in [TableOfContents, CombinatoryTest] } default_problem_types = { problem_type.get_type(): problem_type for problem_type in [ DisplayableCodeProblem, DisplayableCodeSingleLineProblem, DisplayableFileProblem, DisplayableMultipleChoiceProblem, DisplayableMatchProblem ] } course_factory, task_factory = create_factories(fs_provider, default_task_dispensers, default_problem_types, plugin_manager) user_manager = UserManager(database, config.get('superadmins', [])) update_pending_jobs(database) client = create_arch(config, fs_provider, zmq_context, course_factory) lti_outcome_manager = LTIOutcomeManager(database, user_manager, course_factory) submission_manager = WebAppSubmissionManager(client, user_manager, database, gridfs, plugin_manager, lti_outcome_manager) template_helper = TemplateHelper(plugin_manager, user_manager, config.get('use_minified_js', True)) register_utils(database, user_manager, template_helper) is_tos_defined = config.get("privacy_page", "") and config.get( "terms_page", "") # Init web mail mail.init_app(flask_app) # Add some helpers for the templates template_helper.add_to_template_globals("_", _) template_helper.add_to_template_globals("str", str) template_helper.add_to_template_globals("available_languages", available_languages) template_helper.add_to_template_globals("get_homepath", get_homepath) template_helper.add_to_template_globals("pkg_version", __version__) template_helper.add_to_template_globals( "allow_registration", config.get("allow_registration", True)) template_helper.add_to_template_globals("sentry_io_url", config.get("sentry_io_url")) template_helper.add_to_template_globals("user_manager", user_manager) template_helper.add_to_template_globals("default_allowed_file_extensions", default_allowed_file_extensions) template_helper.add_to_template_globals("default_max_file_size", default_max_file_size) template_helper.add_to_template_globals("is_tos_defined", is_tos_defined) template_helper.add_other( "course_admin_menu", lambda course, current: course_admin_utils.get_menu( course, current, template_helper.render, plugin_manager, user_manager)) template_helper.add_other( "preferences_menu", lambda current: preferences_utils.get_menu( config.get("allow_deletion", True), current, template_helper. render, plugin_manager, user_manager)) # Not found page def flask_not_found(e): return template_helper.render("notfound.html", message=e.description), 404 flask_app.register_error_handler(404, flask_not_found) # Forbidden page def flask_forbidden(e): return template_helper.render("forbidden.html", message=e.description), 403 flask_app.register_error_handler(403, flask_forbidden) # Enable debug mode if needed web_debug = config.get('web_debug', False) flask_app.debug = web_debug oauthlib.set_debug(web_debug) def flask_internalerror(e): return template_helper.render("internalerror.html", message=e.description), 500 flask_app.register_error_handler(InternalServerError, flask_internalerror) # Insert the needed singletons into the application, to allow pages to call them flask_app.get_homepath = get_homepath flask_app.plugin_manager = plugin_manager flask_app.course_factory = course_factory flask_app.task_factory = task_factory flask_app.submission_manager = submission_manager flask_app.user_manager = user_manager flask_app.l10n_manager = l10n_manager flask_app.template_helper = template_helper flask_app.database = database flask_app.gridfs = gridfs flask_app.client = client flask_app.default_allowed_file_extensions = default_allowed_file_extensions flask_app.default_max_file_size = default_max_file_size flask_app.backup_dir = config.get("backup_directory", './backup') flask_app.webterm_link = config.get("webterm", None) flask_app.lti_outcome_manager = lti_outcome_manager flask_app.allow_registration = config.get("allow_registration", True) flask_app.allow_deletion = config.get("allow_deletion", True) flask_app.available_languages = available_languages flask_app.welcome_page = config.get("welcome_page", None) flask_app.terms_page = config.get("terms_page", None) flask_app.privacy_page = config.get("privacy_page", None) flask_app.static_directory = config.get("static_directory", "./static") flask_app.webdav_host = config.get("webdav_host", None) # Init the mapping of the app init_flask_mapping(flask_app) # Loads plugins plugin_manager.load(client, flask_app, course_factory, task_factory, database, user_manager, submission_manager, config.get("plugins", [])) # Start the inginious.backend client.start() return flask_app.wsgi_app, lambda: _close_app(mongo_client, client)
import dash import dash_core_components as dcc import dash_html_components as html from dash.dependencies import Input, Output, State from root_locus import * import flask import os from random import randint server = flask.Flask(__name__) server.secret_key = os.environ.get('secret_key', str(randint(0, 1000000))) external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css'] app = dash.Dash(__name__, server=server, external_stylesheets=external_stylesheets) app.layout = html.Div(children=[ html.H1(children='Root Locus'), html.Div('''GH transfer function is equal to Numerator / Denominator'''), html.Div( ["Numerator: ", dcc.Input(id='num', value='x^2 + 4*x', type='text')]), html.Div([ "Denominator: ", dcc.Input(id='denom', value='x^4 + 2*x^3 + 4*x**2', type='text') ]), html.Div('''Set window boundaries to show the plot'''), html.Div([ "X axis bounds\n", "Lowest x:",
def test_no_configuration(self): self.assertRaises(ValueError, FlaskOAuth2, flask.Flask(__name__))
import flask as fl from dora.server.response import returns_json from dora.active_sampling import GaussianProcess as GPsampler import numpy as np import logging app = fl.Flask(__name__) log = logging.getLogger('werkzeug') log.setLevel(logging.ERROR) @app.route('/samplers', methods=['POST']) @returns_json def initialise_sampler(): """ Initialise the Sampler Model This expects a dict containing: lower : a list of the lower bounds of the region of interest upper : a list of the upper bounds of the region of interest Optional dict entries for the model initialisation: kerneldef : Kernel function definition. See the 'gp' module. n_train : int Number of training samples required before sampler can be trained acq_name : str A string specifying the type of acquisition function used explore_priority : float, optional The priority of exploration against exploitation """ initDict = fl.request.json
#!/usr/bin/env python # -*- coding:utf-8 -*- import flask import PlayCards from flask_cors import CORS from flask import jsonify server = flask.Flask(__name__) # __name__代表当前的python文件。把当前的python文件当做一个服务启动 CORS(server, resources=r'/*') @server.route('/getcards', methods=['post']) # 第一个参数就是路径,第二个参数支持的请求方式,不写的话默认是get def getcards(): card = flask.request.values.get('card') output = PlayCards.PostCards(card) str_Qiandun = "" str_Zhongdun = "" str_Houdun = "" for item in output[0]: str_Qiandun += item[1] num = item[0] if (num == 11): num = 'J' elif (num == 12): num = 'Q' elif (num == 13): num = 'K' elif (num == 14): num = 'A' else:
import argparse import copy import datetime import flask as f from flask import views import pymongo app = f.Flask(__name__) _mongourl = None LOG_ALL = 'all' LOG_UNKNOWN = 'unknown' class Singleton(object): def __new__(cls, *args, **kwargs): if not hasattr(cls, '_instance'): cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs) return cls._instance @property def initialized(self): return hasattr(self, '_initialized') @staticmethod def check_initialized(func): def wrapper(self, *args, **kwargs): if not self.initialized: retval = func(self, *args, **kwargs)
def run(): app = flask.Flask(__name__) @app.route("/") def welcome(): return "{status: \"OK\", error: 0, message: \"Welcome\"}" @app.route("/monitor", methods=["GET"]) def monitor(): client = pymongo.MongoClient("127.0.0.1", 27017) db = client["media_monitor"] result = db["sensor_raw"].find({}).sort([{"time", pymongo.DESCENDING}]).limit(1) result_array = [i for i in result] if len(result_array) == 0: return { "status": "FAIL", "error": 1, "message": "DB is empty" } else: del result_array[0]["_id"] return { "status": "OK", "error": 0, "data": result_array[0] } @app.route("/monitor/after/<time>", methods=["GET"]) def monitor_after(time): client = pymongo.MongoClient("127.0.0.1", 27017) db = client["media_monitor"] result = db["sensor_raw"].find({"time": {"$gt": float(time)}}) result_array = [i for i in result] if len(result_array) == 0: return { "status": "FAIL", "error": 1, "message": "DB is empty" } else: for i in result_array: del i["_id"] return { "status": "OK", "error": 0, "data": result_array } @app.route("/monitor/limit/<int:cnt>", methods=["GET"]) def monitor_limit(cnt): client = pymongo.MongoClient("127.0.0.1", 27017) db = client["media_monitor"] result = db["sensor_raw"].find({}).sort([{"time", pymongo.DESCENDING}]).limit(cnt) result_array = [i for i in result] if len(result_array) == 0: return { "status": "FAIL", "error": 1, "message": "DB is empty" } else: for i in result_array: del i["_id"] return { "status": "OK", "error": 0, "data": result_array } app.run(host="0.0.0.0", port=8080)
def get_top_counties_div(n=50): sorted_by_last_day = df.sort_values(last_column, ascending=False).head(n) return [ dbc.Card([ dbc.CardBody([ html.H6(f"{row['Admin2']}, {row['Province_State']}"), html.P(f"{row[last_column]:,} total cases"), ]) ]) for index, row in sorted_by_last_day.iterrows() ] # ----------------------- Dash app ------------------------------------ server = flask.Flask(__name__, template_folder="templates") @server.route('/') def index(): return flask.render_template('index.html') app = dash.Dash(__name__, server=server, routes_pathname_prefix='/dash/', external_stylesheets=[dbc.themes.BOOTSTRAP]) app.layout = dbc.Container( [ dbc.Row([
def test_json_key_sorting(self): app = flask.Flask(__name__) app.testing = True assert app.config['JSON_SORT_KEYS'] == True d = dict.fromkeys(range(20), 'foo') @app.route('/') def index(): return flask.jsonify(values=d) c = app.test_client() rv = c.get('/') lines = [x.strip() for x in rv.data.strip().decode('utf-8').splitlines()] sorted_by_str = [ '{', '"values": {', '"0": "foo",', '"1": "foo",', '"10": "foo",', '"11": "foo",', '"12": "foo",', '"13": "foo",', '"14": "foo",', '"15": "foo",', '"16": "foo",', '"17": "foo",', '"18": "foo",', '"19": "foo",', '"2": "foo",', '"3": "foo",', '"4": "foo",', '"5": "foo",', '"6": "foo",', '"7": "foo",', '"8": "foo",', '"9": "foo"', '}', '}' ] sorted_by_int = [ '{', '"values": {', '"0": "foo",', '"1": "foo",', '"2": "foo",', '"3": "foo",', '"4": "foo",', '"5": "foo",', '"6": "foo",', '"7": "foo",', '"8": "foo",', '"9": "foo",', '"10": "foo",', '"11": "foo",', '"12": "foo",', '"13": "foo",', '"14": "foo",', '"15": "foo",', '"16": "foo",', '"17": "foo",', '"18": "foo",', '"19": "foo"', '}', '}' ] try: assert lines == sorted_by_int except AssertionError: assert lines == sorted_by_str
import flask, os, re, redis from random import randint REDIS = redis.Redis(host=os.environ['REDIS_HOST'], port=6379, db=0) COLOR = f'rgb({randint(0, 255)},{randint(0, 255)},{randint(0, 255)})' HTML = '''<!DOCTYPE html> <html><body style="background-color:{}"> <h1>Version:1, AccessCount:{}, HostName:{}</h1> </body><html>''' app = flask.Flask('app server') @app.route('/', methods=['GET']) def index(): value = REDIS.get('count') count = 1 if value is None else int(value.decode()) REDIS.set('count', str(count + 1)) return HTML.format(COLOR, count, os.uname()[1]) app.run(debug=False, host='0.0.0.0', port=80)
def test_send_file_object(self, catch_deprecation_warnings): app = flask.Flask(__name__) with catch_deprecation_warnings() as captured: with app.test_request_context(): f = open(os.path.join(app.root_path, 'static/index.html'), mode='rb') rv = flask.send_file(f) rv.direct_passthrough = False with app.open_resource('static/index.html') as f: assert rv.data == f.read() assert rv.mimetype == 'text/html' rv.close() # mimetypes + etag assert len(captured) == 2 app.use_x_sendfile = True with catch_deprecation_warnings() as captured: with app.test_request_context(): f = open(os.path.join(app.root_path, 'static/index.html')) rv = flask.send_file(f) assert rv.mimetype == 'text/html' assert 'x-sendfile' in rv.headers assert rv.headers['x-sendfile'] == \ os.path.join(app.root_path, 'static/index.html') rv.close() # mimetypes + etag assert len(captured) == 2 app.use_x_sendfile = False with app.test_request_context(): with catch_deprecation_warnings() as captured: f = StringIO('Test') rv = flask.send_file(f) rv.direct_passthrough = False assert rv.data == b'Test' assert rv.mimetype == 'application/octet-stream' rv.close() # etags assert len(captured) == 1 with catch_deprecation_warnings() as captured: class PyStringIO(object): def __init__(self, *args, **kwargs): self._io = StringIO(*args, **kwargs) def __getattr__(self, name): return getattr(self._io, name) f = PyStringIO('Test') f.name = 'test.txt' rv = flask.send_file(f) rv.direct_passthrough = False assert rv.data == b'Test' assert rv.mimetype == 'text/plain' rv.close() # attachment_filename and etags assert len(captured) == 3 with catch_deprecation_warnings() as captured: f = StringIO('Test') rv = flask.send_file(f, mimetype='text/plain') rv.direct_passthrough = False assert rv.data == b'Test' assert rv.mimetype == 'text/plain' rv.close() # etags assert len(captured) == 1 app.use_x_sendfile = True with catch_deprecation_warnings() as captured: with app.test_request_context(): f = StringIO('Test') rv = flask.send_file(f) assert 'x-sendfile' not in rv.headers rv.close() # etags assert len(captured) == 1
#!/usr/bin/env python import sqlite3 import base64 import json import flask from flask_bootstrap import Bootstrap from data_filter_example import opa app = flask.Flask(__name__, static_url_path='/static') Bootstrap(app) def get_pet(pet_id): decision = query_opa("GET", ["pets", pet_id]) if not decision.defined: raise flask.abort(403) sql = opa.splice(SELECT='pets.*', FROM='pets', WHERE='pets.id=?', decision=decision) result = query_db(sql, args=(pet_id, ), one=True) if result is None: raise flask.abort(404) return result
def test_debug_log_override(self): app = flask.Flask(__name__) app.debug = True app.logger_name = 'flask_tests/test_debug_log_override' app.logger.level = 10 assert app.logger.level == 10
try: import flask from waitress.server import create_server except ImportError as error: print(error, "- to use the server, 'pip install anki[syncserver]'") sys.exit(1) from flask import Response from anki.collection import Collection from anki.sync_pb2 import SyncServerMethodRequest Method = SyncServerMethodRequest.Method # pylint: disable=no-member app = flask.Flask(__name__, root_path="/fake") col: Collection trace = os.getenv("TRACE") def get_request_data() -> bytes: buf = BytesIO() flask.request.files["data"].save(buf) buf.seek(0) zip = gzip.GzipFile(mode="rb", fileobj=buf) return zip.read() def get_request_data_into_file() -> bytes: "Returns the utf8 path to the resulting file." # this could be optimized to stream the data into a file
def test_name_with_import_error(self, modules_tmpdir): modules_tmpdir.join('importerror.py').write('raise NotImplementedError()') try: flask.Flask('importerror') except NotImplementedError: assert False, 'Flask(import_name) is importing import_name.'
import flask from flask import request from werkzeug.utils import secure_filename import os from caption import caption_generator app = flask.Flask(__name__) app.config["DEBUG"] = True # app.config['UPLOAD_FOLDER'] = './media/' APP_ROOT = os.path.dirname(os.path.abspath(__file__)) @app.route('/', methods=['GET']) def home(): return "<h1>BE - Project</h1>" @app.route('/upload', methods=['POST']) def create_caption(): target = os.path.join(APP_ROOT, 'media') image = request.files['image'] destination = "/".join([target, image.filename]) image.save(destination) return caption_generator(destination) app.run()
#: Parsing errors from subprocess _SUBPROCESS_ERROR_RE = re.compile(r'(?:warning|exception|error): ([^\n]+)', flags=re.IGNORECASE) #: Identifies the user in uWSGI logging (read by uwsgi.yml.jinja) _UWSGI_LOG_KEY_USER = '******' #: See sirepo.sr_unit SR_UNIT_TEST_IN_REQUEST = 'test_in_request' #: WSGIApp instance (see `init_by_server`) _wsgi_app = None #: Flask app instance, must be bound globally app = flask.Flask( __name__, static_folder=str(simulation_db.STATIC_FOLDER), template_folder=str(simulation_db.STATIC_FOLDER), ) app.config.update( PROPAGATE_EXCEPTIONS=True, ) def api_copyNonSessionSimulation(): req = _json_input() sim_type = req['simulationType'] global_path = simulation_db.find_global_simulation(sim_type, req['simulationId']) if global_path: data = simulation_db.open_json_file(sim_type, os.path.join(global_path, simulation_db.SIMULATION_DATA_FILE)) data['models']['simulation']['isExample'] = False data['models']['simulation']['outOfSessionSimulationId'] = req['simulationId']