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)
