def init_app(config_file, name=None, **kwargs) -> Flask:
name = name or __name__
app = Flask(name, static_url_path='', **kwargs)
app.srv_config = create_from_config_file(Configuration,
entity_conf=[{
"class":
FedEntityConfiguration,
"attr":
"federation",
"path": ["federation"]
}],
filename=config_file,
base_path=dir_path)
# app.users = {'test_user': {'name': 'Testing Name'}}
try:
from .views import intermediate
except ImportError:
from views import intermediate
app.register_blueprint(intermediate)
# Initialize the oidc_provider after views to be able to set correct urls
app.server = init_entity(app.srv_config.federation, dir_path)
return app
def setUp(self):
modules.flags_manager.remove_all_flags()
self.app = Flask(__name__)
self.app.add_url_rule('/test', 'test', test_api, methods=['POST'])
init_flask('test_app', self.app, setup_kuber_config_loader=False)
flags.DEFINE_INTEGER_FLAG("test")
self.loader = KuberConfigLoader("test_service")
self.loader.load_config(
config_pb2.GlobalConfig(
flags=[{
"name": "test",
"type": "INTEGER",
"value": {
"base_value": {
"number_value": 1
}
}
}],
experiments={
2:
ExperimentDefinition(
id=2,
flag_values={
"test": FlagValue(base_value={"number_value": 2})
})
}))
self.server = Process(target=self.app.run, args=("127.0.0.1", 8008))
self.server.start()
sleep(1)
def create_app(config_name: str) -> Flask:
app = Flask(__name__)
app.config.from_object(config_by_name[config_name])
db.init_app(app)
flask_bcrypt.init_app(app)
ma.init_app(app)
return app
def test_register_handlers_registers_connection_handler_with_bindings_validation(
server_info: Info,
faker: Faker,
):
namespace = f"/{faker.pystr()}"
spec = AsyncApiSpec(
asyncapi=faker.pystr(),
info=server_info,
channels={
namespace:
Channel(bindings=ChannelBindings(
ws=WebSocketsChannelBindings(method="GET", )), )
},
)
server = new_mock_asynction_socket_io(spec)
flask_app = Flask(__name__)
server._register_handlers()
_, registered_handler, _ = server.handlers[0]
handler_with_validation = deep_unwrap(registered_handler, depth=1)
actual_handler = deep_unwrap(registered_handler)
with flask_app.test_client() as c:
with patch.object(server, "start_background_task"):
c.post() # Inject invalid POST request
actual_handler() # actual handler does not raise validation errors
with pytest.raises(BindingsValidationException):
handler_with_validation()
def app_secured_from_configuration():
app = Flask(__name__)
app.config["OPA_SECURED"] = True
app.config["OPA_URL"] = 'http://localhost:8181/v1/data/examples/allow'
app.opa = OPA(app, input_function=parse_input)
init_app(app)
return app
def test_start_background_daemon_task_with_threading_async_mode(
server_info: Info, faker: Faker):
spec = AsyncApiSpec(
asyncapi=faker.pystr(),
info=server_info,
channels={f"/{faker.pystr()}": Channel()},
)
server = new_mock_asynction_socket_io(spec,
app=Flask(__name__),
async_mode="threading")
def target():
# noop
pass
args = tuple(faker.pylist())
kwargs = faker.pydict()
with patch.object(threading, "Thread") as mock_thread_cls:
t = server.start_background_task(target, *args, **kwargs)
mock_thread_cls.assert_called_once_with(target=target,
args=args,
kwargs=kwargs,
daemon=True)
t.start.assert_called_once_with() # type: ignore
def create_app(spark_context, app):
global recommendationengine
recommendationengine = RecommendationEngine(spark_context, app)
app = Flask(__name__)
app.register_blueprint(main)
return app
def __init__(self,
dbUri='sqlite:///:memory:',
port=5000,
verbose=False,
serializer=jsonSerializerWithUri):
self.flaskApp = Flask(__name__,
static_url_path='',
static_folder=abspath('./static'))
print 'Using following sqlite database URI:', dbUri
self.flaskApp.config['SQLALCHEMY_DATABASE_URI'] = dbUri
self.flaskApp.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
if verbose:
self.flaskApp.config['SQLALCHEMY_ECHO'] = True
@self.flaskApp.route('/')
def index():
return self.flaskApp.send_static_file('index.html')
self.port = port
self.serializer = serializer
self.namespaces = {}
def create_app(config_name):
app = Flask(__name__)
print(__name__)
app.config.from_object(config[config_name])
bootstrap.init_app(app)
mail.init_app(app)
moment.init_app(app)
# 初始化db
db.init_app(app)
login_manager.init_app(app)
# 初始化日志配置
common = LogCommon()
app = common.init_log(app, 'log')
# 附加路由和自定义的错误页面
from app.pyweb.main import main
app.register_blueprint(main)
# 定义认证路由
from app.pyweb.auth import auth
app.register_blueprint(auth, url_prefix='/auth')
# 定义Captcha路由
from app.pyweb.captcha_chinese import captcha
app.register_blueprint(captcha, url_prefix='/captcha')
return app
def oidc_provider_init_app(config_file, name=None, **kwargs):
name = name or __name__
app = Flask(name, static_url_path='', **kwargs)
app.srv_config = create_from_config_file(Configuration,
entity_conf=[{
"class": FedRPConfiguration,
"attr": "rp"
}],
filename=config_file,
base_path=dir_path)
app.users = {'test_user': {'name': 'Testing Name'}}
try:
from .views import oidc_rp_views
except ImportError:
from views import oidc_rp_views
app.register_blueprint(oidc_rp_views)
# Initialize the oidc_provider after views to be able to set correct urls
app.rph = init_oidc_rp_handler(app.srv_config.rp, dir_path)
return app
def init_app(name=None):
name = name or __name__
app = Flask(name)
app.config.from_pyfile('application.cfg')
app.config.from_pyfile('production.cfg')
app.jinja_env.globals['GIT_HASH'] = get_git_hash()
#app.ldap_orm = Connection(app.config['LDAP_URL'], app.config['LDAP_BIND_DN'], app.config['LDAP_BIND_PW'], auto_bind=True)
server = Server(app.config['LDAP_URL'], get_info=ALL)
app.ldap_conn = Connection(server,
app.config['LDAP_BIND_DN'],
app.config['LDAP_BIND_PW'],
auto_bind=True)
model.ldap_conn = app.ldap_conn
model.base_dn = app.config['LDAP_BASE_DN']
from .model import db
db.init_app(app)
with app.app_context():
db.create_all()
app.babel = Babel(app)
init_oauth2(app)
app.login_manager = LoginManager(app)
#init hydra admin api
hydra_config = hydra.Configuration(
host=app.config['HYDRA_ADMIN_URL'],
username=app.config['HYDRA_ADMIN_USER'],
password=app.config['HYDRA_ADMIN_PASSWORD'])
hydra_client = hydra.ApiClient(hydra_config)
app.hydra_api = hydra.AdminApi(hydra_client)
from .views import auth_views, frontend_views, init_login_manager, api_views, pki_views, admin_views
init_login_manager(app)
app.register_blueprint(auth_views)
app.register_blueprint(frontend_views)
app.register_blueprint(api_views)
app.register_blueprint(pki_views)
app.register_blueprint(admin_views)
@app.before_request
def befor_request():
request_start_time = time.time()
g.request_time = lambda: "%.5fs" % (time.time() - request_start_time)
from .translations import init_babel
init_babel(app)
app.lenticular_services = {}
for service_name, service_config in app.config[
'LENTICULAR_CLOUD_SERVICES'].items():
app.lenticular_services[service_name] = model.Service.from_config(
service_name, service_config)
app.pki = Pki(app.config['PKI_PATH'], app.config['DOMAIN'])
return app
def main():
'''
This method registers all the end points of the application
'''
app = Flask(__name__)
api = Api(app)
api.add_resource(MyHanlder, '/api/hello')
return app
def create_app():
app = Flask(__name__)
from . import api
app.register_blueprint(api.bp)
app.height = int(os.environ.get('PREDICTOR_HEIGHT', '0'))
app.feature_type = os.environ.get('PREDICTOR_FEATURE_TYPE')
app.logger.debug(f"Building predictor: {app.feature_type}")
return app
def app():
"""Import the test app"""
app = Flask(__name__)
app.config["OPA_SECURED"] = True
app.config["OPA_URL"] = 'http://localhost:8181/v1/data/examples/allow'
app.opa = OPA(app, input_function=parse_input).secured()
init_app(app)
return app
def create_app(config_filename=None):
app = Flask(__name__)
app.config.from_object(hepdata_converter_ws)
from hepdata_converter_ws.api import api
app.register_blueprint(api)
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
bootstrap.init_app(app)
db.init_app(app)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
return app
def create_app(config_object: Type[Config] = DevConfig) -> Flask:
app = Flask(__name__)
app.config.from_object(config_object)
chained_function = chain(register_commands, register_blueprints,
register_extensions, register_handlers)
app = chained_function(app)
return app
def __create_server(self):
host = CONFIG.get_rest_api_host()
port = CONFIG.get_rest_api_port()
self.flask = Flask(__name__)
self.__werkzeug = make_server(host=host if host else self.DEFAULT_HOST,
port=port if port else self.DEFAULT_PORT,
app=self.flask)
# Suppress low level logging
logging.getLogger("werkzeug").setLevel(logging.WARNING)
def _create_json_record(xml_record):
object_record = create_record(etree.XML(xml_record))
app = Flask('hepcrawl')
app.config.update(self.settings.getdict('MARC_TO_HEP_SETTINGS',
{}))
with app.app_context():
dojson_record = hep.do(object_record)
return dojson_record
def create_app():
app = Flask(__name__)
from . import api
app.register_blueprint(api.bp)
app.identifier = os.environ.get('VECTORIZER_IDENTIFIER')
app.width = int(os.environ.get('VECTORIZER_WIDTH', '0'))
app.constructor = os.environ.get('VECTORIZER_CONSTRUCTOR')
app.logger.debug(f"Building vectorizer: {app.constructor}")
return app
def create_app(self):
from openbrokerapi.api import get_blueprint
app = Flask(__name__)
self.broker = Mock()
app.register_blueprint(
get_blueprint(self.broker, BrokerCredentials("", ""),
basic_config(level=logging.WARN)))
return app
def create_app(config_name: str = "default") -> Flask:
app = Flask(__name__)
init_config(app, config_name)
with app.app_context():
init_extensions(app)
init_blueprints(app)
init_commands(app)
return app
def main():
'''
This method registers all the end points of the application
'''
app = Flask(__name__)
app.secret_key = 'some_secret_key'
api = Api(app)
jwt = JWT(app, validate_user, get_user_based_on_identity)
api.add_resource(MyHanlder, '/api/hello')
return app
def create_app():
application = Flask(__name__)
application.secret_key = gen_random_password()
Bootstrap(application)
application.register_blueprint(base_bp)
application.register_blueprint(files_bp)
application.register_blueprint(helpers_bp)
return application
def setUp(self):
app = Flask(__name__)
app.testing = True
app.config["TESTING"] = True
setup_rest_api(app)
self.client = app.test_client
# Init db
DbSessionHolder(TestV1API.REST_TEST_DB).reset()
def _create_json_record(xml_record):
object_record = create_record(etree.XML(xml_record))
app = Flask('hepcrawl')
app.config.update(self.settings.getdict('MARC_TO_HEP_SETTINGS',
{}))
with app.app_context():
dojson_record = hep.do(object_record)
base_uri = self.settings['SCHEMA_BASE_URI']
dojson_record['$schema'] = base_uri + 'hep.json'
return dojson_record
def test_opa_create_with_staticmethod_deny_access():
app = Flask(__name__)
opa_url = 'http://localhost:8181/v1/data/dm/allow'
app.opa = OPA.secure(app, input_function=parse_input, url=opa_url)
init_app(app)
responses.add(responses.POST, opa_url, json={'result': False}, status=200)
response = app.test_client().get('/')
assert 403 == response.status_code
def init_app():
app = Flask(__name__)
app.config.from_object(config)
app.template_folder = config.template_folder
handler = RotatingFileHandler(config.log_path,
maxBytes=10000,
backupCount=1)
handler.setLevel(logging.INFO)
app.logger.addHandler(handler)
register_blueprints(app)
return app
def _create_environment(self, **kwargs):
if FLASK_VERSION < '0.7':
# Older Flask versions do not support the
# static_folder argument, which we need to use
# a temporary folder for static files, without
# having to do sys.path hacking.
raise SkipTest()
if not hasattr(self, 'app'):
self.app = Flask(__name__, static_folder=self.tempdir, **kwargs)
self.env = Environment(self.app)
return self.env
def create_app():
app = Flask(__name__)
bootstrap = Bootstrap(app)
app.config.from_object(Config)
# login manager inicializando la app
login_manager.init_app(app)
# Se registra el nuevo blueprint auth
app.register_blueprint(auth)
return app
