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