def test_gravatar_url():
"""Test that the gravatar url is generated correctly"""
app = Flask(__name__)
with app.test_request_context("/"):
app.debug = True
url = gravatar_url("*****@*****.**")
eq_(url, "http://www.gravatar.com/avatar/" "b642b4217b34b1e8d3bd915fc65c4452?d=mm")
url = gravatar_url("*****@*****.**", 200)
eq_(url, "http://www.gravatar.com/avatar/" "b642b4217b34b1e8d3bd915fc65c4452?s=200&d=mm")
app.debug = False
url = gravatar_url("*****@*****.**")
eq_(url, "http://www.gravatar.com/avatar/" "b642b4217b34b1e8d3bd915fc65c4452?d=mm")
app.config["SITE_URL"] = "http://www.site.com"
url = gravatar_url("*****@*****.**")
eq_(
url,
"http://www.gravatar.com/avatar/"
"b642b4217b34b1e8d3bd915fc65c4452"
"?d=http%3A%2F%2Fwww.site.com%2Fstatic%2Fimg%2Fdefault-avatar.png",
)
def test_menu_render():
menu = decorators.menu
menu.clear()
app = Flask(__name__)
app.testing = True
@menu("Hello World", group_name="admin")
class Hello(object):
@menu("Index")
def index(self):
pass
@menu("Page 2")
def index2(self):
pass
@menu("Monster")
class Monster(object):
@menu("Home")
def maggi(self):
pass
with app.test_client() as c:
c.get("/")
assert len(menu.render()) == 2
def script_info(request):
"""Get ScriptInfo object for testing CLI."""
instance_path = tempfile.mkdtemp()
app = Flask('testapp', instance_path=instance_path)
app.config.update(
ACCOUNTS_USE_CELERY=False,
SECRET_KEY="CHANGE_ME",
SECURITY_PASSWORD_SALT="CHANGE_ME_ALSO",
SQLALCHEMY_DATABASE_URI=os.environ.get(
'SQLALCHEMY_DATABASE_URI', 'sqlite:///test.db'),
TESTING=True,
)
FlaskCLI(app)
Babel(app)
Mail(app)
InvenioDB(app)
InvenioAccounts(app)
with app.app_context():
if not database_exists(str(db.engine.url)):
create_database(str(db.engine.url))
db.drop_all()
db.create_all()
def teardown():
with app.app_context():
drop_database(str(db.engine.url))
shutil.rmtree(instance_path)
request.addfinalizer(teardown)
return ScriptInfo(create_app=lambda info: app)
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
app.register_blueprint(main_blueprint)
Misaka(app, tables=True, wrap=True)
cache.init_app(app)
return app
def create_app(database):
global app
# create our little application :)
app = Flask(__name__)
app.config.from_object(config)
app.secret_key = config.SECRET_KEY
# db import
from libs.db import init_connection
# db setup
if database: init_connection(database)
# presenters
from presenters.home import home
# register modules
app.register_blueprint(home)
# template filters
@app.template_filter('test_format')
def test_format(input):
return input[::-1]
return app
def create_app(config):
"""create flaks app object"""
# Initialize the App:
app = Flask(__name__)
from config import configurations
app.config.from_object(configurations[config])
configurations[config].init_app(app)
app.logger.addHandler(app.config.get('LOG_HANDLER'))
app.logger.info('App is starting!')
db.init_app(app)
# Register the Main Views:
from .views import api
app.register_blueprint(api, url_prefix='/api/v1')
@app.after_request
def after_request(resp):
for q in get_debug_queries():
if q.duration > app.config.get('DB_QUERY_TIMEOUT'):
app.logger.warning(
'SLOW DB STATEMENT: {0}\n\tParameters: {1}\n\tDuration: {2}\n\tContext: {3}'.
format(q.statement, q.parameters, q.duration, q.context))
return resp
return app
def setUp(self):
self.engine = Engine("op1", "op2")
self.engine.op1.setup(in_name="in", out_name="middle", required=False)
self.engine.op2.setup(in_name="middle", out_name="out")
self.engine.op1.set(OptProductEx())
foisdouze = OptProductEx("foisdouze")
foisdouze.force_option_value("factor", 12)
self.engine.op2.set(foisdouze, OptProductEx())
egn_view = EngineView(self.engine, name="my_egn")
egn_view.add_input("in", Numeric(vtype=int, min=-5, max=5))
egn_view.add_input("middle", Numeric(vtype=int))
print(self.engine.needed_inputs())
egn_view.add_output("in")
egn_view.add_output("middle")
egn_view.add_output("out")
api = ReliureAPI()
api.register_view(egn_view)
app = Flask(__name__)
app.config['TESTING'] = True
app.register_blueprint(api, url_prefix="/api")
self.app = app.test_client()
def create_app(self):
app = Flask(__name__)
app.config.from_object(config['unit_test'])
app.add_url_rule('/test', view_func=test_route)
app.add_url_rule('/', view_func=index)
#print "app.view_functions: {}".format(app.view_functions)
return app
def create_app(name='davesite', configuration='Default'):
"""
Overview: Factory method that is responsible for the following. Returns the configured Flask app object.
* Reading the configuration. The configuration is kept in config.py
* Registering the blueprints. Any blueprints to be added to the application are be added here.
* Logging: DaveSite uses the built-in python logging module to provide console and file logging.
All errors are logged to the console while only warnings and above are logged to the file.
Parameters:
name: package that davesite currently resides under.
configuration: string that points to one of the classes in config.py
Returns: A properly configured Flask application
"""
app = Flask(name)
initialize_logging()
try:
app.config.from_object('davesite.app.config.{config}'.format(config=configuration))
initialize_blueprints(app)
except Exception:
app.logger.exception("Error while starting app:")
sys.exit(-1)
add_file_logging(app.config.get('ERROR_LOG_FILE', 'error.log'), logging.WARN)
app.wsgi_app = URLPrefixMiddleware(app.wsgi_app, app.config.get('SCRIPT_NAME', '/'))
return app
def main():
app = Flask(__name__)
app.config.update(
DB_CONNECTION_STRING=':memory:',
CACHE_TYPE='simple',
SQLALCHEMY_DATABASE_URI='sqlite://',
)
app.debug = True
injector = init_app(app=app, modules=[AppModule])
configure_views(app=app, cached=injector.get(Cache).cached)
post_init_app(app, injector)
client = app.test_client()
response = client.get('/')
print('%s\n%s%s' % (response.status, response.headers, response.data))
response = client.post('/', data={'key': 'foo', 'value': 'bar'})
print('%s\n%s%s' % (response.status, response.headers, response.data))
response = client.get('/')
print('%s\n%s%s' % (response.status, response.headers, response.data))
response = client.get('/hello')
print('%s\n%s%s' % (response.status, response.headers, response.data))
response = client.delete('/hello')
print('%s\n%s%s' % (response.status, response.headers, response.data))
response = client.get('/')
print('%s\n%s%s' % (response.status, response.headers, response.data))
response = client.get('/hello')
print('%s\n%s%s' % (response.status, response.headers, response.data))
response = client.delete('/hello')
print('%s\n%s%s' % (response.status, response.headers, response.data))
def lte(app: Flask):
for blueprint in app.blueprints.values():
blueprint.jinja_loader = jinja2.ChoiceLoader([
jinja2.FileSystemLoader(os.path.join(get_root_path('flask_admin_lte'), 'templates/lte')),
blueprint.jinja_loader,
])
app.register_blueprint(Blueprint('admin_lte', __name__, static_folder='static', static_url_path='/static/lte'))
def create_app(_name_=None, root=root, config='DevelopmentConfig', **configs):
"""
App factory
:param config: name of Config class from config.py
"""
# Create and set app config
app = Flask(_name_ or __name__)
app.config.from_object('%s.config.%s' % (root, config))
app.config.update(**configs)
# initialize Flask-Login with app
login_manager.init_app(app)
# initialize hash mechanism
hashing.init_app(app)
# setup blueprints
def reload_blueprints():
"""Loads all LIVE blueprints"""
mod = lambda view: importlib.import_module('%s.%s.views' % (root, view))
return [getattr(mod(view), view) for view in app.config['LIVE']]
# Setup blueprints
def register_blueprints(*blueprints):
"""Registers all passed-in blueprints"""
blueprints = list(blueprints) + reload_blueprints()
for blueprint in blueprints:
app.register_blueprint(blueprint)
app.register_blueprints = register_blueprints
app.register_blueprints()
return app
def setUp(self):
app = Flask(__name__)
Funnel(app)
app.config['CSS_BUNDLES'] = {
'css-bundle': (
'css/test.css',
'less/test.less',
'scss/test.scss',
'stylus/test.styl',
),
}
app.config['JS_BUNDLES'] = {
'js-bundle': (
'js/test1.js',
'js/test2.js',
'coffee/test.coffee',
),
}
@app.route('/')
def index():
return render_template_string(
"{{ css('css-bundle') }} {{ js('js-bundle') }}")
self.app = app
self.client = app.test_client()
def make_json_app(import_name, **kwargs):
"""
Creates a JSON-oriented Flask app.
All error responses that you don't specifically
manage yourself will have application/json content
type, and will contain JSON like this (just an example):
{ "message": "405: Method Not Allowed" }
http://flask.pocoo.org/snippets/83/
"""
def make_json_error(ex):
response = jsonify(message=str(ex))
response.status_code = (ex.code
if isinstance(ex, HTTPException)
else 500)
return response
app = Flask(import_name, **kwargs)
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
return app
def create_app(app=None, config_file=None):
if not app:
app = Flask(__name__, template_folder="views")
# Config files
app.config.from_pyfile("config/base.py")
if config_file:
app.config.from_pyfile("config/{}.py".format(config_file))
# Extensions
Foundation(app)
admin = Admin(app, name='Bolsa de Trabajo', template_mode='bootstrap3')
"""
CONTROLADORES
"""
# Blueprints
app.register_blueprint(frontend)
# Admin Views
admin.add_view(AdminSkillView(Skill, db.session))
admin.add_view(AdminStudentView(Student, db.session))
admin.add_view(AdminCompanyView(Company, db.session))
return app
def create_app(**config):
"""Application Factory
You can create a new He-Man application with::
from heman.config import create_app
app = create_app() # app can be uses as WSGI application
app.run() # Or you can run as a simple web server
"""
app = Flask(__name__, static_folder=None)
if "MONGO_URI" in os.environ:
app.config["MONGO_URI"] = os.environ["MONGO_URI"]
app.config["LOG_LEVEL"] = "DEBUG"
app.config["SECRET_KEY"] = "2205552d13b5431bb537732bbb051f1214414f5ab34d47"
configure_logging(app)
configure_sentry(app)
configure_api(app)
configure_mongodb(app)
configure_login(app)
return app
def create_app(package_name, package_path, settings_override=None,
register_security_blueprint=True):
"""Returns a :class:`Flask` application instance configured with common
functionality for the _app_name_ platform.
:param package_name: application package name
:param package_path: application package path
:param settings_override: a dictionary of settings to override
:param register_security_blueprint: flag to specify if the Flask-Security
Blueprint should be registered. Defaults
to `True`.
"""
app = Flask(package_name, instance_relative_config=True)
app.config.from_object('_app_name_.settings')
app.config.from_pyfile('settings.cfg', silent=True)
app.config.from_object(settings_override)
db.init_app(app)
mail.init_app(app)
security.init_app(app, SQLAlchemyUserDatastore(db, User, Role),
register_blueprint=register_security_blueprint)
register_blueprints(app, package_name, package_path)
app.wsgi_app = HTTPMethodOverrideMiddleware(app.wsgi_app)
return app
def app(request):
"""Flask application fixture."""
instance_path = tempfile.mkdtemp()
app_ = Flask(__name__, instance_path=instance_path)
app_.config.update(
FILES_REST_PERMISSION_FACTORY=lambda *a, **kw: type(
'Allow', (object, ), {'can': lambda self: True}
)(),
SECRET_KEY='CHANGE_ME',
SQLALCHEMY_DATABASE_URI=os.environ.get(
'SQLALCHEMY_DATABASE_URI', 'sqlite://'),
SQLALCHEMY_TRACK_MODIFICATIONS=True,
TESTING=True,
)
app_.register_blueprint(files_rest_blueprint)
InvenioDB(app_)
InvenioRecords(app_)
InvenioFilesREST(app_)
InvenioIndexer(app_)
search = InvenioSearch(app_)
search.register_mappings('records-files', 'data')
with app_.app_context():
yield app_
shutil.rmtree(instance_path)
def test_flask_sqlalchemy():
from flask.ext.sqlalchemy import SQLAlchemy as FlaskSQLAlchemy
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///'
db = FlaskSQLAlchemy(app)
class UserMixin(object):
email = db.Column(db.Unicode(300))
def __init__(self, login, email):
self.login = login
self.email = email
self.password = '******'
class RoleMixin(object):
description = db.Column(db.UnicodeText)
auth = authcode.Auth(SECRET_KEY, db=db, UserMixin=UserMixin, RoleMixin=RoleMixin)
authcode.setup_for_flask(auth, app)
User = auth.User
db.create_all()
user = User(u'meh', u'*****@*****.**')
db.session.add(user)
db.session.commit()
assert user.login == u'meh'
assert user.email == u'*****@*****.**'
assert hasattr(user, 'password')
assert hasattr(user, 'last_sign_in')
assert repr(user) == '<User meh>'
def create_cartographer(args):
app = Flask(__name__)
app.config["SECRET_KEY"] = "map the soul"
@app.route("/")
def hi():
return render_template("index.html")
@app.route("/getPoints", methods=["POST"])
def getPoints():
print(request.json)
zoom = int(request.json.get("zoom", 1))
seen = request.json.get("seen", [])
ensure(seen).is_a_list_of(str)
points = POI.objects(
at__geo_within_box=(request.json["SW"], request.json["NE"]), min_zoom=zoom, name__nin=request.json["seen"]
)
return jsonify(
{
"points": [
{
"name": p.name,
"lat": p.at["coordinates"][1],
"lng": p.at["coordinates"][0],
"abstract": lz4.decompress(p.abstract).decode() if p.abstract else "",
"img": p.img,
}
for p in points
]
}
)
return app
class RootREST:
def __init__(self, host, run_flask, port):
self.host = host
self.port = port
self.run_flask = run_flask
self.app = Flask(__name__)
CORS(self.app,
resources={
r'/*': {
'origins': '*',
'headers': ['Content-Type']
}
}
)
#blueprintRest = BlueprintRest()
self.app.register_blueprint(bp, url_prefix='/blueprint')
#self.app.register_blueprint(Blueprint('blueprint', __name__), url_prefix='/blueprint')
# Root service.
@self.app.route('/')
def landing():
return core.landing_message()
# Run Flask.
if self.run_flask:
self.app.run(host=self.host, port=self.port)
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
# 初始化一些flask扩展库，依赖于flask的app上下文环境
db.init_app(app)
# 初始化bootstrap
bootstrap.init_app(app)
# 初始化登陆管理
login_manager.init_app(app)
# 初始化邮件
mail.init_app(app)
# 初始化moment
moment.init_app(app)
# 附加路由和自定义的错误页面
app_dir = os.path.join(root_dir, 'app')
# 逐个执行各个路由映射脚本，添加到route_list中
for routes in os.listdir(app_dir):
rou_path = os.path.join(app_dir, routes)
if (not os.path.isfile(rou_path)) and routes != 'static' and routes != 'templates':
__import__('app.' + routes)
# 从route_list中引入蓝图
for blueprints in route_list:
if blueprints[1] != None:
app.register_blueprint(blueprints[0], url_prefix = blueprints[1])
else:
app.register_blueprint(blueprints[0])
#返回app实例，让外部模块继续使用
return app
def test_whitelisting(self):
app = Flask(__name__)
limiter = Limiter(app, global_limits=["1/minute"], headers_enabled=True)
@app.route("/")
def t():
return "test"
@limiter.request_filter
def w():
if request.headers.get("internal", None) == "true":
return True
return False
with hiro.Timeline().freeze() as timeline:
with app.test_client() as cli:
self.assertEqual(cli.get("/").status_code, 200)
self.assertEqual(cli.get("/").status_code, 429)
timeline.forward(60)
self.assertEqual(cli.get("/").status_code, 200)
for i in range(0,10):
self.assertEqual(
cli.get("/", headers = {"internal": "true"}).status_code,
200
)
def test_headers_breach(self):
app = Flask(__name__)
limiter = Limiter(app, global_limits=["10/minute"], headers_enabled=True)
@app.route("/t1")
@limiter.limit("2/second; 10 per minute; 20/hour")
def t():
return "test"
with hiro.Timeline().freeze() as timeline:
with app.test_client() as cli:
for i in range(11):
resp = cli.get("/t1")
timeline.forward(1)
self.assertEqual(
resp.headers.get('X-RateLimit-Limit'),
'10'
)
self.assertEqual(
resp.headers.get('X-RateLimit-Remaining'),
'0'
)
self.assertEqual(
resp.headers.get('X-RateLimit-Reset'),
str(int(time.time() + 49))
)
def test_custom_headers_from_config(self):
app = Flask(__name__)
app.config.setdefault(C.HEADER_LIMIT, "X-Limit")
app.config.setdefault(C.HEADER_REMAINING, "X-Remaining")
app.config.setdefault(C.HEADER_RESET, "X-Reset")
limiter = Limiter(app, global_limits=["10/minute"], headers_enabled=True)
@app.route("/t1")
@limiter.limit("2/second; 10 per minute; 20/hour")
def t():
return "test"
with hiro.Timeline().freeze() as timeline:
with app.test_client() as cli:
for i in range(11):
resp = cli.get("/t1")
timeline.forward(1)
self.assertEqual(
resp.headers.get('X-Limit'),
'10'
)
self.assertEqual(
resp.headers.get('X-Remaining'),
'0'
)
self.assertEqual(
resp.headers.get('X-Reset'),
str(int(time.time() + 49))
)
def test_url_absolute(self):
app = Flask(__name__)
app.add_url_rule("/<hey>", "foobar", view_func=lambda x: x)
field = fields.Url("foobar", absolute=True)
with app.test_request_context("/"):
self.assertEquals("http://localhost/3", field.output("hey", Foo()))
def setUp(self):
app = Flask(__name__)
app.config['SECRET_KEY'] = 'my secret'
digest_auth_my_realm = HTTPDigestAuth(realm='My Realm')
@digest_auth_my_realm.get_password
def get_digest_password_3(username):
if username == 'susan':
return 'hello'
elif username == 'john':
return 'bye'
else:
return None
@app.route('/')
def index():
return 'index'
@app.route('/digest-with-realm')
@digest_auth_my_realm.login_required
def digest_auth_my_realm_route():
return 'digest_auth_my_realm:' + digest_auth_my_realm.username()
self.app = app
self.client = app.test_client()
def create_app():
setup_config(sys.argv[1], 'dnsdb-updater', conf_dir=os.path.dirname(os.path.dirname(__file__)))
log.error('This host belong to host group %s' % CONF.host_group)
app = Flask(__name__)
app.config['SECRET_KEY'] = CONF.etc.secret_key
from dns_updater.utils.updater_util import check_necessary_options
check_necessary_options()
@app.route("/healthcheck.html", methods=['GET'])
def health_check():
try:
return render_template('healthcheck.html')
except TemplateNotFound:
abort(404)
@app.context_processor
def default_context_processor():
result = {'config': {'BASE_URL': CONF.web.base_url}}
return result
from dns_updater import api
app.register_blueprint(api.bp, url_prefix='/api')
return app
def test_url_invalid_object(self):
app = Flask(__name__)
app.add_url_rule("/<hey>", "foobar", view_func=lambda x: x)
field = fields.Url("foobar")
with app.test_request_context("/"):
self.assertRaises(MarshallingException, lambda: field.output("hey", None))
def test_flask(self):
app = Flask(__name__)
db = SQLAlchemy(app)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:'
class Cities(db.Model):
__tablename__ = 'users'
id = Column(Integer, primary_key=True)
name = Column(String)
population = Column(Integer)
def __init__(self, name, population):
self.name = name
self.population = population
app.config['TESTING'] = True
app = app.test_client()
db.create_all()
city = Cities("Cordoba", 1000000)
db.session.add(city)
city = Cities("Rafaela", 99000)
db.session.add(city)
db.session.commit()
query_string = '{ "sort": { "population" : "desc" } }'
results = elastic_query(Cities, query_string)
assert(results[0].name == 'Cordoba')
result = captcha.output(logits)
saver = tf.train.Saver()
sess = tf.Session()
saver.restore(sess, tf.train.latest_checkpoint(FLAGS.checkpoint_dir))
# print(tf.train.latest_checkpoint(FLAGS.checkpoint_dir))
recog_result = sess.run(result)
sess.close()
text = one_hot_to_texts(recog_result)
total_count = len(input_filenames)
result = ""
for i in range(total_count):
result = text[i]
return result
api = Flask("hello")
@api.route('/ping', methods=['POST'])
def ping():
data = json.loads(request.get_data(as_text=True))
res = run_predict(data['image'])
return res
def main(_):
api.run(host="0.0.0.0")
if __name__ == '__main__':
parser = argparse.ArgumentParser()
from flask import Flask, render_template, request, session, redirect, flash
from flask_sqlalchemy import SQLAlchemy
from werkzeug.utils import secure_filename
from flask_mail import Mail
import json
import os
import math
from datetime import datetime
local_server = True
with open("config.json", "r") as c:
params = json.load(c)["params"]
app = Flask(__name__)
app.secret_key = "super-secret-key"
app.config["UPLOAD_FOLDER"] = params["upload_location"]
app.config.update(MAIL_SERVER='smtp.gmail.com',
MAIL_PORT="465",
MAIL_USERNAME=params["user"],
MAIL_PASSWORD=params["password"])
mail = Mail(app)
if (local_server):
app.config['SQLALCHEMY_DATABASE_URI'] = params["local_uri"]
else:
app.config['SQLALCHEMY_DATABASE_URI'] = params["prod_uri"]
db = SQLAlchemy(app)
class Contacts(db.Model):
sno = db.Column(db.Integer, primary_key=True)
'''
This program helps you to render HTML template in flask.
You should create an HTML file inside a folder called "templates"
in the same directory
'''
from flask import Flask #import the Flask object from the flask package
from flask import render_template#for rendering html page
app=Flask(__name__)#creating your Flask application instance with the name app
@app.route("/")#pass '/' to signify that this function respond to main URL
def home():
return render_template("index1.html")#connects with html page
if __name__=="__main__":
app.run()#run the development server.
import numpy as np
from flask import Flask, request, jsonify, render_template
import pickle
app = Flask(__name__)
model = pickle.load(open('model.pkl', 'rb'))
@app.route('/')
def home():
return render_template('index.html')
@app.route('/predict', methods=['POST'])
def predict():
int_features = [int(x) for x in request.form.values()]
final_features = [np.array(int_features)]
prediction = model.predict(final_features)
output = prediction[0]
return render_template('index.html',
prediction_text='Expense = {}'.format(output))
if __name__ == "__main__":
app.run(debug=True)
import json
from flask import Flask, request, jsonify
from jsonschema.exceptions import ValidationError
from .check_against_schema import (
validate_request_against_schema,
validate_response_against_schema,
is_whitelisted,
get_spec,
parse_data,
JSONSchemaValidationError,
UndefinedSchemaError,
)
app = Flask(__name__)
schema = None
whitelist = None
def set_proxy_settings(schema_arg, whitelist_arg):
global schema
global whitelist
schema = json.loads(schema_arg)
if whitelist_arg:
whitelist = json.loads(whitelist_arg)
@app.route("/", methods=["POST"])
from flask import Flask, request, make_response
import base64
import json
import hmac
import hashlib
app = Flask(__name__)
@app.route("/")
def hello():
return "Hello World!"
key = "LQoFCBtOXRcbF1UhRRgTAU8NSA=="
def sha256(msg):
return int(hashlib.sha256(msg.encode('utf-8')).hexdigest(), 16)
def hmac_sha256(key, msg):
signature = hmac.new(bytes(key, 'latin-1'),
msg = bytes(msg, 'latin-1'),
digestmod = hashlib.sha256).hexdigest().upper()
return signature
@app.route("/ex3/login", methods=['POST'])
def login():
data = json.loads(request.data.decode('utf-8'))
user = data["user"]
pwd = data["pass"]
resp = make_response()
if user == "administrator" and pwd == "42":
cookie = 'administrator,1489662453,com402,hw2,ex3,administrator'
## log in with the current credentials
self.name=name
self.email=email
self.logged_in=True
return True
## if an user with this email is already there return false
else:
return False
def get_models(self):
if self.logged_in:
print('Accessing priviledge accounts')
## Configuring the app
app = Flask(__name__,static_url_path='/')
app.config['SECRET_KEY'] = '9OLWxND4o83j4K4iuopO'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///DB.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
init_db
db.init_app(app)
current_user=User(app.config['SQLALCHEMY_DATABASE_URI'])
## App route for home directory, reshows the index
@app.route('/')
def home():
print(current_user.name)
return render_template('index.html')
## App route for signup, allows users to create an account
from math import log
from flask import Flask, request, render_template
from spotify import *
import os.path
template_dir = os.path.abspath('static/templates')
static_dir = os.path.abspath('static')
app = Flask('name', template_folder=template_dir, static_folder=static_dir)
@app.route('/')
def home():
return render_template('home.html')
@app.route('/app')
def application():
return render_template('app.html')
@app.route('/getplaylist')
def generate():
input_string = request.args.get('url', default="none", type = str)
print(input_string)
if input_string == "none":
return "{'error 123': 'no string provided, you have to route it to /getplaylist?url=<url>'}"
else:
informations = get_playlist_infos(input_string)
return json.dumps(informations)
@app.route('/favicon.ico')
def icon():
with open('icon.ico', 'rb') as file:
return file.read()
def create_app():
app = Flask(__name__)
basedir = os.path.abspath(os.path.dirname(__file__))
#sqlite - local
#app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + \
# os.path.join(basedir, 'crud.db')
#MySQL - local
#app.config['SQLALCHEMY_DATABASE_URI']='mysql+pymysql://<mysql_username>:<mysql_password>@<mysql_host>:<mysql_port>/<mysql_db>'
#app.config['SQLALCHEMY_DATABASE_URI']='mysql+pymysql://projetofinal:password@localhost:3306/crud'
#MySQL - Docker
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://*****:*****@mysql/crud'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
config_db(app)
config_ma(app)
Migrate(app, app.db)
from .sound import bp_sound
app.register_blueprint(bp_sound)
from .xdk import bp_xdk
app.register_blueprint(bp_xdk)
from .esp32 import bp_esp32
app.register_blueprint(bp_esp32)
from .vibration import bp_vibration
app.register_blueprint(bp_vibration)
return app
import psycopg2
from flask import Flask, render_template, redirect, flash, session
import requests
from flask.ext.wtf import Form
from wtforms import StringField, PasswordField
import riotwatcher
import atexit
app = Flask(__name__)
app.secret_key = 'A0Zr98j/3yX R~XHH!jmN]LWX/,?RT'
app.service = 'http://127.0.0.1:5001/api/'
key = '1dbf97cc-5028-4196-a05c-6645adc80bef'
w = riotwatcher.RiotWatcher(key)
@app.route('/')
def index():
return render_template("index.html")
@app.route('/sign-out')
def sign_out():
if 'username' in session:
del session['username']
return redirect('/')
@app.route('/sign-up', methods=['GET', 'POST'])
def sign_up():
class SignUpForm(Form):
email = StringField()
from flask import make_response
import requests
auth = HTTPBasicAuth()
engine = create_engine('sqlite:///itemCatalog.db')
Base.metadata.bind = engine
DBSession = sessionmaker(bind=engine)
session = DBSession()
app = Flask(__name__)
CLIENT_ID = json.loads(open('client_secrets.json',
'r').read())['web']['client_id']
APPLICATION_NAME = "Item Catalog"
# Create anti-forgery state token
@app.route('/login')
def showLogin():
state = ''.join(
random.choice(string.ascii_uppercase + string.digits)
for x in xrange(32))
login_session['state'] = state
#return "The current session state is %s" % login_session['state']
return render_template('login.html', STATE=state)
# вначале id потом class
bot.register_next_step_handler(msg, hello)
def hello(message):
uId = message.chat.id
uClass = message.text
filemanager.reg(uId, uClass)
filemanager.getStat()
# Проверим, есть ли переменная окружения Хероку (как ее добавить смотрите ниже)
if "HEROKU" in list(os.environ.keys()):
logger = telebot.logger
telebot.logger.setLevel(logging.INFO)
server = Flask(__name__)
@server.route("/bot", methods=['POST'])
def getMessage():
bot.process_new_updates([telebot.types.Update.de_json(request.stream.read().decode("utf-8"))])
return "!", 200
@server.route("/")
def webhook():
bot.remove_webhook()
bot.set_webhook(url="https://https://send-homework.herokuapp.com/bot") # этот url нужно заменить на url вашего Хероку приложения
return "?", 200
server.run(host="0.0.0.0", port=os.environ.get('PORT', 80))
else:
# если переменной окружения HEROKU нету, значит это запуск с машины разработчика.
# Удаляем вебхук на всякий случай, и запускаем с обычным поллингом.
bot.remove_webhook()
bot.polling(none_stop=True)
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
app.config[
"SQLALCHEMY_DATABASE_URI"] = "mysql+pymysql://root:[email protected]:3306/flaskweb"
# 如果设置成 True (默认情况)，Flask-SQLAlchemy 将会追踪对象的修改并且发送信号。
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = True
# 绑定app至SQLAlchemy
db = SQLAlchemy(app)
# 班级 1
class Classs(db.Model):
__tablename__ = 'onetomore_class'
id = db.Column(db.Integer, primary_key=True)
cname = db.Column(db.String(50))
# stus = db.relationship('Stus',backref="classs")
stus = db.relationship('Stus',
backref="classs",
cascade="all,delete,delete-orphan")
# def __repr__(self):
# return self.cname
# 学员 多
class Stus(db.Model):
__tablename__ = 'onetomore_stu'
id = db.Column(db.Integer, primary_key=True)
import sqlite3
from flask import Flask, g
DATABASE = r'C:\libraltranary\library.db'
app = Flask(__name__)
# If we don't have a database connection already, we create a new one and attach it to the 'g' global object
def get_db():
db = getattr(g, '_database', None)
if db is None:
db = g._database = sqlite3.connect(DATABASE)
return db
# Close an open database
@app.teardown_appcontext
def close_connection(exception):
db = getattr(g, '_database', None)
if db is not None:
db.close()
# Prints a message to a user
@app.route('/greet/<string:name>')
def hello(name):
return f'Message in a bottle for {name}!'
'''
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
log = logging.getLogger(__name__)
log.setLevel(LOG_LEVEL)
stream_handler = logging.StreamHandler()
stream_handler.setFormatter(formatter)
log.addHandler(stream_handler)
return log
LOG = _logger()
LOG.debug("Starting with log level: %s" % LOG_LEVEL )
APP = Flask(__name__)
def require_jwt(function):
"""
Decorator to check valid jwt is present.
"""
@functools.wraps(function)
def decorated_function(*args, **kws):
if not 'Authorization' in request.headers:
abort(401)
data = request.headers['Authorization']
token = str.replace(str(data), 'Bearer ', '')
try:
jwt.decode(token, JWT_SECRET, algorithms=['HS256'])
except: # pylint: disable=bare-except
abort(401)
from flask import Flask
from flask import request
from flask import jsonify
from flask import render_template
import json
app = Flask(__name__)
@app.route('/')
def index():
return 'hello world! ;)'
@app.route('/routeScores')
def getRouteScores():
'''returns json object of all allocation scores per route'''
routeScores = json.load(open('../jsons/routeScores.json', 'r'))
return jsonify(routeScores)
@app.route('/allocationScores')
def getAllocationScores():
'''returns json object of all allocation scores per route'''
allocationScores = json.load(open('../jsons/allocationScores.json', 'r'))
return jsonify(allocationScores)
@app.route('/routes')
def getRoutes():
routes = json.load(open('../jsons/routesGeoJSONs.json', 'r'))
import json
# dependencies
from flask import Flask, jsonify, request
from celery import group
# import uuid
# project dependencies
from config import config
from tasks import fetch
from worker import celery
# Date format from arguments. Also required for Twint
dtformat = "%Y-%m-%d"
#
# Initialize Flask
app = Flask('twint_server')
# Development on localhost
if config['ALLOW_CORS']:
from flask_cors import CORS
CORS(app)
class Empty(object):
pass
#
# REST Endpoint
@app.route("/fetch", methods=['POST'])
def fetch_tweets():
print("Fetching request")
config = Empty()
import os
from cs50 import SQL
from flask import Flask, flash, jsonify, redirect, render_template, request, session
from flask_session import Session
from tempfile import mkdtemp
from werkzeug.exceptions import default_exceptions, HTTPException, InternalServerError
from werkzeug.security import check_password_hash, generate_password_hash
from helpers import apology, login_required, lookup, usd
app = Flask(__name__)
# Ensure templates are auto-reloaded
app.config["TEMPLATES_AUTO_RELOAD"] = True
# Ensure responses aren't cached
@app.after_request
def after_request(response):
response.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
response.headers["Expires"] = 0
response.headers["Pragma"] = "no-cache"
return response
# Custom filter
app.jinja_env.filters["usd"] = usd
# Configure session to use filesystem (instead of signed cookies)
app.config["SESSION_FILE_DIR"] = mkdtemp()
app.config["SESSION_PERMANENT"] = False
#!/usr/bin/python3
from flask import Flask, render_template
from models import storage, State
app = Flask(__name__)
@app.route('/states_list', strict_slashes=False)
def print_state():
""" string to be returned """
states = storage.all(State).values()
print(states)
return render_template('7-states_list.html', states=states)
@app.teardown_appcontext
def closesession(self):
""" string to be returned """
storage.close()
if __name__ == '__main__':
app.run('0.0.0.0', port=5000)
from flask import Flask
from flask_restful import Api
import yaml
from applications.notify.api import Start, Stop
from applications.audit.api import Statistic
from multiprocessing import Pool
import os
cpu_count = os.cpu_count()
app = Flask(__name__)
# 加载配置文件
with open('config.yaml', 'r', encoding='utf-8') as f:
data = yaml.load(f, Loader=yaml.FullLoader)
for key, value in data.items():
app.config[key] = value
# restful
api = Api(app)
api.add_resource(Start, '/notify/start')
api.add_resource(Stop, '/notify/end')
api.add_resource(Statistic, '/student/stat')
app.config['pool'] = Pool(cpu_count)
import os
import elasticsearch
from flask import Flask
from flask_cors import CORS
from apies import apies_blueprint
DATAPACKAGE_BASE = 'http://next.obudget.org/datapackages/budgetkey/{}/datapackage.json'
ES_HOST = os.environ.get('ES_HOST', 'localhost')
ES_PORT = int(os.environ.get('ES_PORT', '9200'))
INDEX_NAME = os.environ.get('INDEX_NAME', 'budgetkey')
app = Flask(__name__)
CORS(app)
blueprint = apies_blueprint(app,
[
DATAPACKAGE_BASE.format(doctype)
for doctype in [
'people',
'tenders',
'entities',
'contract-spending',
'national-budget-changes',
'supports',
'reports',
'budget',
'gov_decisions',
]
],
import datetime
import os
from flask import Flask, render_template, redirect, url_for
from forms import ItemForm
from models import Items
from database import db_session
app = Flask(__name__)
app.secret_key = os.environ['APP_SECRET_KEY']
@app.route("/", methods=('GET', 'POST'))
def add_item():
form = ItemForm()
if form.validate_on_submit():
item = Items(name=form.name.data, quantity=form.quantity.data, description=form.description.data, date_added=datetime.datetime.now())
db_session.add(item)
db_session.commit()
return redirect(url_for('success'))
return render_template('index.html', form=form)
@app.route("/success")
def success():
results = []
qry = db_session.query(Items)
results = qry.all()
#return str(results)
# list_results=[]
#for item in results:
# list_results.append({'name':item.name, 'quantity':item.quantity, 'description':item.description})
# -*- coding: utf-8 -*-
# @File : index.py
# @Date : 2018-05-10
# @Author : 彭世瑜
# 使用flask创建一个导航主页管理
from flask import Flask, render_template, request, url_for, redirect
from model import ClassifyModel
from model import WebsiteModel
from spider import get_website_info
from spider import download_icon
app = Flask(__name__)
# 首页
@app.route("/")
def index():
websites = WebsiteModel.select().where(WebsiteModel.weight!=0)
classifies = ClassifyModel.select().where(ClassifyModel.weight!=0).order_by(-ClassifyModel.weight)
print(len(websites))
dct = {
"websites": websites,
"classifies": classifies
}
return render_template("index.html", **dct)
# 管理首页
@app.route("/admin")
def admin():
f"{self.formatTime(record, self.datefmt)} : {cpath} : "
f"{record.getMessage()}")
if record.exc_info:
# Cache the traceback text to avoid converting it multiple times
if not record.exc_text:
record.exc_text = self.formatException(record.exc_info)
if record.exc_text:
if outputString[-1:] != "\n":
outputString = outputString + "\n"
outputString = outputString + record.exc_text
return outputString
# Initialize the app for Flask
app = Flask(__name__)
# Set the configuration parameters that are used by the application.
# These values are overriden by the .panrc file located in the base directory
# for the application
#
# ---------- APPLICATION SETTINGS --------------
#
# Current version number of SafeNetworking
app.config['VERSION'] = "v4.0"
#
# When set to True, this slows down the logging by only processing 1 event at a
# time and allows us to see what is going on if there are bugs
app.config['DEBUG_MODE'] = False
#
'''
文件说明：该文件是主app文件，系统的逻辑功能都写在该文件里
'''
from flask import Flask,render_template,request,redirect,url_for
import config
from exts import db
from models import DeclareForm,Invite
import time,datetime
# app的初始化
app = Flask(__name__)
app.config.from_object(config)
db.init_app(app)
'''
功能：编制邀标书首页显示
作者：秦华山
日期：2017.10.5
'''
@app.route('/')
def index():
return render_template('index.html')
# 时间控件测试
@app.route('/dateTest/')
def dateTest():
return render_template('dateTest.html')
'''
功能：将编辑好的邀标书存入数据库，以便后期审核、查看
from flask import session as login_session
from sqlalchemy import create_engine
from sqlalchemy.pool import SingletonThreadPool
from sqlalchemy.orm import sessionmaker
from oauth2client.client import flow_from_clientsecrets, FlowExchangeError
from database_setup import Base, Author, Books_Data, User
import httplib2
import json
import requests
import random
import string
CLIENT_ID = json.loads(open('client_secrets.json',
'r').read())['web']['client_id']
app = Flask(__name__)
engine = create_engine('sqlite:///bookscatalogue.db')
Base.metadata.bind = engine
DBSession = sessionmaker(bind=engine)
session = DBSession()
@app.route('/login')
def showLogin():
state = ''.join(
random.choice(string.ascii_uppercase + string.digits)
for x in xrange(32))
login_session['state'] = state
return render_template('login.html', STATE=state)
from flask import Flask, request, jsonify, make_response
from flask_mongoengine import MongoEngine
from marshmallow import Schema, fields, post_load
from bson import ObjectId
app = Flask(__name__)
app.config['MONGODB_DB'] = 'FLASKMONGODB'
db = MongoEngine(app)
Schema.TYPE_MAPPING[ObjectId] = fields.String
class Authors(db.Document):
name = db.StringField()
specialisation = db.StringField()
class AuthorsSchema(Schema):
class Meta:
model = Authors
id = fields.String(required=True)
name = fields.String(required=True)
specialisation = fields.String(required=True)
@app.route('/authors', methods = ['GET'])
def index():
get_authors = Authors.objects.all()
author_schema = AuthorsSchema(many=True)
#print(get_authors[0].name)
if len(get_authors)>0:
authors = author_schema.dump(get_authors)
else:
authors = author_schema.dump([])
return make_response(jsonify({"authors": authors}))
from flask import Flask, render_template, request
app = Flask(__name__)
import sys
import docker
import json
import subprocess
import re
import statistics
client = docker.DockerClient(base_url='unix://container/path/docker.sock')
DOCKER_EXCLUDE = ['experiment-runner']
METRICS_MOCK_FILE = ""
@app.route('/')
def index_html():
# print(client.containers.list(), file=sys.stderr)
docker_list = {}
for _container in client.containers.list():
if not _container.attrs["Name"][1:] in DOCKER_EXCLUDE:
docker_list[_container.attrs["Name"][1:]] = _container.attrs["Id"]
return render_template('index.html', docker_list=docker_list)
@app.route('/interactive')
def interactive_html():
# print(client.containers.list(), file=sys.stderr)
docker_list = {}
from flask import Flask, render_template
from flask_pymongo import PyMongo
import scraping
# set up Flask:
app = Flask(__name__)
# Use flask_pymongo to set up mongo connection
app.config["MONGO_URI"] = "mongodb://*****:*****@app.route("/")
def index():
mars = mongo.db.mars.find_one(
) # uses PyMongo to find the “mars” collection in our database, which we will create when we convert our Jupyter scraping code to Python Script
return render_template(
"index.html", mars=mars
) # return an HTML template using an index.html file, and use mars collection
@app.route("/scrape")
def scrape():
mars = mongo.db.mars
mars_data = scraping.scrape_all()
mars.update(
{}, mars_data, upsert=True
) # upsert=True, which tells Mongo to create a new document if one doesn’t already exist.
return "Scraping Successful!"
from flask import Flask, redirect, render_template, request, flash, session
from mysqlconnection import MySQLConnector
import re
EMAIL_REGEX = re.compile(r'^[a-zA-Z0-9.+_-]+@[a-zA-Z0-9._-]+\.[a-zA-Z]+$')
app = Flask(__name__)
app.secret_key = "secretkey"
mysql = MySQLConnector(app, 'emails')
@app.route('/')
def index():
return render_template('index.html')
@app.route('/check', methods=['POST'])
def check():
if len(request.form['email']) < 1:
flash('Email cannot be blank!')
elif not EMAIL_REGEX.match(request.form['email']):
flash('Email is invalid!')
else:
query("INSERT INTO emails (email, created_at, updated_at)" +
"VALUES(:email, NOW(), NOW())")
data = {'email': request.form['email']}
mysql.query_db(query, data)
session['email'] = request.form['email']
return redirect('/success')
return redirect('/')
