def build_app():
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////tmp/db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
db = SQLAlchemy(app)
app.secret_key = 'super secret key'
admin = Admin(app, name='Fuzz', template_mode='bootstrap3')
admin.add_view(ModelView(FuzzerIssue, db.session))
logging.basicConfig(level=logging.DEBUG)
return app
def create_app():
application = Flask(__name__)
application.secret_key = gen_random_password()
Bootstrap(application)
application.register_blueprint(base_bp)
application.register_blueprint(files_bp)
application.register_blueprint(helpers_bp)
return application
def main():
'''
This method registers all the end points of the application
'''
app = Flask(__name__)
app.secret_key = 'some_secret_key'
api = Api(app)
jwt = JWT(app, validate_user, get_user_based_on_identity)
api.add_resource(MyHanlder, '/api/hello')
return app
import subprocess
subprocess.call(['rm', '/home/rrangkuti/web/bayarkan/memory'])
from common import logger_factory
from flask.app import Flask
from controllers import home_controller
import os
logger = logger_factory.create_logger(__name__)
logger.info('starting up...')
main = Flask(__name__)
main.secret_key = os.urandom(24)
main.register_blueprint(home_controller.home_router, url_prefix='/')
if __name__ == '__main__':
main.run(port=29000)
from flask.app import Flask
from flask.ext.login import LoginManager
app = Flask(__name__)
app.secret_key = "secret"
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = "login"
with app.test_request_context():
import routes_base
import routes_home
# -*- coding:utf-8 -*-
from datetime import datetime, timedelta
import jwt
from flask.app import Flask
from flask.globals import session, request
from flask.helpers import url_for, make_response
from flask.json import jsonify
from werkzeug.security import generate_password_hash, check_password_hash
app = Flask(__name__)
app.secret_key = 'asdfasdf'
def has_no_empty_params(rule):
defaults = rule.defaults if rule.defaults is not None else ()
arguments = rule.arguments if rule.arguments is not None else ()
return len(defaults) >= len(arguments)
@app.route("/")
def index():
links = []
for rule in app.url_map.iter_rules():
# Filter out rules we can't navigate to in a browser
# and rules that require parameters
if "GET" in rule.methods and has_no_empty_params(rule):
url = url_for(rule.endpoint, **(rule.defaults or {}))
links.append((url, rule.endpoint))
# links is now a list of url, endpoint tuples
print str(links)
from flask.app import Flask
from flask.globals import request, session
from flask.templating import render_template
app = Flask(__name__)
app.secret_key = 'ASF$^UHgfjf890'
print(app.config)
@app.route('/')
@app.route('/save', methods=['GET', 'POST'])
def index():
if request.method == 'GET':
return render_template('contact.html')
if request.method == 'POST':
name = request.form
print(name["username"])
session['user'] = name["username"]
session['address'] = name["paddr"]
session['phone'] = name["phonenumber"]
return render_template('sucess.html')
if __name__ == '__main__':
app.run(debug=True)
from sqlalchemy.orm import relationship, Session
from werkzeug.utils import secure_filename
from pathlib import Path
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import os
import pandas as pd
import numpy as np
import shutil
app = Flask(__name__, static_folder="files")
app.config['UPLOAD_FOLDER'] = '.\files'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///my.db'
app.secret_key = "987654321DWT"
db = SQLAlchemy(app)
class file_details(db.Model):
__tablename__ = 'file_details'
id = Column(Integer, primary_key=True, autoincrement=True)
name = Column(String(100), unique=True, nullable=True)
columns = Column(Integer, nullable=True)
rows = Column(Integer, nullable=True)
size = Column(Integer, nullable=True)
one_to_many = relationship('file_specs',
backref='file_details',
lazy='dynamic')
from flask.app import Flask
from flask.templating import render_template
from flask.globals import session, request
from flask import redirect
import uuid
from flask.helpers import url_for
from userhash import hash_password, check_password
"""DB"""
from google.appengine.ext import db
from google.appengine.ext.db import GqlQuery
from google.appengine.api import memcache
from model import Jubo_Am, User
from google.appengine.datastore.datastore_query import Query
""" App Setting"""
app = Flask(__name__)
app.secret_key = uuid.uuid4().hex
@app.route('/')
def index():
return render_template('index.html')
@app.route('/jubo')
def jubo():
"""jubo_am = session.query(Jubo).first()"""
jubo_am = memcache.get('juboam') # @UndefinedVariable
if jubo_am is None:
jam_list = Jubo_Am.all()
for jam in jam_list:
jubo_am = jam
from app.configuration import Configuration
from app.globals import cache, db, mailservice
import blueprints
from blueprints.core import BlueprintCore
from utility.log import Log
if (__name__ == "__main__"):
# Initialise application
# ---------------------------------------------------------------------------- #
Log.level(Log.DEBUG)
Log.information(__name__, "Initialising Flask...")
app = Flask(__name__,
static_folder="../../static",
template_folder="../../template")
Bootstrap(app)
app.secret_key = Configuration["secret_key"]
Log.information(__name__, "Connecting to database...")
app.config["SQLALCHEMY_DATABASE_URI"] = Configuration["sql_db_uri"]
db.app = app
db.init_app(app)
Log.information(__name__, "Setting up cache...")
cache.init_app(app,
config={
"CACHE_TYPE": Configuration["cache_type"],
"CACHE_DIR": Configuration["cache_path"]
})
Log.information(__name__, "Setting up mailservice...")
mailservice.init_app(Configuration["email_host"],
Configuration["email_host"],
Configuration["email_user"],
Configuration["email_pass"])
import os
import sys
from flask.app import Flask
from flask import session, redirect, url_for, request
from markupsafe import escape
app = Flask(__name__)
# Set the secret key to some random bytes. Keep this really secret!
app.secret_key = b'_5#y2L"F4Q8z\n\xec]/'
print(sys.getsizeof(session))
@app.route('/')
def index():
if 'username' in session:
return 'Logged in as %s' % escape(session['username'])
return 'You are not logged in'
@app.route('/login', methods=['GET', 'POST'])
def login():
if request.method == 'POST':
session['username'] = request.form['username']
print(session['username'])
print(id(session))
return redirect(url_for('index'))
return '''
<form method="post">
import os
from flask.app import Flask
from flask_login import LoginManager
application = Flask(__name__, static_folder="content")
application.secret_key = "session_secret1122222222332321212"
def config__get(key):
return os.environ.get(key)
from couchdropwebsite import routes
import os
from flask.app import Flask
from flask_cors import CORS
from endless.server.database import init_db
app = Flask(__name__)
CORS(app)
selected_config_file = (
'../../deployment_config/budgeto/config_{0}.cfg'.format(
'prod' if os.environ.get('MODE', '') == 'PROD' else 'debug'))
app.config["PROJECT_ROOT"] = os.path.abspath(os.path.dirname(__file__))
app.config.from_pyfile(selected_config_file)
app.secret_key = 'f3c82c4584527c7ba650b18c38237cca'
# Database init
db_session, server = init_db(app.config)
from forms import GPUSearchForm
from flask import flash, render_template, request, redirect
from models import Price
from flask_table import table
from main1 import *
from flask.app import Flask
main1()
current_prices()
init_db()
app = Flask(__name__)
app.secret_key = "super secret key"
@app.route('/', methods=['GET', 'POST'])
def index():
search = GPUSearchForm(request.form)
if request.method == 'POST':
return search_results(search)
return render_template('index.html', form=search)
NETWORK = TESTNET
# The seller uri (received from a link, qrcode, ...)
SELLER_URI = 'http://127.0.0.1:8082/bargain'
'''
INITIALIZATION
'''
# Initializes the flask app
app = Flask(__name__)
# Initializes a secret key used to encrypt data in cookies
app.secret_key = '\xfd{H\xe5<\x95\xf9\xe3\x96.5\xd1\x01O<!\xd5\xa2\xa0\x9fR"\xa1\xa8'
# Initializes services to access databases or services
# For this toy project we use fake dbs storing data in memory
nego_db_service = NegoDbService()
negotiator = NegotiatorService(NETWORK)
'''
FLASK UTILITY METHODS
'''
# NoCache decorator
# Required to fix a problem with IE which caches all XMLHttpRequest responses
def nocache(f):
def add_nocache(*args, **kwargs):
import os
from flask.app import Flask
from flask.helpers import flash
from flask.templating import render_template
from flask_bootstrap import Bootstrap
from flask_transfer.exc import UploadError
from metadata_upload.service import random_string, SAMLMetadataUploadForm, \
SAMLMetadataUpload
app = Flask(__name__)
app.config['UPLOAD_DIRECTORY'] = os.environ.get('MD_UPLOAD_DIR', 'metadata_uploads')
app.secret_key = os.environ.get('MD_UPLOAD_SECRET', random_string())
Bootstrap(app)
@app.route('/', methods=['GET', 'POST'])
def upload():
form = SAMLMetadataUploadForm()
if form.validate_on_submit():
filehandle = form.uploaded_file.data
try:
SAMLMetadataUpload.save(filehandle, upload_directory=app.config['UPLOAD_DIRECTORY'])
flash('Uploaded {}'.format(filehandle.filename), 'success')
except UploadError as e:
flash('{}: {}'.format(filehandle.filename, str(e)), 'error')
elif form.errors:
for field, errors in form.errors.items():
for error in errors:
nat_dt = dt.replace(tzinfo=None)
to_fmt = '%d-%m-%Y@%I:%M:%S %p'
return nat_dt.strftime(to_fmt)
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("-d",
"--debug",
type=bool,
nargs='?',
const=True,
default=False,
dest="debug",
help="Run the server in debug mode.")
parser.add_argument("cfg_file_path",
type=str,
help="Scrapper runner config file path.")
args = parser.parse_args()
app.secret_key = V.random_str(size=30)
V._init_db()
with open(args.cfg_file_path, "r") as cfg_file:
V.CONFIG = json.load(cfg_file)
logging.info("CONFIG: " + str(V.CONFIG))
app.run(host=V.CONFIG["host"],
port=V.CONFIG["port"],
threaded=True,
debug=args.debug)
from flask.app import Flask
from flask.templating import render_template
import urllib2
from flask.globals import request
from bs4 import BeautifulSoup
import sqlite3 as lite
import HTMLParser
DATABASE = 'nc4h.db'
nc4hers = ["Sarah Kotzian","Amy Chilcote","David Herpy Larry Hancock","Michael Yoder","Salim Oden","Shannon McCollum","Mitzi Downing"]
nc4h = Flask(__name__)
nc4h.secret_key = 'nc4h'
@nc4h.route('/')
def home():
return render_template('home.html')
@nc4h.route('/add')
def add_submission():
return render_template('index.html')
@nc4h.route('/getname/',methods=["GET"])
def getname():
url = request.args.get('transferurl')
usock = urllib2.urlopen(url)
filer = usock.read();
parsed_html = BeautifulSoup(filer, "html5lib")
my_out = str(parsed_html.find('title')).replace('<title>','').replace('</title>','').replace('|','').replace('NC 4-H Youth Development','')
h = HTMLParser.HTMLParser()
s = h.unescape(my_out)
import os
from flask.app import Flask
from flask_assets import Environment
from flask_login import LoginManager
from webassets.bundle import Bundle
def config__get(key):
return os.environ.get(key)
application = Flask(__name__, static_folder="content")
application.secret_key = config__get("COUCHDROP_WEB__FLASK_SESSION_SECRET")
login_manager = LoginManager()
login_manager.init_app(application)
login_manager.login_view = "login"
from couchdropweb import routes
