log_level = getattr(logging, LOG_LEVEL)
logging_instances = [[app.logger, log_level],
[logging.getLogger('werkzeug'), logging.WARNING],
[logging.getLogger('azure'), logging.WARNING]]
# ---------------------------------------------------------
app.register_blueprint(home_page)
app.register_blueprint(postcode_page)
cache_client.init_app(app)
minifier = minify(html=True,
js=True,
cssless=True,
caching_limit=0,
fail_safe=True)
@app.template_filter()
@lru_cache(maxsize=256)
def format_timestamp(latest_timestamp: str) -> str:
ts_python_iso = latest_timestamp[:-1] + "+00:00"
ts = datetime.fromisoformat(ts_python_iso)
ts_london = ts.astimezone(timezone_LN)
formatted = ts_london.strftime(timestamp_pattern)
result = re.sub(r'\s([AP]M)', lambda found: found.group(1).lower(),
formatted)
return result
def create_app(config={}):
''' Create the flask app and setup extensions and blueprints.
Returns
-------
app: Flask app
app with settings and blueprints loadeds.
'''
app = Flask(__name__,
static_folder=absolute_path('static'),
template_folder=absolute_path('templates'))
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get(
'DATABASE_URI', (f'sqlite:///{absolute_path(DATABASE_FILE)}'
'?check_same_thread=False'))
app.config['DB_NAME'] = DATABASE_FILE
# Autoreload if templates change
app.config['TEMPLATES_AUTO_RELOAD'] = True
# flask_upload settings
# app.config['MAX_CONTENT_LENGTH'] = 500 * 1024 * 1024 # Remove Upload limit. FIX ISSUE
app.config['UPLOADED_FILES_DEST'] = absolute_path('static/multimedia')
app.config['UPLOADED_FILES_ALLOW'] = reduce(lambda sum, group: sum + group,
SUPPORTED_MEDIA_FILES)
app.config['SECRET_KEY'] = SECRET_KEY
app.config['RESTX_VALIDATE'] = True
app.config.update(config)
# Initiating extensions before registering blueprints
Moment(app)
QRcode(app)
configure_uploads(app, files)
login_manager.init_app(app)
db.init_app(app)
migrate.init_app(app, db=db)
datepicker(
app, local=['static/css/jquery-ui.min.css', 'static/jquery-ui.min.js'])
colorpicker(app,
local=['static/css/spectrum.css', 'static/spectrum.min.js'])
fontpicker(app,
local=[
'static/jquery-ui.min.js', 'static/css/jquery-ui.min.css',
'static/webfont.min.js', 'static/webfont.select.min.js',
'static/css/webfont.select.css'
])
gTTs.init_app(app)
gtranslator.init_app(app)
if app.config.get('GUNICORN', False):
gtranslator.readonly = True
else:
minify(app,
js=True,
cssless=True,
caching_limit=3,
fail_safe=True,
bypass=['.min.*', 'restx_doc.static'])
# Register blueprints
app.register_blueprint(administrate)
app.register_blueprint(core)
app.register_blueprint(cust_app)
app.register_blueprint(manage_app)
app.register_blueprint(setup_api(), url_prefix='/api/v1')
app.jinja_env.add_extension('jinja2.ext.loopcontrols')
return app
import re
from flask import Flask, render_template, request
from flask_minify import minify
from rdflib import Graph, Literal
from rdflib.plugins.sparql import prepareQuery
from JSONLD import *
from Queries import *
app = Flask(__name__)
minify(app=app, html=True, js=True, cssless=True)
######################################
# CALL APIs AND PARSING INTO JSON-LD
######################################
NUMBER_OF_RESULTS = 10000
ELECTRIC_CARS_API_URL = "https://public.opendatasoft.com/api/records/1.0/search/?dataset=fichier-consolide-des-bornes-de-recharge-pour-vehicules-electriques-irve&q=&facet=n_enseigne&facet=nbre_pdc&facet=puiss_max&facet=accessibilite&facet=nom_epci&facet=commune&facet=nom_reg&facet=nom_dep&rows=" + \
str(NUMBER_OF_RESULTS)
ELECTRIC_CARS_API_URL_PART1 = f"{ELECTRIC_CARS_API_URL}&start=0"
ELECTRIC_CARS_API_URL_PART2 = f"{ELECTRIC_CARS_API_URL}&start={NUMBER_OF_RESULTS}"
ELECTRIC_CARS_API_URL_PART3 = f"{ELECTRIC_CARS_API_URL}&start={NUMBER_OF_RESULTS*2}"
ELECTRIC_CARS_CONTEXT = r'contexts/electric_car_parks.json'
CARS_API_URL = "https://data.opendatasoft.com/api/records/1.0/search/?dataset=stations-services-en-france%40datanova&q=&facet=typeroute&facet=commune&facet=codepostal&facet=services&facet=carburants&facet=activite&rows=" + \
str(NUMBER_OF_RESULTS)
CARS_API_URL_PART1 = f"{CARS_API_URL}&start=0"
CARS_API_URL_PART2 = f"{CARS_API_URL}&start={NUMBER_OF_RESULTS}"
def test_javascript_minify(client):
""" testing JavaScript minify option """
minify(app=app, html=False, cssless=False, js=True)
resp = client.get('/js')
assert b'<script>["J","S"].reduce(function(a,r){return a+r})</script>' == resp.data
def test_lesscss_minify(client):
""" testing css and less minify option """
minify(app=app, html=False, cssless=True, js=False)
resp = client.get('/cssless')
assert b'<style>body{color:red;}</style>' == resp.data
try:
from flask_compress import Compress
except ModuleNotFoundError:
compress_inited = False
minify_inited = True
try:
from flask_minify import minify
except ModuleNotFoundError:
minify_inited = False
# Init flask
app = Flask(__name__, template_folder="game")
if compress_inited:
Compress(app)
if minify_inited:
minify(app=app, js=False, caching_limit=0)
import before_after_req # noqa: F401,E402
# Init github
if os.getenv("GITHUB_VERSION_PAT") is not None:
github_instance = Github(os.getenv("GITHUB_VERSION_PAT"))
else:
github_instance = Github()
rep = github_instance.get_repo("KTibow/scorecard")
def sleep(timefor):
"""
Sleep, but catch interrupts and whatever.
Args:
def test_html_minify(client):
""" testing HTML minify option """
minify(app=app, html=True, cssless=False, js=False)
resp = client.get('/html')
assert b'<html> <body> <h1> HTML </h1> </body> </html>' == resp.data
from flask import Flask from flask_minify import minify app = Flask(__name__) minify(app=app, html=True, js=False, cssless=False) from app import routes
from flask import Flask, render_template, url_for
from flask_assets import Environment, Bundle
from flask_minify import minify
import os.path
app = Flask(__name__)
assets = Environment(app)
assets.url = app.static_url_path
scss = Bundle('styles/*.scss', filters='pyscss', output='css/main.css')
assets.register('scss_all', scss)
minify(app=app)
@app.before_request
def before_request():
app.jinja_env.cache = {}
# prevents cached versions
@app.context_processor
def override_url_for():
return dict(url_for=dated_url_for)
def dated_url_for(endpoint, **values):
if endpoint == 'static':
filename = values.get('filename', None)
if filename:
file_path = os.path.join(app.root_path, endpoint, filename)
values['q'] = int(os.stat(file_path).st_mtime)
return url_for(endpoint, **values)
def create_app():
app = Flask(__name__)
# Load app config
if app.config['ENV'] == 'production':
# Create logger
logger = logging.getLogger('flask.errors')
logger.setLevel(logging.DEBUG)
# Create console handler and configure it
consoleHandler = logging.StreamHandler()
consoleHandler.setLevel(logging.DEBUG)
logFormat = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
consoleHandler.setFormatter(logging.Formatter(logFormat))
# Add our custom handler to the logger
logger.addHandler(consoleHandler)
# Tell the app to use logger
app.logger.handlers = logger.handlers
app.logger.setLevel(logger.level)
# Server side minification
app.logger.info('Minifying')
minify(app=app, html=True, js=False, cssless=True)
app.logger.info('Starting with ProductionConfig')
app.config.from_object(ProductionConfig)
elif app.config['ENV'] == 'testing':
app.logger.info("Starting with TestingConfig")
app.config.from_object(TestingConfig)
else:
app.logger.info('Starting with DevelopmentConfig')
app.config.from_object(DevelopmentConfig)
# Connect to database
app.logger.info('Using database connection:' +
app.config['SQLALCHEMY_DATABASE_URI'])
app.logger.info('Using redis connection:' + app.config['RQ_REDIS_URL'])
app.url_map.strict_slashes = True
# Gotify push notifications
if app.config['GOTIFY_URL'] is not None:
app.logger.info('Using Gotify url: {}'.format(
app.config['GOTIFY_URL']))
#
# Custom flask cli commands
#
app.cli.add_command(run_worker)
app.cli.add_command(run_scheduler)
#
# Set up Flask extensions
#
# Init Flask-DebugToolbar
toolbar.init_app(app)
# Init Flask-RQ2
rq.init_app(app)
# Init Flask-SQLAlchemy
db.init_app(app)
# Init Flask-Migrate
migrate.init_app(app, db)
# Init Flask-Login
login_manager.login_view = 'auth.login'
login_manager.init_app(app)
login_manager.refresh_view = 'auth.login'
login_manager.needs_refresh_message = (
u"Session timedout, please re-login")
login_manager.needs_refresh_message_category = "info"
from app.models import User
from app import admin
admin.init_app(app)
admin.add_view(AdminModelView(User, db.session))
#admin.add_view(FileAdmin('./path/', '/files/', name="File browser"))
admin.add_link(MainIndexLink(name='Flask Dashboard'))
try:
with app.app_context():
# Create database models
#db.create_all()
# Create admin user on startup
admin_email = app.config['ADMIN_EMAIL']
admin_name = app.config['ADMIN_NAME']
admin_pass = app.config['ADMIN_PASSWORD']
admin = User.query.filter_by(email=admin_email).first()
if admin.name is None:
passw = generate_password_hash(admin_pass, method='sha256')
new_user = User(
email=admin_email,
name=admin_name,
#password=admin_pass,
role='admin')
new_user.set_password(admin_pass)
db.session.add(new_user)
db.session.commit()
app.logger.info('Added admin user to dabatase')
else:
# Checking if password has been changed
admin_hash = generate_password_hash(admin_pass,
method='sha256')
if not check_password_hash(admin_hash, admin.password):
# Updating password on database
admin.password = admin_hash
db.session.add(admin)
db.session.commit()
#app.logger.info('Updated admin password')
app.logger.info('Database working')
except Exception as e:
app.logger.error('Exception Found' + str(e))
app.logger.error(
'Database not found. Please read README.md to create the db.')
app.logger.info('Done. Flask extensions started.')
# Adding the views app
from app.views.home import dashboard_bp
from app.views.auth import auth_bp
from app.views.api import api_bp
app.register_blueprint(dashboard_bp)
app.register_blueprint(auth_bp)
app.register_blueprint(api_bp)
# Inject global variables to all templates
@app.context_processor
def injectVariables():
return dict(user=current_user)
# Set up global HTML handlers
@app.errorhandler(500)
def internal_server_error(error):
return render_template('500.html'), 500
@app.errorhandler(404)
def page_not_found(error):
return render_template('404.html'), 404
# Auto logout session. Modify time in minutes
@app.before_request
def before_request():
session.permanent = True
app.permanent_session_lifetime = timedelta(minutes=1440)
return app
from flask import Flask
from flask_minify import minify
from flask_minify import parsers as minify_parsers
from flask_minify.decorators import minify as decorator
from .constants import FALSE_LESS, HTML, HTML_EMBEDDED_TAGS, JS, JS_WITH_TYPE, LESS
app = Flask(__name__)
parsers = {"style": minify_parsers.Lesscpy}
store_minify = minify(app=app, fail_safe=False, parsers=parsers)
@app.route("/html")
def html():
return HTML
@app.route("/bypassed")
def bypassed():
return HTML
@app.route("/js")
def js():
return JS
@app.route("/js_with_type")
def js_with_type():
return JS_WITH_TYPE
def setup_minification():
minify(app=app, caching_limit=0, bypass=[r'fuzzysort.js', r'^rss$'])
url = 'https://cssminifier.com/raw'
for style in {'style', 'dark'}:
data = {'input': open(f'static/css/{style}.css', 'rb').read()}
r = requests.post(url, data=data)
with open(f'static/css/{style}.min.css', 'w') as f:
f.write(r.text)
except requests.exceptions.ConnectionError:
print('Failed to minify CSS, are you connected to the internet?')
app = Flask(__name__)
app.jinja_env.lstrip_blocks = True
app.jinja_env.trim_blocks = True
app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 0 if DEV_ENV else 604800
# app.wsgi_app = ProxyFix(app.wsgi_app, num_proxies=1)
Compress(app)
if not DEV_ENV: minify(app, caching_limit=0)
socketio = SocketIO(app)
@app.context_processor
def get_style_links():
if DEV_ENV:
return {
'style_default': '/static/css/style.css',
'style_dark': '/static/css/dark.css'
}
return {
'style_default': '/static/css/style.min.css',
'style_dark': '/static/css/dark.min.css'
}
# return {'style_default': 'https://cdn.jsdelivr.net/gh/elibroftw/website/static/css/style.min.css',
from flask import Flask
from flask_assets import Bundle, Environment
from flask_caching import Cache
from flask_compress import Compress
from flask_minify import minify
from .url_converters import ListConverter
app = Flask(__name__)
app.config.from_pyfile('settings.py')
app.cache = Cache(app)
js_assets = Bundle('js/cookie.js', 'js/index.js', filters='rjsmin', output='gen/bundled.js')
css_assets = Bundle('css/index.css', filters='cssmin', output='gen/bundled.css')
assets = Environment(app)
assets.register('js_all', js_assets)
assets.register('css_all', css_assets)
# gzip responses
Compress(app)
# Minify HTML and any inline JS or CSS
minify(app, js=True)
app.url_map.converters['list'] = ListConverter
from . import filters
from . import views
from flask_restless import APIManager
from slugify import slugify
basicConfig(format="%(asctime)s\t- %(levelname)s\t- %(message)s", level=INFO)
app = Flask(__name__)
app.config["TELERIVET_API_KEY"] = environ["TELERIVET_API_KEY"]
app.config["WEBHOOK_SECRET"] = environ["WEBHOOK_SECRET"]
app.config["SQLALCHEMY_DATABASE_URI"] = environ.get(
"DATABASE_URL") or "sqlite:///dev.db"
db = SQLAlchemy(app)
mn = minify(app)
hz = Humanize(app)
ev = DotEnv(app)
@hz.localeselector
def get_locale():
return "pt_BR"
# Models
class Category(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), unique=True, nullable=False)
slug = db.Column(db.String(50), unique=True, nullable=False)
def test_html_bypassing(client):
""" testing HTML route bypassing """
minify(app=app, html=True, cssless=False, js=False, bypass=['/html'])
resp = client.get('/html')
assert b'<html> <body> <h1> HTML </h1> </body> </html>' != resp.data
from flask_minify import minify static_minify = minify(html=True, js=True, cssless=True, caching_limit=0)
from .url_converters import ListConverter
app = Flask(__name__)
app.config.from_pyfile('settings.py')
app.cache = Cache(app)
js_assets = Bundle('js/cookie.js',
'js/index.js',
filters='rjsmin',
output='gen/bundled.js')
css_assets = Bundle('css/index.css',
filters='cssmin',
output='gen/bundled.css')
assets = Environment(app)
assets.register('js_all', js_assets)
assets.register('css_all', css_assets)
# gzip responses
Compress(app)
# Minify HTML and any inline JS or CSS
minify(app, js=True)
app.url_map.converters['list'] = ListConverter
from . import filters
from . import views
