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('/')