def create_app(db_name=None): app = Flask(__name__) app.config.from_object(config) if db_name: config.MONGO_DATABASE = db_name mongo, db = HapPyMongo(config) app.permanent_session_lifetime = timedelta(hours=2) auth = CloudAuth(app, db) app.context_processor(template_functions.view_functions) Admin(app) @app.before_first_request def logger(): if not app.debug: app.logger.addHandler(logging.StreamHandler()) app.logger.setLevel(logging.INFO) @app.before_request def before_request(): g.db, g.auth = db, auth defaults.application_initialize(db, app) views.BaseView.register(app) views.GlobalManageView.register(app) views.QueryView.register(app) if db_name: return app, db else: return app
def start(): """ Start the application """ config_type = "DevelopmentConfig" if len(sys.argv) == 2: if sys.argv[1] == "dev": config_type = "DevelopmentConfig" elif sys.argv[1] == "test": config_type = "TestConfig" elif sys.argv[1] == "prod": config_type = "ProductionConfig" app = Flask(__name__) app.config.from_object("conf.config.%s" % config_type) app.secret_key = getRandomInteger(128) app.permanent_session_lifetime = timedelta(seconds=10) FORMAT = "%(asctime)s %(levelname)s: " "%(message)s [in %(pathname)s:%(lineno)d]" logging.basicConfig(filename=app.config["LOGFILE"], level=logging.DEBUG, format=FORMAT) PYSTHClient.init_controllers(app) @app.errorhandler(400) def bad_request(exception): """Bad Request""" data = dict(status=exception.code, error=str(exception), description=bad_request.__doc__) return jsonify(data), 400 @app.errorhandler(404) def page_not_found(exception): """Page Not Found""" data = dict(status=exception.code, error=str(exception), description=page_not_found.__doc__) return jsonify(data), 404 if app.config["DEBUG"] is True: @app.errorhandler(500) def error(exception): """Internal Server Error""" data = dict(status=exception.code, error=str(exception), description=error.__doc__) return jsonify(data), 500 @app.errorhandler(403) def forbidden(exception): """Forbidden""" data = dict(status=exception.code, error=str(exception), description=forbidden.__doc__) return jsonify(data), 403 # noinspection PyUnusedLocal @app.before_first_request def bootstrap(): """ Call the bootstrap function """ Bootstrap() with app.app_context(): Base.do_first_request() app.run(app.config["HOST"], app.config["PORT"])
def create_app(config_name): app = Flask(__name__) CORS(app) app.config.from_object(config[config_name]) import logging from logging.handlers import RotatingFileHandler _handler = RotatingFileHandler(app.config['LOGGER_NAME'], maxBytes=10000, backupCount=1) _handler.setLevel(logging.DEBUG) app.logger.addHandler(_handler) pagedown.init_app(app) mail.init_app(app) moment.init_app(app) bootstrap.init_app(app) app.secret_key = app.config['SECRET_KEY'] app.permanent_session_lifetime = timedelta(minutes=5) login_manager.init_app(app) db.init_app(app) from .api_1_0 import api as api_1_0_blueprint app.register_blueprint(api_1_0_blueprint, url_prefix='/api') from .base import base app.register_blueprint(base) from .rest_api import rest_api app.register_blueprint(rest_api, url_prefix='/rest') from .models import Role @app.before_first_request def build_up_before_start(): Role.insert_roles() return app
def create_app(config_name): application = Flask(__name__, static_folder='static/', static_url_path=configs[config_name].ASSET_PATH) init_app( application, configs[config_name], bootstrap=bootstrap, data_api_client=data_api_client, login_manager=login_manager ) application.permanent_session_lifetime = timedelta(hours=1) from .main import main as main_blueprint from .status import status as status_blueprint url_prefix = application.config['URL_PREFIX'] application.register_blueprint(status_blueprint, url_prefix=url_prefix) application.register_blueprint(main_blueprint, url_prefix=url_prefix) login_manager.login_view = 'main.render_login' main_blueprint.config = application.config.copy() init_frontend_app(application, data_api_client, login_manager) application.add_template_filter(parse_document_upload_time) @application.context_processor def extra_template_variables(): return { 'generic_contact_email': application.config['GENERIC_CONTACT_EMAIL'], } return application
def create_app(): application = Flask(__name__) application.config['SQLALCHEMY_DATABASE_URI'] = DATABASE_URI # application.config['BABEL_DEFAULT_LOCALE'] = 'ru-ru' application.config['SECRET_KEY'] = SECRET_KEY application.permanent_session_lifetime = timedelta(minutes=30) Triangle(application) assets.init_app(application) api.init_app(application) api.application = application db.init_app(application) admin.init_app(application) login_manager.init_app(application) application.db = db application.api = api babel = Babel(application) @babel.localeselector def get_locale(): return request.accept_languages.best_match(["ru"]) init_logging(application) return application
def create_app(config_filename='config.default.DevelopmentConfig'): app = Flask(__name__) app.config.from_object(config_filename) app.secret_key = app.config['SECRET_KEY'] app.permanent_session_lifetime = timedelta(minutes=app.config['SESSION_ALIVE_MINUTES']) app.session_interface = ItsdangerousSessionInterface() # SOCKET # url = '127.0.0.1' # client_socket.connect((url, 8000)) # logging module log_filepath = os.path.join(app.config['ROOT_DIR'], 'app_server/log') log.init(log_filepath=log_filepath, log_level=app.config['LOG_LEVEL']) log.info("CREATE HIMS APP : "+__name__) db.init_app(app) bcrypt.init_app(app) login_manager.init_app(app) from youngs_server.api.auth_controllers import api_auth from youngs_server.api.member_controllers import api_member from youngs_server.api.lecture_controllers import api_lecture from youngs_server.api.question_controllers import api_question app.register_blueprint(api_auth) app.register_blueprint(api_member) app.register_blueprint(api_lecture) app.register_blueprint(api_question) return app
def create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) config[config_name].init_app(app) bootstrap.init_app(app) # mail.init_app(app) moment.init_app(app) db.init_app(app) login_manager.init_app(app) admin.init_app(app) # Todo-rezwan follow this guide for auto renewing session # http://stackoverflow.com/questions/19760486/resetting-the-expiration-time-for-a-cookie-in-flask # http://stackoverflow.com/questions/19760486/resetting-the-expiration-time-for-a-cookie-in-flask app.permanent_session_lifetime = timedelta(minutes=60) # adding session time out. working # attach routes and custom error pages here from main import main as main_blueprint app.register_blueprint(main_blueprint) from .auth import auth as auth_blueprint app.register_blueprint(auth_blueprint, url_prefix='/auth') from .admin import admin_panel as admin_blueprint app.register_blueprint(admin_blueprint, url_prefix='/admin') db.app = app db.create_all() return app
def create_app(config_name): app = Flask(__name__) app.config.from_object(app_config[config_name]) app.permanent_session_lifetime = timedelta(minutes=5) init_models() register_blueprints(app) return app
def create_app(config_name): application = Flask(__name__, static_folder='static/', static_url_path=configs[config_name].STATIC_URL_PATH) init_app( application, configs[config_name], bootstrap=bootstrap, data_api_client=data_api_client, feature_flags=feature_flags, login_manager=login_manager ) # Should be incorporated into digitalmarketplace-utils as well csrf.init_app(application) application.permanent_session_lifetime = timedelta(hours=1) from .main import main as main_blueprint from .status import status as status_blueprint application.register_blueprint(status_blueprint, url_prefix='/admin') application.register_blueprint(main_blueprint, url_prefix='/admin') login_manager.login_view = 'main.render_login' main_blueprint.config = application.config.copy() @application.before_request def remove_trailing_slash(): if request.path != '/' and request.path.endswith('/'): return redirect(request.path[:-1], code=301) application.add_template_filter(parse_document_upload_time) return application
def flask(cls, name, config=None, debug=False, **kwargs): template_folder = kwargs.pop('template_folder', tmpl_dir) app = Flask(name, template_folder=template_folder, **kwargs) if config: app.config.from_object(config) app.permanent_session_lifetime = timedelta(minutes=60) app.debug = debug if app.config.get('COUCHDB_DATABASE',None) is None: app.config['COUCHDB_DATABASE'] = name.lower() assert app.secret_key is not None, "flask config does not specify a secret key" return app
def create_app(config_name): app = Flask(__name__) app.config.from_object('config') bootstrap.init_app(app) # moment.init_app(app) db.init_app(app) login_manager.init_app(app) app.permanent_session_lifetime = timedelta(hours=24) from .main import main as main_blueprint app.register_blueprint(main_blueprint) from .auth import auth as auth_blueprint app.register_blueprint(auth_blueprint) return app
def create_app(config_name): application = Flask( __name__, static_folder='static/', static_url_path=configs[config_name].STATIC_URL_PATH ) application.config['NOTIFY_ENVIRONMENT'] = config_name application.config.from_object(configs[config_name]) init_app(application) csrf.init_app(application) @csrf.error_handler def csrf_handler(reason): if 'user_id' not in session: application.logger.info( u'csrf.session_expired: Redirecting user to log in page' ) return application.login_manager.unauthorized() application.logger.info( u'csrf.invalid_token: Aborting request, user_id: {user_id}', extra={'user_id': session['user_id']}) abort(400, reason) login_manager.init_app(application) admin_api_client.init_app(application) proxy_fix.init_app(application) from .main import main as main_blueprint application.permanent_session_lifetime = timedelta(hours=1) application.register_blueprint(main_blueprint, url_prefix='/admin') login_manager.login_view = 'main.render_login' main_blueprint.config = application.config.copy() @application.before_request def remove_trailing_slash(): if request.path != '/' and request.path.endswith('/'): return redirect(request.path[:-1], code=301) application.add_template_filter(datetimeformat) return application
def create_app(): app = Flask(__name__) app.config['SECRET_KEY'] = 'THIS IS JUST A TEST WEBPAGE !' app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://*****:*****@[email protected]/maizi' app.config['BABEL_DEFAULT_LOCALE'] = 'en' app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True from flask.json import JSONEncoder class CustomJSONEncoder(JSONEncoder): """This class adds support for lazy translation texts to Flask's JSON encoder. This is necessary when flashing translated texts.""" def default(self, obj): from speaklater import is_lazy_string if is_lazy_string(obj): try: return unicode(obj) # python 2 except NameError: return str(obj) # python 3 return super(CustomJSONEncoder, self).default(obj) app.json_encoder = CustomJSONEncoder bootstrap.init_app(app) db.init_app(app) login_manager.init_app(app) pagedown.init_app(app) Gravatar(app, size=64) babel.init_app(app) from auth import auth as auth_blueprint from main import main as main_blueprint app.register_blueprint(auth_blueprint) app.register_blueprint(main_blueprint) app.permanent_session_lifetime = timedelta(minutes=5) @app.template_test('current_link') def is_current_link(link): return link == request.path @babel.localeselector def get_locale(): return current_user.locale return app
def create_manager(deed_api_client=make_deed_api_client()): app = Flask(__name__) app.config.from_pyfile('config.py') manager = Manager(app) app.url_map.strict_slashes = False setattr(searchdeed, 'deed_api_client', deed_api_client) app.register_blueprint(health, url_prefix='/health') app.register_blueprint(searchdeed) app.register_blueprint(borrower_landing) app.secret_key = app.config['APP_SECRET_KEY'] app.permanent_session_lifetime = timedelta(minutes=20) return manager
def create_app(config_name): app = Flask(__name__) from .main import main as main_blueprint app.register_blueprint(main_blueprint) app.config.from_object(config[config_name]) app.permanent_session_lifetime = timedelta(minutes=5) config[config_name].init_app(app) bootstrap.init_app(app) mail.init_app(app) moment.init_app(app) db.init_app(app) # 附加路由和自定义的错误页面 return app
def create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) app.permanent_session_lifetime = timedelta(minutes = 10) config[config_name].init_app(app) mail.init_app(app) moment.init_app(app) db.init_app(app) # attach routes and custom error pages here from main import main as main_blueprint app.register_blueprint(main_blueprint) file_handler = RotatingFileHandler('logs/nights_watch.log', 'a', # Append 1 * 1024 * 1024 * 1024, # 10 MB 20) # Max 20 log files #mail_handler = SMTPHandler( # mailhost=(app.config["MAIL_SERVER"], app.config["MAIL_PORT"]), # fromaddr=app.config["MAIL_SENDER"], # toaddrs=app.config["MAIL_TO"], # subject=app.config["MAIL_SUBJECT_PREFIX"]) log_format_file = logging.Formatter('%(asctime)s %(levelname)s: %(message)s \ [at %(pathname)s:%(lineno)d]') #log_format_email = logging.Formatter('%(asctime)s %(levelname)s: %(message)s') file_handler.setFormatter(log_format_file) #mail_handler.setFormatter(log_format_email) app.logger.setLevel(logging.INFO) file_handler.setLevel(logging.INFO) #mail_handler.setLevel(logging.WARNING) app.logger.addHandler(file_handler) #app.logger.addHandler(mail_handler) app.logger.info('application started!!!') return app
def setUp(self): application = Flask(__name__) application.config['TESTING'] = True application.secret_key = 'you will not guess' application.permanent_session_lifetime = timedelta(seconds=1) login_manager.init_app(application) self.application = application with self.application.test_client() as c: with c.session_transaction() as sess: sess['user_id'] = '1' schema_file = open(os.path.join(settings.EQ_SCHEMA_DIRECTORY, "0_star_wars.json")) schema = schema_file.read() # create a parser self.schema_json = json.loads(schema) parser = SchemaParserFactory.create_parser(self.schema_json) self.questionnaire = parser.parse()
def create_app(config_name): application = Flask(__name__, static_folder="static/", static_url_path=configs[config_name].STATIC_URL_PATH) init_app( application, configs[config_name], bootstrap=bootstrap, data_api_client=data_api_client, feature_flags=feature_flags, login_manager=login_manager, ) # Should be incorporated into digitalmarketplace-utils as well csrf.init_app(application) application.permanent_session_lifetime = timedelta(hours=1) from .main import main as main_blueprint from .status import status as status_blueprint application.register_blueprint(status_blueprint, url_prefix="/admin") application.register_blueprint(main_blueprint, url_prefix="/admin") login_manager.login_view = "main.render_login" main_blueprint.config = application.config.copy() @application.before_request def remove_trailing_slash(): if request.path != "/" and request.path.endswith("/"): return redirect(request.path[:-1], code=301) @application.template_filter("timeformat") def timeformat(value): return datetime.strptime(value, formats.DATETIME_FORMAT).strftime(DISPLAY_TIME_FORMAT) @application.template_filter("dateformat") def dateformat(value): return datetime.strptime(value, formats.DATETIME_FORMAT).strftime(DISPLAY_DATE_FORMAT) @application.template_filter("displaydateformat") def display_date_format(value): return value.strftime(DISPLAY_DATE_FORMAT) return application
def create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) config[config_name].init_app(app) db.init_app(app) bootstrap.init_app(app) mail.init_app(app) login_manager.init_app(app) # security setting app.secret_key="youdon'tknwhatIT1s" app.permanent_session_lifetime = datetime.timedelta(minutes=30) # register blueprint from .main import main as main_blueprint app.register_blueprint(main_blueprint) return app
def create_app(config_name): app = Flask(__name__) from .main import main as main_blueprint app.register_blueprint(main_blueprint) from .auth import auth as auth_blueprint app.register_blueprint(auth_blueprint, url_prefix='/auth') app.config.from_object(config[config_name]) app.permanent_session_lifetime = timedelta(minutes=5) config[config_name].init_app(app) bootstrap.init_app(app) mail.init_app(app) moment.init_app(app) db.init_app(app) login_manager.init_app(app) return app
def create_app(db_name=None): app = Flask(__name__) app.config.from_object(config) if db_name: config.MONGO_DATABASE = db_name Admin(app) Engine(app) mongo, db = HapPyMongo(config) app.permanent_session_lifetime = timedelta(hours=2) auth = CloudAuth(app, db) custom_filters = { name: function for name, function in getmembers(template_filters) if isfunction(function) } app.jinja_env.filters.update(custom_filters) app.context_processor(template_functions.utility_processor) @app.before_first_request def logger(): if not app.debug: app.logger.addHandler(logging.StreamHandler()) app.logger.setLevel(logging.INFO) @app.before_request def before_request(): g.db, g.auth = db, auth defaults.application_initialize(db, app) views.ProductsView.register(app) views.MiscView.register(app) views.FeedbackView.register(app) views.GlobalManageView.register(app) if db_name: return app, db else: return app
def create_app(config=config.dev_config, school_name=None): """ The main entry point where the application is created """ # Create the application app = Flask(__name__) # User only logged in for 10 minutes before getting auto logged out app.permanent_session_lifetime = timedelta(seconds=600) # Default configurations app.config.from_object(config) # Configuration overrides app.config.from_pyfile('../application.cfg', silent=True) # In "multi-school" mode, each school is run as a separate app. # And each is run under the root directory (eg. domain.net/school) if school_name is not None: app.config['SCRIPT_NAME'] = '/'+school_name app.config['SCHOOL'] = school_name or app.config['DEFAULT_SCHOOL'] # Register everything register_extensions(app) register_views(app) register_template_filters(app) configure_hooks(app) return app
def create_app(config_name): application = Flask(__name__, static_folder='static/', static_url_path=configs[config_name].STATIC_URL_PATH) init_app( application, configs[config_name], data_api_client=data_api_client, feature_flags=feature_flags, login_manager=login_manager, ) application.permanent_session_lifetime = timedelta(hours=1) from .main import main as main_blueprint from .status import status as status_blueprint application.register_blueprint(status_blueprint, url_prefix='/suppliers') application.register_blueprint(main_blueprint, url_prefix='/suppliers') login_manager.login_view = 'main.render_login' main_blueprint.config = application.config.copy() csrf.init_app(application) @application.before_request def remove_trailing_slash(): if request.path.endswith('/'): return redirect(request.path[:-1], code=301) @application.before_request def refresh_session(): session.permanent = True session.modified = True return application
web_service = Flask(__name__, static_url_path=WEB_SERVICE_CONFIG["static_url_path"], static_folder=WEB_SERVICE_CONFIG["static_files_path"], template_folder=WEB_SERVICE_CONFIG["templates_path"]) socket_service = SocketIO(web_service) web_service.config['DEBUG'] = WEB_SERVICE_CONFIG["debug"] web_service.config['SQLALCHEMY_DATABASE_URI'] = DATABASE_CONFIG[ "connection_string"] web_service.config['SECRET_KEY'] = WEB_SERVICE_CONFIG["security_secret_key"] web_service.config['SECURITY_PASSWORD_HASH'] = WEB_SERVICE_CONFIG[ "security_password_hash"] web_service.config['SECURITY_PASSWORD_SALT'] = WEB_SERVICE_CONFIG[ "security_password_salt"] if WEB_SERVICE_CONFIG["expire_session"]: session.permanent = True web_service.permanent_session_lifetime = timedelta( minutes=WEB_SERVICE_CONFIG["session_timeout_in_minutes"]) web_service.config['SESSION_REFRESH_EACH_REQUEST'] = WEB_SERVICE_CONFIG[ "refresh_session_on_each_request"] # Flask-SQLAlchemy db = SQLAlchemy(web_service) import server.database.models # Do NOT remove this import - it pulls up all models for SQLAlchemy module. db.create_all() # Flask-Security from server.database.models.user.users import Users from server.database.models.user.roles import Roles from server.web.utils import ModifiedLoginForm user_datastore = SQLAlchemySessionUserDatastore(db.session, Users, Roles)
path = os.path.abspath('.') if not os.path.exists('database'): os.mkdir(os.path.join(path, 'database')) static_folder = os.path.join(path, 'static') template_folder = os.path.join(path, 'templates') app = Flask(__name__, template_folder=template_folder, static_folder=static_folder) else: app = Flask(__name__) app.config['SECRET_KEY'] = get_random_bytes(0x20) app.permanent_session_lifetime = timedelta( minutes=SessionConst.SESSION_TTL.value) # Protection against CSRF attack CSRFProtect(app) # databases account_db = Account() profile_db = Profile() # core functions def login_required(func): def wrapper(*args, **kwargs): if not 'logged_in' in session: return redirect(url_for('index')) elif not session['logged_in']:
print(request.cookies) return 'wam' def sea(): name = request.args.get('name') print('name ----> {}'.format(name)) return name class A(object): x = 1 gen = (lambda x: (x for _ in range(10)))(x) if __name__ == '__main__': app.secret_key = '2e3ew8w4r4dod' app.session_cookie_name = 'u300000' from datetime import timedelta # session.permanent = True app.permanent_session_lifetime = timedelta(minutes=10) print(app.url_map) app.run(host='0.0.0.0', debug=True, port=3001, use_reloader=False) # use tornado container run flask app import tornado.wsgi import tornado.httpserver import tornado.ioloop import tornado.web from tornado.wsgi import WSGIContainer container = tornado.wsgi.WSGIContainer(app) server = tornado.httpserver.HTTPServer(container) # server.listen(8000) # tornado.ioloop.IOLoop.instance().start()
import stripe import json import os import uuid from flask import Flask, render_template, jsonify, request, session, send_from_directory from dotenv import load_dotenv, find_dotenv load_dotenv(find_dotenv()) stripe.api_key = os.getenv("STRIPE_SECRET_KEY") app = Flask(__name__) # session secret key app.secret_key = "not so super secret key" # session data to be persisted for 365 days app.permanent_session_lifetime = datetime.timedelta(days=365) @app.route("/") def home(): return render_template("index.html") @app.route("/favicon.ico") def favicon(): return send_from_directory(os.path.join(app.root_path, "static"), "favicon.ico") @app.route("/cart", methods=["GET"]) def get_cart():
import sys from datetime import timedelta from flask import Flask from flask_wtf.csrf import CSRFProtect from config import ProductionConfig from views.lib import Conn import os app = Flask(__name__) app.secret_key = os.environ.get('SECRET_KEY') or os.urandom(64) app.config.from_object(ProductionConfig) csrf = CSRFProtect() csrf.init_app(app) Mongo = Conn.MongoDB(app.config.get('DB'), app.config.get('PORT'), app.config.get('DBNAME'), app.config.get('DBUSERNAME'), app.config.get('DBPASSWORD')) app.permanent_session_lifetime = timedelta(hours=6) page_size = 30 sys.path.append(sys.path[0] + '/vulscan/vuldb/') file_path = os.path.split(os.path.realpath(__file__))[0] + '/../vulscan/vuldb/'
from helpers.database import * from helpers.reader import read from obs.obsws import obs_connector # This function is not yet ready. # from helpers.pdf import render # ########################################################### # # # App Config # # # ########################################################### # app = Flask(__name__) app.secret_key = b'aFvAUaVyaxW7ENbT4S2HDyQW3n0EEGnJYtehL9kG29LUaYWu56g4-KE5aZl3ck4xJkXEku4PoduaYK3k' app.config["SECRET_KEY"] = 'aFvAUaVyaxW7ENbT4S2HDyQW3n0EEGnJYtehL9kG29LUaYWu56g4-KE5aZl3ck4xJkXEku4PoduaYK3k' # Sets the secret key, used for signing sessions, and making sure they are not tampered with. app.permanent_session_lifetime = timedelta(days=365) # max time the session is stored. app.config['PERMANENT_SESSION_LIFETIME'] = timedelta(days=365) auth_key = 'Yv326fIgqRoZocoYo5jjU0OAR_rJe6LpzCkbAr6F' # End Config app.debug = False for_testing_purpose = False # ########################################################### # # # Main application # # # ########################################################### # @app.route('/test') def this_testing():
params = urllib.parse.quote_plus( "Driver={ODBC Driver 17 for SQL Server};Server=tcp:apiservice.database.windows.net,1433;Database=ApiService;Uid=apiserviceAdmin;Pwd=BenTeo18062416;Encrypt=yes;TrustServerCertificate=no;Connection Timeout=30;" ) app = Flask(__name__) app.config[ 'SQLALCHEMY_DATABASE_URI'] = "mssql+pyodbc:///?odbc_connect=%s" % params app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False db.init_app(app) FlaskUUID(app) Bootstrap(app) app.config['SECRET_KEY'] = 'EdrMedeso2020' app.permanent_session_lifetime = datetime.timedelta(minutes=5) def token_required(f): @wraps(f) def wrapper(*args, **kwargs): token = request.args.get('token') try: jwt.decode(token, app.config['SECRET_KEY']) return f(*args, **kwargs) except: return jsonify({'error': 'Need a valid token to view this page'}), 401 return wrapper
limiter = Limiter(app, global_limits=['20 per minute']) # Load configuration from the environment secret_key = os.environ.get('SECRET_KEY') signing_key = os.environ.get('SIGNING_KEY') if not secret_key: raise Exception("SECRET_KEY not set") if not signing_key: raise Exception("SIGNING_KEY not set") app.config['SERVER_NAME'] = os.environ.get('SERVER_NAME') app.config['SECRET_KEY'] = secret_key app.config['BOT_NAME'] = 'edsgar' app.config['SESSION_LIFETIME_DAYS'] = 90 # Used in a template tokenizer = Tokenizer(signing_key) app.permanent_session_lifetime = timedelta( days=app.config['SESSION_LIFETIME_DAYS']) @app.before_request def before_request(): session.permanent = True # This is needed because of a stupid, old bug in Flask @app.errorhandler(400) @app.errorhandler(401) @app.errorhandler(404) @app.errorhandler(429) @app.errorhandler(500) @app.errorhandler(Exception) def show_error_page(error):
# -*- coding: utf-8 -*- from flask import Flask,redirect,url_for,render_template,session,request import os import threading import subprocess import sys from datetime import timedelta app = Flask(__name__) app.secret_key = os.urandom(24) #session.permanent = True app.permanent_session_lifetime = timedelta(minutes=30) #消息循环队列初始化 cache_msg=['']*30 cache_msg_num=0 #配置初始化 try: import xml.etree.cElementTree as ET except ImportError: import xml.etree.ElementTree as ET configxml = ET.ElementTree(file='rmcsconfig.xml') mcargs = configxml.find('mcargs').text javaexe = configxml.find('javaexe').text expires = configxml.find('expires').text #启动进程 p = subprocess.Popen(mcargs, executable=javaexe, universal_newlines=True, stdin = subprocess.PIPE, stdout = subprocess.PIPE, stderr = subprocess.PIPE, shell = False)
from flask import got_request_exception from celery import Celery import __builtin__ # Argument parser arg_parser = argparse.ArgumentParser() arg_parser.add_argument("-c") args = arg_parser.parse_args() # Config cfg = read_config_file(args.c) # Create App app = Flask(__name__, static_url_path='') app.secret_key = SECRET_KEY app.permanent_session_lifetime = SESSION_DURATION documentor = Autodoc(app) app.config['MONGODB_SETTINGS'] = { 'db': cfg["database"]["name"], 'host': cfg["database"]["host"], 'port': cfg["database"]["port"] } # Celery app.config['CELERY_BROKER_URL'] = cfg['redis']['url'] app.config['CELERY_RESULT_BACKEND'] = cfg['redis']['url'] def make_celery(app): celery = Celery(app.import_name, broker=app.config['CELERY_BROKER_URL']) celery.conf.update(app.config) TaskBase = celery.Task
# log.setLevel(logging.DEBUG) # log.addHandler(handler) app.cache = redis.StrictRedis(**app.config.get('REDIS_CONFIG')) app.cache.set("saDir", SA_DIR) app.cache.set("uid_track", 1) app.cache.set("session_data", {}) app.config['UPLOAD_FOLDER'] = os.path.dirname(os.path.abspath(__file__)) + SA_DIR app.config['STATIC_FOLDER'] = os.path.dirname(os.path.abspath(__file__)) + '/static' # app.session_interface = RedisSessionInterface(app.cache, key_prefix='SESSION') app.session_interface = RedisSessionInterface(app.cache, key_prefix='SESSION', use_signer=True, permanent=False) app.permanent_session_lifetime = datetime.timedelta(hours=1) try: os.mkdir(SA_DIR) except Exception as E: app.logger.info("[%s] mkdir() -- [%s] : %s" % \ (ctime(), SA_DIR, E)) # def reset_cache(sessionID): # session_data = { # "false_upload": True, # # "stdOut": '', # # "stdOut_conv": '' # } # app.cache.hmset("session_data:%s" % sessionID, session_data)
return SECRETE_KEY VARIFICATION_CODE = {"email": "nan", "code": generate_key()} def encrpt(password): passwd = password.encode() salt = bcrypt.gensalt() hashed = bcrypt.hashpw(passwd, salt) return hashed app = Flask(__name__) app.secret_key = 'random string' app.permanent_session_lifetime = timedelta( hours=5) #save section for x mins/hours #index_page @app.route('/') @app.route('/home') def index(): global PREVIOUS PREVIOUS = "team" return render_template('index.html') @app.route("/check_otp", methods=['GET', 'POST']) def check_otp(): if request.method == 'POST':
#处理utf8编码,统一python2和python3的编码,两个版本测试通过 defaultencoding = 'utf-8' if sys.getdefaultencoding() != defaultencoding: reload(sys) sys.setdefaultencoding(defaultencoding) app = Flask(project_name) app.config['SECRET_KEY'] = project_secret_key app.debug = project_debug # app.config['DEBUG'] = True toolbar = DebugToolbarExtension(app) #session过期时间10分钟 app.permanent_session_lifetime = datetime.timedelta(seconds=project_session_timeout) #flask返回结果中支持中文 app.config['JSON_AS_ASCII'] = False if os.path.exists('/var/log/flaskuserpwd.txt'): # print('文件存在,不需要再创建用户名和密码') pass else: print('创建用户名和密码') username = ''.join(random.choice(string.ascii_lowercase) for _ in range(8)) password = ''.join(random.choice(string.ascii_letters) for i in range(14)) password = password[:7] + '#' + password[7:]
from datetime import timedelta from flask import Flask, redirect, url_for, render_template from mural import bp_home, bp_avisos, bp_noticias, bp_anuncios, bp_banner, bp_universidade, bp_usuarios, \ bp_logs from mural.mod_base.auth import SESSION_LIMIT, Auth from mural.mod_base.base_model import error_404_response from mural.mod_universidade import Universidade app = Flask(__name__, template_folder='mural/templates', static_url_path='/static', static_folder='mural/static') app.secret_key = b'_8#y2P"g8l1x\n\xec]/' app.permanent_session_lifetime = timedelta(minutes=SESSION_LIMIT) @app.context_processor def inject_auth(): universidade = Universidade() universidade.select(1) return dict(auth=Auth(), universidade=universidade) @app.errorhandler(404) def not_found(e): return error_404_response() app.register_blueprint(bp_home)
from config import Config from redis import Redis from datetime import timedelta import rq app = Flask(__name__) app.config.from_object(Config) db = SQLAlchemy(app) migrate = Migrate(app, db) bootstrap = Bootstrap(app) moment = Moment(app) login = LoginManager(app) login.login_view = 'login' login.login_message = 'Please log in to access this service.' login.login_message_category = 'info' app.permanent_session_lifetime = timedelta( minutes=app.config['SESSION_LIFETIME_MINUTES']) app.redis = Redis.from_url(app.config['REDIS_URL']) app.task_queue = rq.Queue('roulette-tasks', connection=app.redis) from app import routes, models, errors import logging from logging.handlers import RotatingFileHandler import os def cleanup(): pass def startup():
from flask import Flask, redirect, flash, render_template, jsonify, session, url_for, request from datetime import timedelta from flask_sqlalchemy import SQLAlchemy from CLIENT import Client # ----global variables---- LenText = 3 LenPwd = 1 messages = [] clients = {} username = "" # -----creating heed----- heed = Flask(__name__) heed.secret_key = "heed" heed.permanent_session_lifetime = timedelta(minutes=30) # -----database----- heed.config["SQLALCHEMY_DATABASE_URI"] = 'sqlite:///chat.sqlite3' heed.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False DataBase = SQLAlchemy(heed) # ----- class to initialize and save in DataBase ----- class Users(DataBase.Model): _id = DataBase.Column("id", DataBase.Integer, primary_key=True) name = DataBase.Column(DataBase.String(100)) username = DataBase.Column(DataBase.String(100)) password = DataBase.Column(DataBase.String(100)) email = DataBase.Column(DataBase.String(100)) def __init__(self, name, username, password, email): self.name = name self.username = username self.password = password
from flask import g, current_app DATABASE = './db.sqlite' def get_db(): db = getattr(g, '_database', None) if db is None: db = g._database = sqlite3.connect(DATABASE) return db def parse_column_headers(res): return [r[0] for r in res.description] # ========== for sqlite ========== app=Flask(__name__) # 透過__name__確定app檔案位置,方便找到其他構成app的檔案 app.secret_key='hello' # session的key可隨意設定字串 app.permanent_session_lifetime=timedelta(minutes=100) #設定session能夠被儲存在server上的時間 # conn=cx_Oracle.connect("Group6/[email protected]:1521/Group6",encoding="UTF-8") # conn=cx_Oracle.connect('Group6', 'Group666', "140.117.69.58:1521/Group6",encoding="UTF-8") # tns=cx_Oracle.makedsn('140.117.69.58',1521,'orcl') # conn=cx_Oracle.connect('Group6','Group666',tns) # conn = cx_Oracle.connect('Group6/[email protected]/Group6') # ========== for sqlite ========== @app.teardown_appcontext def close_connection(exception): db = getattr(g, '_database', None) if db is not None: db.close() # ========== for sqlite ==========
#!/usr/bin/env python # -*- coding: utf-8 -*- # @Author: cc # @Date :2019-04-12 import os from datetime import timedelta from flask import Flask import pymysql pymysql.install_as_MySQLdb() app = Flask(__name__) app.secret_key = 'zhBRxENODp7PqTqWNO7lj7wvgwPEgc' prefix = 'sqlite:////' app.config['SQLALCHEMY_DATABASE_URI'] = os.getenv( 'DATABASE_URL', prefix + os.path.join(app.root_path, 'ibook.db.sqlite')) app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False app.permanent_session_lifetime = timedelta(seconds=60) from ibook import views, models
#coding: utf8 import os from datetime import timedelta from flask import Flask, session, render_template, request, redirect import urllib app = Flask(__name__) app.secret_key = os.urandom(24) app.permanent_session_lifetime = timedelta(seconds=30 * 24 * 60 * 60) @app.route('/login') def login(): session.permanent = True referer = request.args.get('referer', None) if referer is not None: referer = referer.strip() if 'name' in session: if referer is not None: return redirect(referer + '?ticket=' + _makeTicket()) return render_template('login.html', **dict(referer=referer)) @app.route('/dologin') def doLogin(): '''这里其实忽略了判断是否登录的流程''' session.permanent = True referer = request.args.get('referer', None) if referer is not None: referer = urllib.unquote(referer.strip())
productname = brandinfo["Vendor"] + " " + brandinfo["ProductName"] lc = brandinfo["License"] print(productname) file.close() with open("lang\\en-US.json", encoding="utf-8") as file: lang = json.load(file) file.close() with open(lc, encoding="utf-8") as file: license1 = file.readlines() file.close() app = Flask(__name__) app.register_blueprint(apimodule, url_prefix="/api") app.register_blueprint(oobeui, url_prefix="/oobe") app.secret_key = "ThEMoSTSeCuRePassWORdINThEWorLD" year = datetime.now().strftime('%Y') app.permanent_session_lifetime = timedelta(days=10) build = "0110" branch = "centralbeta1_5.210906" fullbuildname = build + "." + branch hasher = Hashing() @app.route('/license') def license(): return render_template("nano/license.html", productname=productname, year=year, license=license1) def gensession():
from flask import Flask, escape, request, render_template, url_for, flash, redirect, session, json from flask_restful import Api, Resource, reqparse from flask_sqlalchemy import SQLAlchemy from datetime import datetime, timedelta import hashlib app = Flask(__name__) app.config["SECRET_KEY"] = "6810527e5f4636beca705e70625e96bc" app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///database.sqlite3" app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False app.permanent_session_lifetime = timedelta(weeks=52) api = Api(app) db = SQLAlchemy(app) ########################################################################### #FUNCTIONS ########################################################################### def hash_password(password): return hashlib.sha256(password.encode('utf-8')).hexdigest() def check_login(): try: if User.query.filter_by(name=session["name"]).filter_by( password=session["password"]).first(): return True return False except Exception: return False
import mysql.connector from flask import (Flask, flash, redirect, render_template, request, session, url_for) import datetime from Helper import DataSizeRange from Helper import Generator as Gen from Helper import Validator as Val app = Flask(__name__) app.debug = True app.secret_key = "12345" # use a better secret_key app.templates_auto_reload = True app.cache_type = "null" app.permanent_session_lifetime = datetime.timedelta(hours=1) DATABASE_NAME = "pill_code_db" # mysql db_name USERNAME = "******" HOST = "localhost" PASSWORD = "" # function to read the article content and title def read_title_and_post(article_id): try: id = article_id db_conn = mysql.connector.connect(host=HOST, user=USERNAME,
def create_app(): app = Flask(__name__) # 初始化配置 app.config.from_object(config) config.init_app(app) config_logging(app) # db配置 db.init_app(app) # mongo mongo.init_app(app) # 控制器配置 from controllers import default_blueprints for blueprint in default_blueprints: app.register_blueprint(blueprint) # 开启 CsrfProtect 模块 csrf.init_app(app) @login_manager.user_loader def load_user(user_id): from models import User user = db.session.query(User).get(int(user_id)) user.nickname = user.to_dict()['nickname'] return user login_manager.init_app(app) # cookie有效期 app.permanent_session_lifetime = datetime.timedelta(minutes=24 * 60) login_manager.remember_cookie_duration = datetime.timedelta(days=1) # 访问静态资源 def public_file(filename): return send_from_directory(app.config.get("UPLOAD_FOLDER"), filename) app.add_url_rule("/public/<filename>", "public_file", build_only=True) app.wsgi_app = SharedDataMiddleware( app.wsgi_app, {"/public": app.config.get("UPLOAD_FOLDER")}, cache=False # tips: http://stackoverflow.com/questions/11515804/zombie-shareddatamiddleware-on-python-heroku ) # favicon.ico @app.route('/favicon.ico') def favicon(): return send_from_directory(app.static_folder, 'favicon.ico', mimetype='image/vnd.microsoft.icon') # Robots @app.route('/robots.txt') def robots(): return send_from_directory(app.static_folder, 'robots.txt') # sitemap.xml @app.route('/sitemap<name>') def sitemap(name): return send_from_directory(app.static_folder, 'sitemap%s' % name) # 过滤器处理 configure_template_filters(app) # 错误处理 configure_error_handlers(app) return app
# Website by Ben Grudzien, refer to techwithtim from flask import Flask, redirect, url_for, render_template, request, session, flash # Allows for redirects, render function allows for external html # Request determines GET or POST from datetime import timedelta from flask_sqlalchemy import SQLAlchemy app = Flask(__name__) # Creating flask instance app.secret_key = "password" # could be any string lol, good to be complex (needed for session) app.config[ 'SQLALCHEMY_DATABASE_URI'] = 'sqlite:///users.sqlite3' # User is table name app.config["SQLALCHEMY_TRACK_MODIFCICATIONS"] = False # gets rid of errors app.permanent_session_lifetime = timedelta( minutes=5) # Store log in session data from 5 days/mins db = SQLAlchemy(app) # Avoid quereies and writing this in python class users(db.Model): _id = db.Column("id", db.Integer, primary_key=True) name = db.Column(db.String(100)) email = db.Column( db.String(100)) # Adding string column to database called email def __init__(self, name, email): self.name = name self.email = email
scheme = environ.get('HTTP_X_FORWARDED_PROTO') if scheme: environ['wsgi.url_scheme'] = scheme return self.app(environ, start_response) app = Flask(__name__) app.config['DEBUG'] = False app.config['TEMPLATES_AUTO_RELOAD'] = True app.config['MAX_CONTENT_LENGTH'] = 32 * 1024 * 1024 # 32 MB upload file max app.config['UPLOAD_FOLDER'] = "/tmp/flask_uploads" app.config['SESSION_PERMANENT'] = True app.config["SESSION_COOKIE_NAME"] = "mynode_session_id" app.secret_key = get_flask_secret_key() timeout_days, timeout_hours = get_flask_session_timeout() app.permanent_session_lifetime = timedelta(days=timeout_days, hours=timeout_hours) app.register_error_handler(LoginError, handle_login_exception) app.wsgi_app = ReverseProxied(app.wsgi_app) my_logger = logging.getLogger('FlaskLogger') my_logger.setLevel(logging.DEBUG) handler = logging.handlers.RotatingFileHandler(filename='/var/log/flask', maxBytes=2000000, backupCount=2) my_logger.addHandler(handler) app.logger.addHandler(my_logger) app.logger.setLevel(logging.INFO) app.register_blueprint(mynode_bitcoin) app.register_blueprint(mynode_lnd)
from datetime import timedelta, datetime from random import random from urllib.parse import urlparse, quote from functools import wraps import env_config as config from fingerprint import FingerprintAgent, FingerprintRecorder, FingerprintHelper from tracking import TrackingRecorder from entropy_helper import EntropyHelper from util import number_format, detect_browser_and_platform, get_tool_recommendation from db import Db app = Flask(__name__) app.secret_key = config.secret_key app.debug = config.debug app.permanent_session_lifetime = timedelta(days=config.epoch_days) app.config.update( USE_MATOMO=config.use_matomo, MATOMO_URL=config.matomo_url, MATOMO_SITE_ID=config.matomo_site_id, ) if config.sentry_dsn: sentry_sdk.init(config.sentry_dsn, integrations=[FlaskIntegration()]) def read_keyfile(): global key with open( config.keyfile, 'rb',
#!/usr/bin/env python # encoding: utf-8 ''' @author: chenc @time: 2018/10/18 1:41 PM @desc: ''' # from flask import Blueprint, Flask # # # app = Blueprint('app', __name__,) # app = Flask(__name__) # # from app.user import views from flask import Flask import pymysql from app import config from app.echoImg.exts import db pymysql.install_as_MySQLdb() app = Flask(__name__) # app.secret_key = "123asdzxc" app.permanent_session_lifetime=60*60*2 app.config.from_object(config) db.init_app(app)
url_for) from os import getenv import logging from views import index, load, generate import src.user as user load_dotenv() application = Flask(__name__) application.logger.handlers = [] application.logger.addHandler(logging.StreamHandler()) application.secret_key = getenv('AUTH_KEY') session_timeout = int(getenv('SESSION_TIMEOUT_IN_MINUTES')) application.permanent_session_lifetime = timedelta(minutes=session_timeout) user.initialize_users() Database.initialize() modules = [index, load, generate] for module in modules: application.register_blueprint(module.routes) def authorize(username, password): if not user.is_valid_login(username, password): return False session.permanent = True session['username'] = username return True
#!/usr/bin/python #-*- coding: utf-8 -*- from flask import Flask, jsonify, redirect, url_for, request from datetime import timedelta import json import auth, config import re import vcl app = Flask(import_name=__name__, static_folder='../static') app.secret_key = config.secret_key app.permanent_session_lifetime = timedelta(minutes=config.token_live_time) auth = auth.ApiAuth() @app.before_request def before_request(): if vcl.config.is_dev == False: url = str(request.url).replace(request.host_url, '') is_api = True if re.match(r'^api/', url) else False if is_api: auth.update_session_tbl(); @app.route('/') @auth.login_required def index(): return redirect(url_for('static', filename='switch/index.html')) @app.route('/api/token/', methods=['POST'])
""" app.config['MAIL_SERVER'] = "" app.config['MAIL_PORT'] = "" app.config['MAIL_USE_TLS'] = True app.config['MAIL_USERNAME'] = '******' app.config['MAIL_PASSWORD'] = '******' app.config['SQLALCHEMY_DATABASE_URI'] =\ 'sqlite:///' + os.path.join (basedir, 'data.sqlite') #app.config['SQLALCHEMY_DATABASE_URI'] = os.environ['DATABASE_URL'] #uncomment this line if you want to use Heroku, comment instead the one before it app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True app.config['UPLOAD_FOLDER'] = './static/balls' app.permanent_session_lifetime = timedelta(seconds=60) app.config['SECRET_KEY'] = 'veryhard2guess' #be more original FTP_USER = '******' FTP_PASS = '******' FTP_HOST = 'ftp.ftp.com' #again, environmental variables are preferred manager = Manager(app) bootstrap = Bootstrap(app) db = SQLAlchemy(app) mail = Mail(app) db.drop_all() login_manager = LoginManager()
# encoding: utf-8 from flask import Flask, request, render_template, redirect, session, flash from Log_Analysis import GetTopN from functools import wraps import userdb as user import datetime from userdb import user_delete, change_user_password, get_accesslogs app = Flask(__name__) app.secret_key = '13123dfasdf' # 设置session有效期是600秒 app.permanent_session_lifetime = datetime.timedelta(seconds=10 * 60) # 登陆验证装饰器 def login_required(func): @wraps(func) def inner(*args, **kwargs): if not session: return redirect('/login/') ret = func(*args, **kwargs) return ret return inner @app.route('/') @login_required def hello_world(): title = '51Reboot'
import sys from datetime import timedelta from flask import Flask from Config import ProductionConfig from views.lib import Conn import os app = Flask(__name__) app.secret_key = os.environ.get('SECRET_KEY') or os.urandom(64) app.config.from_object(ProductionConfig) Mongo = Conn.MongoDB(app.config.get('DB'), app.config.get('PORT'), app.config.get('DBNAME'), app.config.get('DBUSERNAME'), app.config.get('DBPASSWORD')) app.permanent_session_lifetime = timedelta(hours=6) page_size = 60 sys.path.append(sys.path[0] + '/vulscan/vuldb/') file_path = os.path.split(os.path.realpath(__file__))[0] + '/../vulscan/vuldb/'
if not os.path.exists(LOG_PATH): os.makedirs(LOG_PATH) handler = RotatingFileHandler(LOG_PATH + '/debug.log', maxBytes=10000, backupCount=1) handler.setFormatter( logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")) handler.setLevel(logging.INFO) app.logger.addHandler(handler) #### initial logger #### #### initial sesion #### from datetime import timedelta app.config['SECRET_KEY'] = 'random' app.permanent_session_lifetime = timedelta(seconds=60 * 60 * 10) # session expire time #### initial sesion #### #### initial database #### app.config.from_pyfile('config/database.cfg') db.init_app(app) #### initial database #### #### router #### from werkzeug.routing import Rule urlpatterns = { Rule('/', endpoint='index'), } for rule in urlpatterns:
#"moron", "idiot", "fool" #] # The ideal tsundere greeting is cold and hostile while betraying a # lingering sense of affection. Constantly search for it. # Set up Flask app app = Flask(__name__) # Database URL, or sqlite in-memory database app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get('DATABASE_URL') # Secret key (for sessions/cookies) app.secret_key = os.environ.get('SECRET_KEY') or 'yolodesu' # Sessions last for 100 years app.permanent_session_lifetime = timedelta(days=36500) # Import the rest of the tsundiary stuff from tsundiary.views import * from tsundiary.models import User, db from tsundiary.utils import their_date import tsundiary.jinja_env migrate = Migrate(app, db) manager = Manager(app) manager.add_command('db', MigrateCommand) ############ # App funcs @app.before_request
from flask import Flask, redirect, url_for, render_template, request, session, flash from datetime import timedelta app = Flask(__name__) app.secret_key = "Your Mom Ugly" app.permanent_session_lifetime = timedelta(days=5) @app.route('/') def home(): return render_template('home.html') @app.route('/login', methods=['GET', 'POST']) def login(): error = None if request.method == 'POST': if request.form['username'] != 'admin' or request.form[ 'password'] != 'admin': error = 'Invalid Credentials. Please try again.' else: session['logged_in'] = True return redirect(url_for('welcome')) return render_template('login.html', error=error) @app.route("/logout") def logout(): session.pop('logged_in', None) return redirect(url_for("login")) @app.route("/admin") def admin(): return render_template('admin.html')
tree['children'].append(dict(name=fn.replace( os.getcwd() + os.path.sep, ""))) return tree def d2d_close_instance(uid): while True: try: if d2d_instances[uid]['alive'] == 0: # clean up the global dicts, deletes the instances del(d2d_instances[uid]) break d2d_instances[uid]['alive'] = 0 time.sleep(SESSION_LIFETIME) except: print('Unable to shutdown thread ' + str(uid)) break if __name__ == "__main__": app.secret_key = os.urandom(24) app.permanent_session_lifetime = SESSION_LIFETIME app.debug = DEBUG app.json_encoder = plotly.utils.PlotlyJSONEncoder app.run(threaded=True, host="127.0.0.1", port=int("5000") )
# db = db(mySqluser, mySqlpasswd) # print(db.insert("users", "email, passwd, username", "'*****@*****.**', 'joe', 'joe'")) site = Flask(__name__) site.register_blueprint(home) site.register_blueprint(login) site.register_blueprint(user) site.register_blueprint(logout) site.register_blueprint(signup) site.register_blueprint(upload) site.register_blueprint(voter) with open("creds.json") as credsFile: creds = json.load(credsFile) key = creds["key"] site.secret_key = key site.permanent_session_lifetime = timedelta(days=7) site.config['UPLOAD_FOLDER'] = "static\\uploads" UPLOADED_FILES_DEST = "static\\uploads" UPLOADS_DEFAULT_DEST = "static\\uploads" # # fikse sesion # lage sign up / login # sette opp db mysql eller sqlalchemy ? if __name__ == "__main__": site.run(debug=True)