def add_extensions(application): global db global mail_app global md global md_no_mj global logger global mb global socketio # App.testing indicates that the database is sqlite://:memory: if not app.testing: application.config[ 'SQLALCHEMY_DATABASE_URI'] += "_debug" if application.debug else "_prod" db = SQLAlchemy(application) mail_app = Mail(application) md = Misaka(application, **application.config['MISAKA_CONFIG']) md_no_mj = Misaka( application, **{ **application.config['MISAKA_CONFIG'], "math": False, "math_explicit": False }) mb = Mobility(app) logger = application.logger socketio = SocketIO(app)
def app(self): app = Flask(__name__) Mobility(app) @app.route("/") def index(): assert isinstance(request.MOBILE, bool) tpl = "{% if request.MOBILE %}True{% else %}False{% endif %}" return render_template_string(tpl) return app
def setUp(self): app = Flask(__name__) Mobility(app) @app.route('/') def index(): tpl = '{% if request.MOBILE %}True{% else %}False{% endif %}' return render_template_string(tpl) self.app = app.test_client() self.config = app.config
def create_app(): app = Flask(__name__) app.config.from_pyfile('config.py') app.jinja_env.filters["usd"] = usd app.jinja_env.filters["capitalize"] = capitalize csrf.init_app(app) db.app = app db.init_app(app) with app.app_context(): make_class_dictable(db.Model) from . import models Migrate(app, db) Session(app) Bootstrap(app) FontAwesome(app) Mobility(app) JWTManager(app) def errorhandler(e): """Handle error""" if isinstance(e, CSRFError): return Redirects.login(True) if not isinstance(e, HTTPException): e = InternalServerError() return _templates.apology(e.name, e.code) for code in default_exceptions: app.errorhandler(code)(errorhandler) mail.init(app) stock.init(app) token.init(app) sms.init(app) geo.init(app) with app.app_context(): from .views import auths, accounts, portfolios from .apis import markets, portfolios, tokens @app.after_request def after_request(response): """Ensure responses aren't cached""" response.headers[ "Cache-Control"] = "no-cache, no-store, must-revalidate" response.headers["Expires"] = 0 response.headers["Pragma"] = "no-cache" return response return app
def app(self): app = Flask(__name__) Mobility(app) @app.route("/") @mobile_template("{mobile/}template.html") def index(template): return render_template_string(template) # Default View def mobilize(): return render_template_string("False") # Mobilized view @app.route("/mobilize") @mobilized(mobilize) def mobilize(): return render_template_string("True") return app
def setUp(self): app = Flask(__name__) Mobility(app) @app.route('/') @mobile_template('{mobile/}template.html') def index(template): return render_template_string(template) # Default View def mobilize(): return render_template_string('False') # Mobilized view @app.route('/mobilize') @mobilized(mobilize) def mobilize(): return render_template_string('True') self.app = app self.client = app.test_client()
from random import shuffle from bs4 import BeautifulSoup import urllib3 import shutil # import html # import multiprocessing from flask_mobility import Mobility from flask import Flask, render_template, Markup, request from flask_caching import Cache from wtforms import Form, BooleanField, FormField, FieldList, StringField, IntegerField, validators, SelectField http = urllib3.PoolManager() g_app = Flask(__name__) Mobility(g_app) application = g_app # from flask_table import Table, Col # <a target="_blank" href = "{{ link }}"><img src = "{{ image_url }}" style="max-height: 100px;"/> EXPIRE_MINUTES = 60 * 10 #Expire things faster in debug mode #if g_app.debug == True: # EXPIRE_MINUTES = 60 # print ("In debug mode, so expires faster") EXPIRE_HOURS = 3600 EXPIRE_DAY = 3600 * 6 EXPIRE_DAYS = 86400 * 10
babel = Babel() geo = geolite2.reader() @babel.localeselector def get_locale(): # need to see if json in request. return request.accept_languages.best_match(config.LANGUAGES.keys()) sentry = Sentry( dsn= 'https://*****:*****@sentry.io/292734' ) mobile = Mobility() crf_protection = CSRFProtect() jwt = JWT(config.SECRET_KEY, expires_in=3600) mailer = Client(auth=(config.MAIL_USERNAME, config.MAIL_PASSWORD), version='v3.1') def search_street(street, lang='en'): location = None try: geolocator = Nominatim() location = geolocator.geocode(street, language=lang) except: try:
from flask_login import LoginManager, UserMixin, login_required, login_user, logout_user import datetime from flask import Flask, render_template, request, redirect, url_for import sqlite3 as sql from random import randint from flask_mobility import Mobility #привет, прочти файл readme.txt в корне application = Flask(__name__) Mobility(application) # объявляю переменные на будущее чтоб не ругался dbdic = {'login': '******'} payment = '' instagram = '' price = '' select_2 = '' select_4 = '' select_6 = '' sort_by = 'c_r_date' sort_by_check = { 'c_id': '', 'c_name': '', 'c_instagram': '', 'c_phone': '', 'c_email': '', 'product': '', 'c_r_date': 'checked', 'period': '', 'price': '',
def create_app(config_class=Config): app = Flask(__name__) app.config.from_object(config_class) ts = translator(app) Mobility(app) db.init_app(app) migrate.init_app(app, db) login.init_app(app) mail.init_app(app) bootstrap.init_app(app) moment.init_app(app) babel.init_app(app) app.elasticsearch = Elasticsearch([app.config['ELASTICSEARCH_URL']]) \ if app.config['ELASTICSEARCH_URL'] else None app.redis = Redis.from_url(app.config['REDIS_URL']) app.task_queue = rq.Queue('streamfish-tasks', connection=app.redis) from app.errors import bp as errors_bp app.register_blueprint(errors_bp) from app.auth import bp as auth_bp app.register_blueprint(auth_bp, url_prefix='/auth') from app.main import bp as main_bp app.register_blueprint(main_bp) from app.api import bp as api_bp app.register_blueprint(api_bp, url_prefix='/api') if not app.debug and not app.testing: if app.config['MAIL_SERVER']: auth = None if app.config['MAIL_USERNAME'] or app.config['MAIL_PASSWORD']: auth = (app.config['MAIL_USERNAME'], app.config['MAIL_PASSWORD']) secure = None if app.config['MAIL_USE_TLS']: secure = () mail_handler = SMTPHandler( mailhost=(app.config['MAIL_SERVER'], app.config['MAIL_PORT']), fromaddr='no-reply@' + app.config['MAIL_SERVER'], toaddrs=app.config['ADMINS'], subject='StreamfishFailure', credentials=auth, secure=secure) mail_handler.setLevel(logging.ERROR) app.logger.addHandler(mail_handler) if app.config['LOG_TO_STDOUT']: stream_handler = logging.StreamHandler() stream_handler.setLevel(logging.INFO) app.logger.addHandler(stream_handler) else: if not os.path.exists('logs'): os.mkdir('logs') file_handler = RotatingFileHandler('logs/microblog.log', maxBytes=10240, backupCount=10) file_handler.setFormatter( logging.Formatter('%(asctime)s %(levelname)s: %(message)s ' '[in %(pathname)s:%(lineno)d]')) file_handler.setLevel(logging.INFO) app.logger.addHandler(file_handler) app.logger.setLevel(logging.INFO) app.logger.info('Welcome') if app.config['LOG_TO_STDOUT']: stream_handler = logging.StreamHandler() stream_handler.setLevel(logging.INFO) app.logger.addHandler(stream_handler) else: if not os.path.exists('logs'): os.mkdir('logs') file_handler = RotatingFileHandler('logs/microblog.log', maxBytes=10240, backupCount=10) file_handler.setFormatter( logging.Formatter('%(asctime)s %(levelname)s: %(message)s ' '[in %(pathname)s:%(lineno)d]')) file_handler.setLevel(logging.INFO) app.logger.addHandler(file_handler) app.logger.setLevel(logging.INFO) app.logger.info('Streamfishstartup') return app
app = Flask(__name__, static_folder='static') env = 'production' app.config['ENV'] = env app.config.from_pyfile('config.py') # app.config['SECURITY_USER_IDENTITY_ATTRIBUTES'] = ('name', 'email') # CSRF protection from flask_wtf.csrf import CsrfProtect CsrfProtect(app) # Database from flask_sqlalchemy import SQLAlchemy # app.config['SQLALCHEMY_DATABASE_URI'] = os.environ['DATABASE_URL'] app.config[ 'SQLALCHEMY_DATABASE_URI'] = 'postgresql://*****:*****@localhost/scoda' db = SQLAlchemy(app) # Mail from flask_mail import Mail mail = Mail(app) from flask_mobility import Mobility mobility = Mobility(app)
#!/usr/bin/env python # -*- coding: UTF-8 -*- from flask import Flask from config import Config from flask_sslify import SSLify from flask_mobility import Mobility from flask_bootstrap import Bootstrap application = Flask(__name__) application.config.from_object(Config) sslify = SSLify(application) # Подключение SSL Mobility(application) # Мобильная версия Bootstrap(application) # Bootstrap from app import routes if __name__ == "__main__": application.run(host='0.0.0.0', port=5000)
from config import config from flask import Flask from flask_bootstrap import Bootstrap from flask_mobility import Mobility from flask_s3 import FlaskS3 import os from arxlive import views import flask_assets assets = flask_assets.Environment() bootstrap = Bootstrap() s3 = FlaskS3() mob = Mobility() def create_app(config_name='default'): """Create and configure an instance of the Flask application.""" app = Flask(__name__, instance_relative_config=True) app.config.from_object(config[config_name]) app.config.from_pyfile("config.py", silent=True) # instance config bootstrap.init_app(app) s3.init_app(app) assets.init_app(app) mob.init_app(app) # ensure the instance folder exists try: os.makedirs(app.instance_path) except OSError: pass
def create_app(test_config=None): # create and configure the app app = Flask(__name__, instance_relative_config=True) Mobility(app) app.config.from_mapping( SECRET_KEY = 'dev', SQLALCHEMY_DATABASE_URI = os.environ['DATABASE_URL'], SQLALCHEMY_TRACK_MODIFICATIONS = False, SEND_FILE_MAX_AGE_DEFAULT = 0, ) #app.jinja_env.trim_blocks = True #app.jinja_env.lstrip_blocks = True if test_config is None: # load the instance config, if it exists, when not testing app.config.from_pyfile('config.py', silent=True) else: # load the test config if passed in app.config.from_mapping(test_config) # ensure the instance folder exists try: os.makedirs(app.instance_path) except OSError: pass db.init_app(app) migrate.init_app(app, db) from . import models from . import auth app.register_blueprint(auth.bp) from . import patient app.register_blueprint(patient.bp) app.add_url_rule('/', endpoint='index') from . import rechnung app.register_blueprint(rechnung.bp) from . import behandlungsverlauf app.register_blueprint(behandlungsverlauf.bp) from . import abfragen app.register_blueprint(abfragen.bp) from . import kalender app.register_blueprint(kalender.bp) from . import admin app.register_blueprint(admin.bp) from .util.filters import mapanrede, mapgeschlecht, mapimpfung, mapartikel, \ filter_supress_none, filter_format_date, filter_format_datetime, \ filter_mformat_date, calc_kw, add_days, add_hours, add_mins, \ gib_feiertag app.jinja_env.filters['mapanrede'] = mapanrede app.jinja_env.filters['mapgeschlecht'] = mapgeschlecht app.jinja_env.filters['mapimpfung'] = mapimpfung app.jinja_env.filters['mapartikel'] = mapartikel app.jinja_env.filters['sn'] = filter_supress_none app.jinja_env.filters['dt'] = filter_format_date app.jinja_env.filters['mdt'] = filter_mformat_date app.jinja_env.filters['dttm'] = filter_format_datetime app.jinja_env.filters['calc_kw'] = calc_kw app.jinja_env.filters['add_days'] = add_days app.jinja_env.filters['add_hours'] = add_hours app.jinja_env.filters['add_mins'] = add_mins app.jinja_env.filters['feiertag'] = gib_feiertag return app
from flask import Flask from .config import Config from flask_sqlalchemy import SQLAlchemy from flask_migrate import Migrate from flask_login import LoginManager from datetime import datetime, date from flask_mobility import Mobility dash_app = Flask(__name__) Mobility(dash_app) dash_app.config.from_object(Config) db = SQLAlchemy(dash_app) migrate = Migrate(dash_app, db) login = LoginManager(dash_app) login.login_view = 'login' def format_datetime(timestamp): return datetime.strftime(timestamp, '%d/%m/%y') def format_date(timestamp): return date.strftime(timestamp, '%d/%m/%y') dash_app.jinja_env.filters['datetime'] = format_datetime dash_app.jinja_env.filters['date'] = format_date from . import routes, models, errors
from flask_sqlalchemy import SQLAlchemy from flask_wtf.csrf import CSRFProtect # from flask_sslify import SSLify # currently doesn't support factory pattern from flask_mobility import Mobility from flask_mail import Mail from flask_cors import CORS # if installed: from flask_serializer import FlaskSerializer from lib.flask_serializer.flask_serializer import FlaskSerializer # Initialize database flask_db = SQLAlchemy() flask_csrf = CSRFProtect() # flask_sslify = SSLify() flask_mobility = Mobility() flask_mail = Mail() # cors config ( # CORS(resources={ # r"/api/*": {"origins": "*"}, # r"/login/": {"origins": "*"} # } flask_cors = CORS(supports_credentials=True) flask_serializer = FlaskSerializer()
import logging from flask import Flask from flask_login import LoginManager from flask_mail import Mail from flask_mobility import Mobility from flask_uploads import configure_uploads from raven.contrib.flask import Sentry from werkzeug.contrib.fixers import ProxyFix from config import DevelopmentConfig from project.apis import api_blueprint as api from project.utils.error_handlers import register_handlers from project.utils.uploadsets import avatars mobility = Mobility() mail = Mail() sentry = Sentry() login_manager = LoginManager() login_manager.login_view = '/login' login_manager.login_message = 'You have to login in order to view that page.' login_manager.login_message_category = 'alert alert-danger' def format_datetime(value): return value.strftime("%d/%m/%Y") def create_app(cfg=DevelopmentConfig): app = Flask(__name__)
return db[usr]['pas'] == pas def run(): #WSGIServer WSGIServer(('', 8081), app).serve_forever() #Thread def keep_alive(): t = Thread(target=run) t.start() app = Flask(__name__) Mobility(app) @app.route('/dark') @app.route('/dark_redirect_signin') def gray(): #index.html site = cacheWorkaround(codecs.open('web/index.html', 'r', 'utf-8')) site = site.replace('download_link', getDLink(request.MOBILE)) return site @app.route('/') @app.route('/redirect_signin') @app.route('/black') @app.route('/black_redirect_signin')
#Imports from flask import Flask, render_template, request, url_for, Response, redirect, make_response, redirect, g, jsonify, send_file from htmlmin.minify import html_minify from flask_cache import Cache from flask_mobility import Mobility import json, requests, urllib2, urllib, isodate, random, os, sys from enigma import Enigma from repo import Repo from youtube import YouTube # Flask Declarations site = Flask(__name__, static_folder="assets") cache = Cache(site, config={'CACHE_TYPE': 'memcached'}) Mobility(site) def after_this_request(f): if not hasattr(g, 'after_request_callbacks'): g.after_request_callbacks = [] g.after_request_callbacks.append(f) return f @site.after_request def call_after_request_callbacks(response): for callback in getattr(g, 'after_request_callbacks', ()): callback(response) return response