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