def __init__(self, shutdown_handler, host='localhost', port=5000, ssl=False): csp = { 'default-src': ['\'self\'', 'localhost'], 'style-src': [ '\'self\'', 'use.fontawesome.com', 'fonts.googleapis.com', 'fonts.gstatic.com', 'http://cdn.datatables.net/1.10.16/css/jquery.dataTables.min.css', 'https://cdnjs.cloudflare.com/ajax/libs/jvectormap/2.0.4/jquery-jvectormap.css', 'http://cdn.jsdelivr.net/chartist.js/latest/chartist.min.css', '\'unsafe-inline\'' ], 'font-src': [ '\'self\'', 'use.fontawesome.com', 'fonts.googleapis.com', 'fonts.gstatic.com', '\'unsafe-inline\'' ], 'img-src': [ '\'self\'', 'data:', 'use.fontawesome.com', 'fonts.googleapis.com', 'fonts.gstatic.com' ], 'script-src': [ '\'self\'', '\'unsafe-inline\'', 'http://cdn.jsdelivr.net/chartist.js/latest/chartist.min.js' ], } if FROZEN: Talisman(_app, force_https=ssl, content_security_policy=csp) else: from flask_cors import CORS CORS(_app) # # otp = OTP() # otp.init_app(_app) flask_compress.Compress(_app) self._shutdown_handler = shutdown_handler self._host = host self._port = int(port) self._use_ssl = ssl self._certfile_path = APP_DIR / 'lib' / 'liquitrader.crt' self._keyfile_path = APP_DIR / 'lib' / 'liquitrader.key' self._jwt = None # Set constants for WSGIServer WSGIServer.version = 'LiquiTrader/2.0' self._wsgi_server = None
def _dostart(self): app = flask.Flask(self.id, static_folder=self.path, static_url_path=self.prefix) flask_compress.Compress(app) # app.run(host=self.listen, port=self.port) @app.route('/') def index(): return flask.send_from_directory(self.path, 'index.html') # svr = wsgiserver.CherryPyWSGIServer((self.listen, self.port), app) # svr.start() svr = gevent.pywsgi.WSGIServer((self.listen, self.port), app) svr.serve_forever() def cbstop(sig, frame): svr.stop() quit(0) signal.signal(signal.SIGINT, cbstop) signal.signal(signal.SIGTERM, cbstop) signal.signal(signal.SIGHUP, cbstop)
'css/font-awesome.min.css', 'css/datatables.min.css', 'css/table-styling.css', filters='cssmin', output='gen/basic_table.css'), "basic_table_js": flask_assets.Bundle('js/jquery-3.2.1.min.js', 'js/datatables.min.js', 'js/appUtil.js', output='gen/basic_table.js') } assets = flask_assets.Environment(app) assets.register(bundles) # views will be sent as gzip encoded flask_compress.Compress(app) # Flask-login stuff login_manager = flask_login.LoginManager() login_manager.init_app(app) login_manager.login_view = 'splash' # Websockets sockets = Sockets(app) @login_manager.user_loader def load_user(user_id): user = Users.get(user_id) return user
subtitle = 'http://youtu.be/' + subtitle song2['subtitle'] = subtitle elif song['network']=='dlna': song2['subtitle'] = song['location'] # try: # song2['subtitle'] = "DLNA://"+song['server']['name'] # except: # song2['subtitle'] = '' song2['playlist_uuid']=song['playlist_uuid'] return song2 """flask start""" fapp = flask.Flask(__name__, static_folder=os.path.join(settings.programDir, 'html/static'), template_folder=os.path.join(settings.programDir, 'html/template')) flask_compress.Compress(fapp) @fapp.route("/") def homePage(): return flask.render_template('index.html') @fapp.route("/title") def titleSearch1(): return flask.render_template('titleSearch.html', json_tracks=titleSearchApi()) @fapp.route("/api/title") def titleSearchApi(): rows = dbconn.execute("select * from song where [index]!=0 order by title COLLATE NOCASE") tracks = [extractSingers(dict(r)) for r in rows]
from flask import Flask import flask_compress from flask_cors import CORS # import project files from Scripts.truckbook_main import app_main from Scripts.Utility import utils # Declaring Apps: app_wsgi = Flask(__name__) app_wsgi.config['SECRET_KEY'] = 'thisisthesecretkey' # Compressing all response: flask_compress.Compress(app_wsgi) # Connecting all services via blueprint app_wsgi.register_blueprint(app_main) CORS(app_wsgi, resources={r'/*': {'origin': '*'}}) if __name__ == "__main__": app_wsgi.run(host=utils.configuration["settings"]["ip"], port=utils.configuration["settings"]["port"], debug=True, threaded=True, use_reloader=False)
def serve(cls, game, host='', port=5000, compression=False, language=GameLanguage.LITTLEPY, avg_game_count=10, multiplayer_scoring_interval=20, num_of_threads=None, game_data_path="temp_game", avg_game_func=average, debug=False, reuse_addr=None): cls.game = game cls.host = host cls.port = port cls.compression = compression cls.language = language cls.avg_game_count = avg_game_count cls._avg_game_func = avg_game_func cls.gamedb = GameDB(game_data_path) # setup anonymous school with an anonymous user if not cls.gamedb.is_school_token(ANONYMOUS_SCHOOL): cls.gamedb.add_new_school(_token=ANONYMOUS_SCHOOL) if not cls.gamedb.is_user_token(ANONYMOUS_USER): cls.gamedb.get_new_token(ANONYMOUS_SCHOOL, _token=ANONYMOUS_USER) if not cls.gamedb.is_comp_token(ANONYMOUS_COMP): cls.gamedb.add_new_competition(_token=ANONYMOUS_COMP) print("Building www cache...") cls.gamedb.www_cache.safe_replace_cache( os.path.join(os.path.split(__file__)[0], "www")) if issubclass(game, GridGame): cls.charset = cls.__copy_in_charset(game.CHAR_SET) cls.app = flask.Flask( __name__.split('.')[0], static_url_path='', static_folder=cls.gamedb.www_cache.static_dir, template_folder=cls.gamedb.www_cache.template_dir, root_path=cls.gamedb.www_cache.root_dir) @cls.app.template_filter('markdown') def markdown_filter(data): from flask import Markup from markdown import markdown return Markup(markdown(data)) if cls.compression: # BUUT WHAT ABOUT BREACH ATTACKS import flask_compress flask_compress.Compress(cls.app) cls.register(cls.app) cls.__load_language() print("Starting server at {}:{}".format(cls.host, cls.port)) if cls.game.MULTIPLAYER and multiplayer_scoring_interval >= 0: if debug: print("Starting scoring process...") scoring_process = RollingMultiplayerCompRunner( multiplayer_scoring_interval, cls.gamedb, cls.game, cls.compiler, debug=debug) # scoring_process = MultiplayerCompRunner(multiplayer_scoring_interval, cls.gamedb, cls.game, cls.compiler, debug=debug) scoring_process.start() if debug: print("Debug Enabled.") cls.app.run(cls.host, cls.port) else: from gevent.server import _tcp_listener from gevent.pywsgi import WSGIServer listener = _tcp_listener((cls.host, cls.port), reuse_addr=reuse_addr) def serve_forever(listener): try: WSGIServer(listener, cls.app).serve_forever() except KeyboardInterrupt: pass if num_of_threads is None: num_of_threads = multiprocessing.cpu_count() for i in range(num_of_threads): Process(target=serve_forever, args=(listener, )).start() serve_forever(listener) print("Dying...") if cls.game.MULTIPLAYER: scoring_process.stop() print("All good :)")
DEBUG_FLAG = True app = flask.Flask(__name__) app.config.from_object(__name__) app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///tickets.db" app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False app.config[ "SECRET_KEY"] = "e135a5c2766b796fcbf286269fd59de11fa47e663230604252f68bbbe4dc132b" app.config["SEND_FILE_MAX_AGE_DEFAULT"] = 604800 with app.app_context(): models.db.init_app(app) # Setup Flask-Compress. compress = flask_compress.Compress() compress.init_app(app) # Setup Flask-Admin and add our views. admin = flask_admin.Admin(app, name="Ticket Administration", template_mode="bootstrap3") admin.add_view( flask_admin.contrib.sqla.ModelView(models.Users, models.db.session)) admin.add_view( flask_admin.contrib.sqla.ModelView(models.Tickets, models.db.session)) admin.add_view( flask_admin.contrib.sqla.ModelView(models.Comments, models.db.session)) admin.add_view( flask_admin.contrib.sqla.ModelView(models.Files, models.db.session)) admin.add_view(
""" Imports all necessary packages """ # Importing App level modules from flask import Flask import flask_compress from flask_cors import CORS from Scripts.xfactor_main import x_factor_app_main from Scripts.Utility import utils # Declaring App: flasked_app = Flask(__name__) # Compressing all response flask_compress.Compress(flasked_app) # Connecting all services flasked_app.register_blueprint(x_factor_app_main) CORS(flasked_app, resources={r"/*": {"origins": "*"}}) if __name__ == "__main__": flasked_app.run(host=utils.configuration["settings"]["ip"], port=utils.configuration["settings"]["port"], debug=True, threaded=True, use_reloader=False)
import flask_bootstrap as bt import flask_compress as cmp from flask import Flask, render_template, redirect, url_for, request from database import (createDB, getSearchedArticles, getSearchedTweets, getGeneratedTweet, getGeneratedArticle, tech_tweets, tech_articles) app = Flask(__name__) cmp.Compress(app) app.secret_key = b"SECRET_KEY" bt.Bootstrap(app) @app.route("/") def start(): return redirect(url_for("index")) # if it isn't already on index it loads onto index page @app.route("/index", methods=["POST", "GET"]) def index(): if request.method == "POST": if request.get("new_article") == "Generate new Article": # if generate new article button is pressed return redirect(url_for("index")) # reloads page because it each time it happens a random article is chosen if request.get("new_tweet") == "Generate New Tweet": return redirect(url_for("index")) # reloads the page because each time a new page is loaded a new tweet is loaded anyway return render_template("index.html", title=getGeneratedArticle()[0],
def create_app(): """ init app :return: flask app """ app = flask.Flask(__name__, static_folder=config.STATIC_PATH) log.init_log(app, config.LOG_PATH, config.LOG_LEVEL) flask_cors.CORS(app) flask_compress.Compress(app) class RegexConverter(werkzeug.routing.BaseConverter): """ regular expression converts for route """ def __init__(self, url_map, *items): """ support for regular expression route :param url_map: alias for conflict with builtin 'map' :param items: regular expression """ super(RegexConverter, self).__init__(url_map) self.regex = items[0] app.url_map.converters['regex'] = RegexConverter app.config['SECRET_KEY'] = ''.join( random.sample(string.ascii_letters + string.digits, 8)) app.config['SQLALCHEMY_DATABASE_URI'] = config.DB_URL app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False db.init_app(app) with app.test_request_context(): db.create_all() app.config['OAUTH'] = {} if os.path.isdir(config.OAUTH_DIR): for root, _, files in os.walk(config.OAUTH_DIR): for auth_file in filter(lambda x: x.endswith('_oauth.json'), files): try: with open(os.path.join(root, auth_file)) as fp: prefix = auth_file[:auth_file.find('_')] oauth_config = json.load(fp) if oauth_config is not None: app.config['OAUTH'][prefix] = oauth_config except Exception as e: app.logger.error(e.message) api.init_oauth(app) app.register_blueprint(api.bp, url_prefix='/v1') @app.route('/<regex("$"):url>') def web_index(url=None): """ redirect to index :return: """ return flask.redirect('/web/index.html') @app.route('/web/swagger-ui<regex("$"):url>') def swagger_index(url=None): """ redirect to index :return: """ return flask.redirect('/web/swagger-ui/index.html') return app
""" Imports all necessary packages """ # importing app level modules from flask import Flask import flask_compress from flask_cors import CORS # from blueprints import api from Scripts.main import app #Importing a variable... from Utility import utility_file ## Declaring APP:: mr_app = Flask(__name__) ## Compressing the Response (Archiving):: flask_compress.Compress(mr_app) # ## Connecting all services (for Multiple API services):: mr_app.register_blueprint(app) CORS(mr_app, resources={r"/*": {"origins": "*"}}) if __name__ == '__main__': mr_app.run(host=utility_file.config["settings"]["ip"], port=utility_file.config["settings"]["port"], debug=True, threaded=True, use_reloader=False)
""" Import all necessary packages/libraries """ from flask import Flask import flask_compress from flask_cors import CORS from OpenSSL import SSL from flask_sslify import SSLify from Scripts.Utils import utility from Scripts.date_extract_main import api_main """Declaring API:::""" project_app = Flask(__name__) """Compressing the Response (Archiving)""" flask_compress.Compress(project_app) """Connecting all services (for multiple API services""" project_app.register_blueprint(api_main) CORS(project_app, resources={r'/*': {'origins': '*'}}) if __name__ == '__main__': """Running main services::""" project_app.run(host=utility.config["settings"]["ip"], port=utility.config["settings"]["port"], debug=True, threaded=True, use_reloader=False)