def setup_manager():
import main
app = main.create_app(**main.OPTIONS)
manager = Manager(app)
manager.add_command('resetdb', InitDatabase())
from flask_security import script
manager.add_command('create-user', script.CreateUserCommand())
manager.add_command('create-role', script.CreateRoleCommand())
manager.add_command('add-role', script.AddRoleCommand())
manager.add_command('remove-role', script.RemoveRoleCommand())
manager.add_command('activate-user', script.ActivateUserCommand())
manager.add_command('deactivate-user', script.DeactivateUserCommand())
from flask_migrate import MigrateCommand
manager.add_command('db', MigrateCommand)
from flask_script.commands import ShowUrls
manager.add_command('rules', ShowUrls)
from flask_assets import ManageAssets
manager.add_command("assets", ManageAssets())
return manager
def add(model, f):
app = create_app()
app.test_request_context().push()
for line in csv.reader(f):
if not line:
# skip empty lines
continue
line = [unicode(l, 'utf_8') for l in line]
try:
email, password, name, sexe, ecole, portable = line
except ValueError:
raise ValueError("La ligne semble trop courte (sur {}) !".format(line))
try:
sexe = Sexe[sexe].value
except:
raise ValueError("sexe: reçu {} au lieu de M ou F pour {}".format(sexe, name))
u = User(email, password, name, sexe, ecole, portable)
m = model(u)
db.session.add(m)
print "Créé {}".format(m)
send_email(m)
db.session.commit()
print "Tout s'est bien passé !"
def setUp(self):
os.environ['SERVER_NAME'] = 'test'
os.environ['SERVER_PORT'] = '1234'
self.mox = Mox()
self.login()
self.creator = self.make_creator()
self.app = TestApp(main.create_app())
self.stubs = StubOutForTesting()
def get_app():
app = create_app()
root = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..')
try:
os.remove(os.path.join(root, 'var', 'test.db'))
except OSError:
pass
os.environ['SETTINGS_FILE'] = os.path.join(root, 'config', 'test.cfg')
with app.app_context():
db.create_all()
CreateBankAccounts().run()
CreateTickets().run()
return app.test_client(), app, db
def app():
""" Fixture to provide an instance of the app.
This will also create a Flask app_context and tear it down.
This fixture is scoped to the module level to avoid too much
Postgres teardown/creation activity which is slow.
"""
if 'SETTINGS_FILE' not in os.environ:
root = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..')
os.environ['SETTINGS_FILE'] = os.path.join(root, 'config', 'test.cfg')
tmpdir = os.environ.get('TMPDIR', '/tmp')
prometheus_dir = os.path.join(tmpdir, 'emf_test_prometheus')
os.environ['prometheus_multiproc_dir'] = prometheus_dir
if os.path.exists(prometheus_dir):
shutil.rmtree(prometheus_dir)
if not os.path.exists(prometheus_dir):
os.mkdir(prometheus_dir)
app = create_app()
with app.app_context():
try:
db_obj.session.close()
except:
pass
db_obj.drop_all()
db_obj.create_all()
CreateBankAccounts().run()
CreateTickets().run()
yield app
db_obj.session.close()
db_obj.drop_all()
def create_app(self):
return create_app()
from main import create_app from main import ProductionConfig __all__ = ['application'] application = create_app(ProductionConfig())
import sys
sys.path.insert(0, '/home/narlab/webapps/touravel')
from main import create_app, db
from flask.ext.script import Manager, Shell
from flask.ext.migrate import Migrate, MigrateCommand
from main.models.user import User
application = create_app('development')
manager = Manager(application)
migrate = Migrate(application, db)
manager.add_command('db', MigrateCommand)
def make_shell_context():
return dict(app=application, db=db, User=User)
manager.add_command("shell", Shell(make_context=make_shell_context))
@application.route("/")
def hello():
return "It Works!"
if __name__ == '__main__':
manager.run()
from flask import Flask
from flask_script import Manager
from flask_migrate import Migrate, MigrateCommand
from models import db
from main import create_app
app = create_app('config')
migrate = Migrate(app, db)
migrate.init_app(app, db)
manager = Manager(app)
manager.add_command('db', MigrateCommand)
if __name__ == "__main__":
manager.run()
db.create_all()
db.session.commit()
def app():
app = main.create_app(config_class=Config)
app.debug = True
client = app.test_client(use_cookies=True)
app.client = client
return app
import os
from dotenv import load_dotenv
from flask import render_template
from main import create_app
dotenv_path = os.path.join(os.path.dirname(__file__), ".env")
if os.path.exists(dotenv_path):
load_dotenv(dotenv_path)
app = create_app(os.getenv("FLASK_CONFIG") or "default")
@app.route("/", defaults={"path": ""})
@app.route("/<path:path>")
def default_route(path):
return render_template("index.html")
if __name__ == "__main__":
app.run(host="0.0.0.0", port=5000)
from main import db, create_app db.create_all(app=create_app())
def app():
app = create_app(testing=True)
return app
#!/usr/bin/env python
# coding=utf-8
from main import create_app
config = "default"
app = create_app(config)
if __name__ == '__main__':
app.run(host="0.0.0.0", port=5100)
from os import getenv
from flask_migrate import Migrate
from flask_script import Manager
from api.datab import db
from config import config
from main import create_app
config_name = getenv("FLASK_ENV", "production")
app = create_app(config.get(config_name))
migrate = Migrate(app, db)
manager = Manager(app)
if "__main__ " == __name__:
manager.run()
def create_app(self):
return create_app()
def app():
"""Setup & teardown app"""
app = create_app("testing")
return app
from main import create_app
if __name__ == '__main__':
app, socketio_app = create_app()
socketio_app.run(app, host='0.0.0.0', debug=True, port=5000)
from tasks.cfp import (ImportCFP, EmailSpeakersAboutSlot,
EmailSpeakersAboutFinalising, RejectUnacceptedProposals)
from tasks.dev import MakeFakeData, MakeVolunteerData
from tasks.external_calendars import (CreateCalendars, RefreshCalendars,
ExportCalendars)
from tasks.schedule import (ImportVenues, RunScheduler, ApplyPotentialSchedule)
from tasks.tickets import (
CreateTickets,
SendTickets,
SendTransferReminder,
CancelReservedTickets,
)
from tasks.exportdb import ExportDB
if __name__ == "__main__":
manager = Manager(create_app())
manager.add_command('db', MigrateCommand)
manager.add_command('exportdb', ExportDB())
manager.add_command('createbankaccounts', CreateBankAccounts())
manager.add_command('loadofx', LoadOfx())
manager.add_command('reconcile', Reconcile())
manager.add_command('sendtransferreminder', SendTransferReminder())
manager.add_command('cancelreservedtickets', CancelReservedTickets())
manager.add_command('createtickets', CreateTickets())
manager.add_command('sendtickets', SendTickets())
manager.add_command('importcfp', ImportCFP())
manager.add_command('createperms', CreatePermissions())
def test_create_app(self): """Branch coverage for production server.""" self.mock(utils, 'is_local_dev_server', lambda: False) main.create_app()
from main import create_app
# Запуск приложения
if __name__ == '__main__':
create_app()
#!/usr/bin/python
'''Flask app runner for dev'''
from main import create_app
app = create_app()
app.config.from_object('config.Development')
if __name__ == '__main__':
app.run(host="0.0.0.0", debug=True, use_reloader=True)
import os
from main import create_app
# Entry point for uWSGI
application = create_app()
if __name__ == "__main__":
port = int(os.environ.get("METAWAHL_PORT", 9000))
app.run(port=port)
# Copyright 2015 The Chromium Authors. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. """Initialize all the apps. This module cannot be imported by tests (requires Datastore), so keep it super simple. """ import admin_handler import main main_app = main.create_app() admin_app = admin_handler.create_app()
import os
from main import create_app, logger, db
from flask import request, _request_ctx_stack
from flask_mail import email_dispatched
if __name__ == "__main__":
app = create_app(dev_server=True)
if app.config.get('DEBUG'):
email_dispatched.connect(logger.mail_logging)
if app.config.get('FIX_URL_SCHEME'):
# The Flask debug server doesn't process _FORWARDED_ headers,
# so there's no other way to set the wsgi.url_scheme.
# Consider using an actual WSGI host (perhaps with ProxyFix) instead.
@app.before_request
def fix_url_scheme():
if request.environ.get('HTTP_X_FORWARDED_PROTO') == 'https':
request.environ['wsgi.url_scheme'] = 'https'
_request_ctx_stack.top.url_adapter.url_scheme = 'https'
if os.path.exists('.inside-vagrant'):
# Make it easier to access from host machine
default_host = '0.0.0.0'
default_port = 5000
else:
# Safe defaults
default_host = None # i.e. localhost
default_port = None # i.e. 5000
host = app.config.get('HOST', default_host)
"""This file is the entry point for the app"""
import os
from main import create_app
app = create_app(os.environ.get("ENV", "development"))
if __name__ == "__main__":
app.run(host="127.0.0.1", port=3001, debug=True)
def app():
app = create_app()
return app
class create_users(Command):
"""Create a user"""
def run(self):
company_user = User(username='******',
email='*****@*****.**',
password=guard.hash_password('super.super'),
first_name='Raul',
last_name='Escamilla',
roles='company')
interpreter_user = User(username='******',
email='*****@*****.**',
password=guard.hash_password('super.super'),
first_name='Alberto',
last_name='Salinas',
roles='interpreter')
users.save(company_user)
users.save(interpreter_user)
app = create_app()
migrate = Migrate(app, db)
manager = Manager(app)
manager.add_command('db', MigrateCommand)
manager.add_command('create_users', create_users())
if __name__ == '__main__':
manager.run()
import os
from main import create_app
web = create_app()
web.app_context().push()
if __name__ == '__main__':
web.run(debug=True, port=os.getenv('PORT'))
def client():
"""Flask test client with Google Cloud logging client removed."""
from main import create_app
app = create_app()
return app.test_client()
def get_app(self):
"""Return HTTP/WS server."""
self.close_future = Future()
return create_app(SHELL, self.close_future)
#-*-coding:utf-8-*-
import os
from main import create_app
from flask_script import Manager,Server
from flask_migrate import Migrate,MigrateCommand
from main.models import db,User
config = os.environ.get('shape_cfg','dev')
app = create_app('main.config.%sConfig'%config.capitalize())
manager = Manager(app)
migrate = Migrate(app,db)
manager.add_command("server",Server())
manager.add_command("db",MigrateCommand)
@manager.shell
def make_shell_context():
return dict(app=app,db=db,User=User)
if __name__=="__main__":
# app.run(host="0.0.0.0")
manager.run()
# Third-Party libraries
from flasgger import swag_from
from flask import jsonify
from decouple import config as env_config
# Config
from main import create_app, rest_api
from config import config
#utils
from api.utils.pre_request import PreRequest
config_name = env_config('FLASK_ENV', 'production')
app = create_app(rest_api, config=config[config_name])
@app.before_request
def check_tenant_param():
return PreRequest.check_tenant()
@app.route('/health')
@swag_from('/api/docs/status.yml')
def index():
return jsonify(dict(message=f'App status - OK.'))
if __name__ == '__main__':
app.run()
# Show a debugging info on console
logging.debug("__file__ = %s", __file__)
logging.debug("sys.version = %s", sys.version)
logging.debug("os.getpid() = %s", os.getpid())
logging.debug("os.getcwd() = %s", os.getcwd())
logging.debug("os.curdir = %s", os.curdir)
logging.debug("sys.path:\n\t%s", "\n\t".join(sys.path))
logging.debug("PYTHONPATH:\n\t%s", "\n\t".join(os.environ.get('PYTHONPATH', "").split(';')))
logging.debug("sys.modules.keys() = %s", repr(sys.modules.keys()))
logging.debug("sys.modules.has_key('website') = %s", ('website' in sys.modules))
if 'website' in sys.modules:
logging.debug("sys.modules['website'].__name__ = %s", sys.modules['website'].__name__)
logging.debug("sys.modules['website'].__file__ = %s", sys.modules['website'].__file__)
# # Setup proper logging
# from website.logcfg import setup_logging
#
# log_file = os.path.join(ROOT_DIR, "logs", 'website.log')
# setup_logging(log_file=log_file, console_verbosity=logging.DEBUG if PRODUCTION else logging.DEBUG)
from main import create_app, OPTIONS
try:
application = create_app(**OPTIONS)
except Exception as ex:
logging.error("Failed to create a WSGI app", exc_info=True)
logging.debug("app.debug: %s" % application.debug)
logging.debug("app.testing: %s" % application.testing)
import os
from main import create_app
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
config_name = os.getenv('FLASK_CONFIG')
app = create_app(config_name)
if __name__ == '__main__':
app.run()
import os
import sys
sys.path.append(os.path.realpath('.'))
from flask_script import Manager
from flask_migrate import Migrate, MigrateCommand
from main import create_app
from models.models import db
from config import Config
app = create_app(Config)
migrate = Migrate(app, db)
manager = Manager(app)
manager.add_command('db', MigrateCommand)
if __name__ == '__main__':
manager.run()
import os
from main import create_app
from api.config.config import ProductionConfig,\
DevelopmentConfig, TestConfig
if os.environ.get('WORK_ENV') == 'PROD':
app = create_app(ProductionConfig)
elif os.environ.get('WORK_ENV') == 'TEST':
app = create_app(TestConfig)
else:
app = create_app(DevelopmentConfig)
celery = app.celery
if __name__ == "__main__":
app.run()
def setUp(self):
"""尝试创建一个测试环境"""
self.app = create_app('testing')
self.app_context = self.app.app_context()
self.app_context.push()
db.create_all()
import os
from flask_script import Manager
from flask_migrate import Migrate, MigrateCommand
from dotenv import load_dotenv
from pathlib import Path
from main import create_app, db
env_path = Path('.') / '.env'
load_dotenv(dotenv_path=env_path, verbose=True)
env_name = os.getenv('FLASK_ENV')
app = create_app(env_name)
migrate = Migrate(app=app, db=db)
manager = Manager(app=app)
manager.add_command('db', MigrateCommand)
if __name__ == '__main__':
manager.run()
for rec in EmailJobRecipient.query.filter(EmailJobRecipient.sent == False): # noqa
self.send_email(conn, rec)
def send_email(self, conn, rec):
msg = Message(rec.job.subject, sender=app.config['CONTACT_EMAIL'])
msg.add_recipient(rec.user.email)
msg.body = rec.job.text_body
msg.html = rec.job.html_body
conn.send(msg)
rec.sent = True
db.session.add(rec)
db.session.commit()
if __name__ == "__main__":
manager = Manager(create_app())
manager.add_command('createdb', CreateDB())
manager.add_command('db', MigrateCommand)
manager.add_command('createbankaccounts', CreateBankAccounts())
manager.add_command('loadofx', LoadOfx())
manager.add_command('reconcile', Reconcile())
manager.add_command('sendtransferreminder', SendTransferReminder())
manager.add_command('createtickets', CreateTickets())
manager.add_command('sendtickets', SendTickets())
manager.add_command('lockproposals', LockProposals())
manager.add_command('importcfp', ImportCFP())
manager.add_command('createperms', CreatePermissions())
"""Application entry point"""
from config import AppConfig
from main import create_app
# application object
app = create_app(AppConfig)
if __name__ == '__main__':
app.run()
import shutil
from main import create_app, db
from flask import request, _request_ctx_stack
from flask_mail import email_dispatched
if __name__ == "__main__":
prometheus_dir = 'var/prometheus'
os.environ['prometheus_multiproc_dir'] = prometheus_dir
if os.path.exists(prometheus_dir):
shutil.rmtree(prometheus_dir, True)
if not os.path.exists(prometheus_dir):
os.mkdir(prometheus_dir)
app = create_app(dev_server=True)
# Prevent DB connections and random numbers being shared
ppid = os.getpid()
@app.before_request
def fix_shared_state():
if os.getpid() != ppid:
db.engine.dispose()
random.seed()
import prometheus_client.multiprocess
@app.after_request
def prometheus_cleanup(response):
# this keeps livesum and liveall accurate
# other metrics will hang around until restart
# system import
from os import getenv
# third party import
from flask import jsonify
# local import
from main import create_app
from config import config
# get flask config name from env or default to production config
config_name = getenv('FLASK_ENV', default='production')
# create application object
app = create_app(config[config_name])
if __name__ == '__main__':
app.run()
def app_module(self): return main.create_app()
def setUpClass(cls):
cls.app = create_app()
cls.client = cls.app.test_client()
import sys
from os import path
sys.path.append('lib')
print path.dirname(path.abspath(__file__))
sys.path.append(path.dirname(path.abspath(__file__)))
from datetime import datetime, timedelta
import arrow
import io
import string
import websocket
import thread
import time
import json
from main import create_app
app = create_app(schedule_events=False)
app.app_context().push()
class AdminUser(HttpLocust):
host = 'https://api-virtumedix-vm2.nimaws.com/'
admin = AdminUser()
pat_id = '560dcedd02b9d75f7e663653'
cli_id = '55e7210f02b9d75d61fbe02b'
total_cnt = 0
def on_message(ws, message):
global total_cnt
total_cnt = total_cnt + 1
pass
#print message
#!/usr/bin/env python
from main import create_app
from gevent import pywsgi
from geventwebsocket.handler import WebSocketHandler
if __name__ == '__main__':
# from flask_script import Manager
# manager = Manager(create_app())
# manager.run()
server = pywsgi.WSGIServer(('0.0.0.0', 5000), create_app(), handler_class=WebSocketHandler)
print('server start')
server.serve_forever()
