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