def create_app(config='config/genocrowd.ini',
app_name='genocrowd',
blueprints=None):
"""Create the Genocrowd app
Parameters
----------
config : str, optional
Path to the config file
app_name : str, optional
Application name
blueprints : None, optional
Flask blueprints
Returns
-------
Flask
Genocrowd Flask application
"""
conf = configparser.ConfigParser()
conf.read(config)
sentry_dsn = None
try:
sentry_dsn = conf['sentry']['server_dsn']
except Exception:
pass
if sentry_dsn:
version = get_distribution('genocrowd').version
name = get_distribution('genocrowd').project_name
sentry_sdk.init(dsn=sentry_dsn,
release="{}@{}".format(name, version),
integrations=[FlaskIntegration(),
CeleryIntegration()])
app = Flask(app_name, static_folder='static', template_folder='templates')
app.iniconfig = FlaskIni()
with app.app_context():
app.iniconfig.read(config)
proxy_path = None
try:
proxy_path = app.iniconfig.get('genocrowd', 'reverse_proxy_path')
app.config['REVERSE_PROXY_PATH'] = proxy_path
except Exception:
pass
mongo_dbname = app.iniconfig.get('flask', 'mongo_dbname')
app.config['MONGO_DBNAME'] = mongo_dbname
mongo_uri = app.iniconfig.get('flask', 'mongo_uri')
app.config['MONGO_URI'] = mongo_uri
if not mongo_uri:
raise Exception("Missing mongo_uri in config file")
if not mongo_dbname:
raise Exception("Missing mongo_dbname in config file")
app.mongo = PyMongo(app)
app.bcrypt = Bcrypt(app)
users = app.mongo.db.users
app.mongo.db.genes
app.mongo.db.answers
groups = app.mongo.db.groups
app.genocrowd_admin_email = app.iniconfig.get('genocrowd',
'genocrowd_admin_email')
app.genocrowd_admin_password = app.iniconfig.get(
'genocrowd', 'genocrowd_admin_password')
app.apollo_admin_email = app.iniconfig.get('genocrowd',
'apollo_admin_email')
app.apollo_admin_password = app.iniconfig.get('genocrowd',
'apollo_admin_password')
app.apollo_dataset_path = app.iniconfig.get('genocrowd',
'apollo_dataset_path')
app.apollo_org_id = app.iniconfig.get('genocrowd', 'apollo_org_id')
app.apollo_url = app.iniconfig.get('genocrowd', 'apollo_url')
# We don't want ending slash
if app.apollo_url.endswith("/"):
app.apollo_url = app.apollo_url[:-1]
app.apollo_url_ext = app.iniconfig.get('genocrowd', 'apollo_url_ext')
# We don't want ending slash
if app.apollo_url_ext.endswith("/"):
app.apollo_url_ext = app.apollo_url_ext[:-1]
configure_logging(app)
if users.find_one() is None:
# Create default admin user
local_auth = LocalAuth(app, None)
local_auth.add_user_to_database('admin', app.genocrowd_admin_email,
app.genocrowd_admin_password,
'admin', 'admin')
if blueprints is None:
blueprints = BLUEPRINTS
for blueprint in blueprints:
app.register_blueprint(blueprint)
if groups.find_one() is None:
# Initiate the groups database
data = Data(app, None)
data.initiate_groups()
if proxy_path:
ReverseProxyPrefixFix(app)
return app
import sentry_sdk
from sentry_sdk.integrations.celery import CeleryIntegration
from sentry_sdk.integrations.flask import FlaskIntegration
from sentry_sdk.integrations.redis import RedisIntegration
from sentry_sdk.integrations.sqlalchemy import SqlalchemyIntegration
from extensions import celery
from app import create_app
import config as c
app = create_app(for_celery=True)
app.app_context().push()
# add more external integrations below
if c.CELERY_SENTRY_DSN:
sentry_sdk.init(
c.CELERY_SENTRY_DSN,
integrations=[
CeleryIntegration(),
FlaskIntegration(),
RedisIntegration(),
SqlalchemyIntegration(),
],
)
def create_app(
name: str = __name__,
mode: ServerModes = ServerModes.NORMAL,
options: Optional[Dict[str, bool]] = None,
) -> Flask:
""" Create the server istance for Flask application """
if PRODUCTION and TESTING and not FORCE_PRODUCTION_TESTS: # pragma: no cover
print_and_exit("Unable to execute tests in production")
# TERM is not catched by Flask
# https://github.com/docker/compose/issues/4199#issuecomment-426109482
# signal.signal(signal.SIGTERM, teardown_handler)
# SIGINT is registered as STOPSIGNAL in Dockerfile
signal.signal(signal.SIGINT, teardown_handler)
# Flask app instance
# template_folder = template dir for output in HTML
microservice = Flask(
name, template_folder=os.path.join(ABS_RESTAPI_PATH, "templates")
)
# CORS
if not PRODUCTION:
cors = CORS(
allow_headers=[
"Content-Type",
"Authorization",
"X-Requested-With",
"x-upload-content-length",
"x-upload-content-type",
"content-range",
],
supports_credentials=["true"],
methods=["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"],
)
cors.init_app(microservice)
log.debug("CORS Injected")
# Flask configuration from config file
microservice.config.from_object(config)
log.debug("Flask app configured")
if PRODUCTION:
log.info("Production server mode is ON")
endpoints_loader = EndpointsLoader()
mem.configuration = endpoints_loader.load_configuration()
mem.initializer = Meta.get_class("initialization", "Initializer")
if not mem.initializer: # pragma: no cover
print_and_exit("Invalid Initializer class")
mem.customizer = Meta.get_instance("customization", "Customizer")
if not mem.customizer: # pragma: no cover
print_and_exit("Invalid Customizer class")
if not isinstance(mem.customizer, BaseCustomizer): # pragma: no cover
print_and_exit("Invalid Customizer class, it should inherit BaseCustomizer")
Connector.init_app(app=microservice, worker_mode=(mode == ServerModes.WORKER))
# Initialize reading of all files
mem.geo_reader = geolite2.reader()
# when to close??
# geolite2.close()
if mode == ServerModes.INIT:
Connector.project_init(options=options)
if mode == ServerModes.DESTROY:
Connector.project_clean()
# Restful plugin with endpoint mapping (skipped in INIT|DESTROY|WORKER modes)
if mode == ServerModes.NORMAL:
logging.getLogger("werkzeug").setLevel(logging.ERROR)
# ignore warning messages from apispec
warnings.filterwarnings(
"ignore", message="Multiple schemas resolved to the name "
)
mem.cache = Cache.get_instance(microservice)
endpoints_loader.load_endpoints()
mem.authenticated_endpoints = endpoints_loader.authenticated_endpoints
mem.private_endpoints = endpoints_loader.private_endpoints
# Triggering automatic mapping of REST endpoints
rest_api = Api(catch_all_404s=True)
for endpoint in endpoints_loader.endpoints:
# Create the restful resource with it;
# this method is from RESTful plugin
rest_api.add_resource(endpoint.cls, *endpoint.uris)
# HERE all endpoints will be registered by using FlaskRestful
rest_api.init_app(microservice)
# APISpec configuration
api_url = get_backend_url()
scheme, host = api_url.rstrip("/").split("://")
spec = APISpec(
title=get_project_configuration(
"project.title", default="Your application name"
),
version=get_project_configuration("project.version", default="0.0.1"),
openapi_version="2.0",
# OpenApi 3 not working with FlaskApiSpec
# -> Duplicate parameter with name body and location body
# https://github.com/jmcarp/flask-apispec/issues/170
# Find other warning like this by searching:
# **FASTAPI**
# openapi_version="3.0.2",
plugins=[MarshmallowPlugin()],
host=host,
schemes=[scheme],
tags=endpoints_loader.tags,
)
# OpenAPI 3 changed the definition of the security level.
# Some changes needed here?
api_key_scheme = {"type": "apiKey", "in": "header", "name": "Authorization"}
spec.components.security_scheme("Bearer", api_key_scheme)
microservice.config.update(
{
"APISPEC_SPEC": spec,
# 'APISPEC_SWAGGER_URL': '/api/swagger',
"APISPEC_SWAGGER_URL": None,
# 'APISPEC_SWAGGER_UI_URL': '/api/swagger-ui',
# Disable Swagger-UI
"APISPEC_SWAGGER_UI_URL": None,
}
)
mem.docs = FlaskApiSpec(microservice)
# Clean app routes
ignore_verbs = {"HEAD", "OPTIONS"}
for rule in microservice.url_map.iter_rules():
endpoint = microservice.view_functions[rule.endpoint]
if not hasattr(endpoint, "view_class"):
continue
newmethods = ignore_verbs.copy()
rulename = str(rule)
for verb in rule.methods - ignore_verbs:
method = verb.lower()
if method in endpoints_loader.uri2methods[rulename]:
# remove from flask mapping
# to allow 405 response
newmethods.add(verb)
rule.methods = newmethods
# Register swagger. Note: after method mapping cleaning
with microservice.app_context():
for endpoint in endpoints_loader.endpoints:
try:
mem.docs.register(endpoint.cls)
except TypeError as e: # pragma: no cover
print(e)
log.error("Cannot register {}: {}", endpoint.cls.__name__, e)
# marshmallow errors handler
microservice.register_error_handler(422, handle_marshmallow_errors)
# Logging responses
microservice.after_request(handle_response)
if SENTRY_URL is not None: # pragma: no cover
if PRODUCTION:
sentry_sdk.init(
dsn=SENTRY_URL,
# already catched by handle_marshmallow_errors
ignore_errors=[werkzeug.exceptions.UnprocessableEntity],
integrations=[FlaskIntegration()],
)
log.info("Enabled Sentry {}", SENTRY_URL)
else:
# Could be enabled in print mode
# sentry_sdk.init(transport=print)
log.info("Skipping Sentry, only enabled in PRODUCTION mode")
log.info("Boot completed")
return microservice
# Edita archivo hosts si es necesario
if os.environ['EDIT_HOSTS'] == 'true':
host_ip = os.environ['HOST_IP']
host_ad = os.environ['HOST_AD']
hosts = Hosts()
new_entry = HostsEntry(entry_type='ipv4',
address=host_ip,
names=[host_ad])
hosts.add([new_entry])
hosts.write()
# Configura sentry
sentry_sdk.init(
dsn=os.environ['SENTRY_DSN'],
integrations=[FlaskIntegration(), CeleryIntegration()],
)
# Obtiene las variables de ambiente
STP_PRIVATE_LOCATION = os.environ['STP_PRIVATE_LOCATION']
STP_BUCKET_S3 = os.environ['STP_BUCKET_S3']
STP_PRIVATE_KEY = os.environ['STP_PRIVATE_KEY']
STP_WSDL = os.environ['STP_WSDL']
STP_EMPRESA = os.environ['STP_EMPRESA']
STP_PREFIJO = os.environ['STP_PREFIJO']
DATABASE_URI = os.environ['DATABASE_URI']
app = Flask('speid')
app.config['MONGODB_HOST'] = DATABASE_URI
def init_sentry(sentry_config):
sentry_sdk.init(dsn=sentry_config["SENTRY_DSN"],
release=sentry_config["RELEASE"],
integrations=[FlaskIntegration()])
def init_logging():
flask_env = os.getenv('FLASK_ENV')
sentry_dns = os.getenv('SENTRY_DSN')
if flask_env != 'dev' and sentry_dns is not None:
sentry_logging = LoggingIntegration(
level=logging.INFO, # Capture info and above as breadcrumbs
event_level=logging.ERROR # Send errors as events
)
sentry_sdk.init(dsn=sentry_dns,
environment=flask_env,
integrations=[sentry_logging,
FlaskIntegration()])
with configure_scope() as scope:
scope.user = {'node_id': common.node_id()}
logging_config = {
'version': 1,
'disable_existing_loggers': False,
'formatters': {
'f': {
'format': '%(asctime)s [%(levelname)s] %(message)s',
'datefmt': '%Y-%m-%d %H:%M:%S'
},
},
'handlers': {
'console': {
'class': 'logging.StreamHandler',
'formatter': 'f',
'level': 'INFO',
},
'file': {
'class': 'logging.handlers.RotatingFileHandler',
'level': 'INFO',
'formatter': 'f',
'filename': 'logs/validation_node.log',
'mode': 'a',
},
'error_file': {
'class': 'logging.handlers.RotatingFileHandler',
'level': 'INFO',
'formatter': 'f',
'filename': 'logs/gunicorn.error.log',
'mode': 'a',
},
'access_file': {
'class': 'logging.FileHandler',
'formatter': 'f',
'filename': 'logs/gunicorn.access.log',
},
},
'root': {
'handlers': ['console', 'file'],
'level': 'INFO',
'propagate': True,
},
'loggers': {
'gunicorn.error': {
'level': 'INFO',
'handlers': ['console', 'error_file'],
'propagate': True
},
'gunicorn.access': {
'level': 'INFO',
'handlers': ['access_file'],
'propagate': False
},
}
}
dictConfig(logging_config)
def create_app(
name: str = __name__,
mode: ServerModes = ServerModes.NORMAL,
options: Optional[Dict[str, bool]] = None,
) -> Flask:
"""Create the server istance for Flask application"""
if PRODUCTION and TESTING and not FORCE_PRODUCTION_TESTS: # pragma: no cover
print_and_exit("Unable to execute tests in production")
# TERM is not catched by Flask
# https://github.com/docker/compose/issues/4199#issuecomment-426109482
# signal.signal(signal.SIGTERM, teardown_handler)
# SIGINT is registered as STOPSIGNAL in Dockerfile
signal.signal(signal.SIGINT, teardown_handler)
# Flask app instance
# template_folder = template dir for output in HTML
flask_app = Flask(name, template_folder=str(ABS_RESTAPI_PATH.joinpath("templates")))
# CORS
if not PRODUCTION:
if TESTING:
cors_origin = "*"
else: # pragma: no cover
cors_origin = get_frontend_url()
# Beware, this only works because get_frontend_url never append a port
cors_origin += ":*"
CORS(
flask_app,
allow_headers=[
"Content-Type",
"Authorization",
"X-Requested-With",
"x-upload-content-length",
"x-upload-content-type",
"content-range",
],
supports_credentials=["true"],
methods=["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"],
resources={r"*": {"origins": cors_origin}},
)
log.debug("CORS Enabled")
# Flask configuration from config file
flask_app.config.from_object(config)
flask_app.json_encoder = ExtendedJSONEncoder
# Used to force flask to avoid json sorting and ensure that
# the output to reflect the order of field in the Marshmallow schema
flask_app.config["JSON_SORT_KEYS"] = False
log.debug("Flask app configured")
if PRODUCTION:
log.info("Production server mode is ON")
endpoints_loader = EndpointsLoader()
if HOST_TYPE == DOCS: # pragma: no cover
log.critical("Creating mocked configuration")
mem.configuration = {}
log.critical("Loading Mocked Initializer and Customizer classes")
from restapi.mocks import Customizer, Initializer
mem.initializer = Initializer
mem.customizer = Customizer()
else:
mem.configuration = endpoints_loader.load_configuration()
mem.initializer = Meta.get_class("initialization", "Initializer")
if not mem.initializer: # pragma: no cover
print_and_exit("Invalid Initializer class")
customizer = Meta.get_class("customization", "Customizer")
if not customizer: # pragma: no cover
print_and_exit("Invalid Customizer class")
mem.customizer = customizer()
if not isinstance(mem.customizer, BaseCustomizer): # pragma: no cover
print_and_exit("Invalid Customizer class, it should inherit BaseCustomizer")
Connector.init_app(app=flask_app, worker_mode=(mode == ServerModes.WORKER))
# Initialize reading of all files
mem.geo_reader = geolite2.reader()
# when to close??
# geolite2.close()
if mode == ServerModes.INIT:
Connector.project_init(options=options)
if mode == ServerModes.DESTROY:
Connector.project_clean()
# Restful plugin with endpoint mapping (skipped in INIT|DESTROY|WORKER modes)
if mode == ServerModes.NORMAL:
logging.getLogger("werkzeug").setLevel(logging.ERROR)
# warnings levels:
# default # Warn once per call location
# error # Convert to exceptions
# always # Warn every time
# module # Warn once per calling module
# once # Warn once per Python process
# ignore # Never warn
# Types of warnings:
# Warning: This is the base class of all warning category classes
# UserWarning: The default category for warn().
# DeprecationWarning: Base category for warnings about deprecated features when
# those warnings are intended for other Python developers
# SyntaxWarning: Base category for warnings about dubious syntactic features.
# RuntimeWarning: Base category for warnings about dubious runtime features.
# FutureWarning: Base category for warnings about deprecated features when those
# warnings are intended for end users
# PendingDeprecationWarning: Base category for warnings about features that will
# be deprecated in the future (ignored by default).
# ImportWarning: Base category for warnings triggered during the process of
# importing a module
# UnicodeWarning: Base category for warnings related to Unicode.
# BytesWarning: Base category for warnings related to bytes and bytearray.
# ResourceWarning: Base category for warnings related to resource usage
if TESTING:
warnings.simplefilter("always", Warning)
warnings.simplefilter("error", UserWarning)
warnings.simplefilter("error", DeprecationWarning)
warnings.simplefilter("error", SyntaxWarning)
warnings.simplefilter("error", RuntimeWarning)
warnings.simplefilter("error", FutureWarning)
# warnings about features that will be deprecated in the future
warnings.simplefilter("default", PendingDeprecationWarning)
warnings.simplefilter("error", ImportWarning)
warnings.simplefilter("error", UnicodeWarning)
warnings.simplefilter("error", BytesWarning)
# Can't set this an error due to false positives with downloads
# a lot of issues like: https://github.com/pallets/flask/issues/2468
warnings.simplefilter("always", ResourceWarning)
warnings.simplefilter("default", Neo4jExperimentalWarning)
# Remove me in a near future, this is due to hypothesis with pytest 7
# https://github.com/HypothesisWorks/hypothesis/issues/3222
warnings.filterwarnings(
"ignore", message="A private pytest class or function was used."
)
elif PRODUCTION: # pragma: no cover
warnings.simplefilter("ignore", Warning)
warnings.simplefilter("always", UserWarning)
warnings.simplefilter("default", DeprecationWarning)
warnings.simplefilter("ignore", SyntaxWarning)
warnings.simplefilter("ignore", RuntimeWarning)
warnings.simplefilter("ignore", FutureWarning)
warnings.simplefilter("ignore", PendingDeprecationWarning)
warnings.simplefilter("ignore", ImportWarning)
warnings.simplefilter("ignore", UnicodeWarning)
warnings.simplefilter("ignore", BytesWarning)
warnings.simplefilter("ignore", ResourceWarning)
# even if ignore it is raised once
# because of the imports executed before setting this to ignore
warnings.simplefilter("ignore", Neo4jExperimentalWarning)
else: # pragma: no cover
warnings.simplefilter("default", Warning)
warnings.simplefilter("always", UserWarning)
warnings.simplefilter("always", DeprecationWarning)
warnings.simplefilter("default", SyntaxWarning)
warnings.simplefilter("default", RuntimeWarning)
warnings.simplefilter("always", FutureWarning)
warnings.simplefilter("default", PendingDeprecationWarning)
warnings.simplefilter("default", ImportWarning)
warnings.simplefilter("default", UnicodeWarning)
warnings.simplefilter("default", BytesWarning)
warnings.simplefilter("always", ResourceWarning)
# even if ignore it is raised once
# because of the imports executed before setting this to ignore
warnings.simplefilter("ignore", Neo4jExperimentalWarning)
# ignore warning messages from apispec
warnings.filterwarnings(
"ignore", message="Multiple schemas resolved to the name "
)
# ignore warning messages on flask socket after teardown
warnings.filterwarnings("ignore", message="unclosed <socket.socket")
# from flask_caching 1.10.1 with python 3.10 on core tests...
# try to remove this once upgraded flask_caching in a near future
warnings.filterwarnings(
"ignore",
message="_SixMetaPathImporter.find_spec",
)
# Raised from sentry_sdk 1.5.11 with python 3.10 events
warnings.filterwarnings(
"ignore",
message="SelectableGroups dict interface is deprecated. Use select.",
)
mem.cache = Cache.get_instance(flask_app)
endpoints_loader.load_endpoints()
mem.authenticated_endpoints = endpoints_loader.authenticated_endpoints
mem.private_endpoints = endpoints_loader.private_endpoints
for endpoint in endpoints_loader.endpoints:
ename = endpoint.cls.__name__.lower()
endpoint_view = endpoint.cls.as_view(ename)
for url in endpoint.uris:
flask_app.add_url_rule(url, view_func=endpoint_view)
# APISpec configuration
api_url = get_backend_url()
scheme, host = api_url.rstrip("/").split("://")
spec = APISpec(
title=get_project_configuration(
"project.title", default="Your application name"
),
version=get_project_configuration("project.version", default="0.0.1"),
openapi_version="2.0",
# OpenApi 3 not working with FlaskApiSpec
# -> Duplicate parameter with name body and location body
# https://github.com/jmcarp/flask-apispec/issues/170
# Find other warning like this by searching:
# **FASTAPI**
# openapi_version="3.0.2",
plugins=[MarshmallowPlugin()],
host=host,
schemes=[scheme],
tags=endpoints_loader.tags,
)
# OpenAPI 3 changed the definition of the security level.
# Some changes needed here?
if Env.get_bool("AUTH_ENABLE"):
api_key_scheme = {"type": "apiKey", "in": "header", "name": "Authorization"}
spec.components.security_scheme("Bearer", api_key_scheme)
flask_app.config.update(
{
"APISPEC_SPEC": spec,
# 'APISPEC_SWAGGER_URL': '/api/swagger',
"APISPEC_SWAGGER_URL": None,
# 'APISPEC_SWAGGER_UI_URL': '/api/swagger-ui',
# Disable Swagger-UI
"APISPEC_SWAGGER_UI_URL": None,
}
)
mem.docs = FlaskApiSpec(flask_app)
# Clean app routes
ignore_verbs = {"HEAD", "OPTIONS"}
for rule in flask_app.url_map.iter_rules():
view_function = flask_app.view_functions[rule.endpoint]
if not hasattr(view_function, "view_class"):
continue
newmethods = ignore_verbs.copy()
rulename = str(rule)
if rule.methods:
for verb in rule.methods - ignore_verbs:
method = verb.lower()
if method in endpoints_loader.uri2methods[rulename]:
# remove from flask mapping
# to allow 405 response
newmethods.add(verb)
rule.methods = newmethods
# Register swagger. Note: after method mapping cleaning
with flask_app.app_context():
for endpoint in endpoints_loader.endpoints:
try:
mem.docs.register(endpoint.cls)
except TypeError as e: # pragma: no cover
print(e)
log.error("Cannot register {}: {}", endpoint.cls.__name__, e)
# marshmallow errors handler
# Can't get the typing to work with flask 2.1
flask_app.register_error_handler(422, handle_marshmallow_errors) # type: ignore
flask_app.register_error_handler(400, handle_http_errors) # type: ignore
flask_app.register_error_handler(404, handle_http_errors) # type: ignore
flask_app.register_error_handler(405, handle_http_errors) # type: ignore
flask_app.register_error_handler(500, handle_http_errors) # type: ignore
# flask_app.before_request(inspect_request)
# Logging responses
# Can't get the typing to work with flask 2.1
flask_app.after_request(handle_response) # type: ignore
if SENTRY_URL is not None: # pragma: no cover
if PRODUCTION:
sentry_sdk_init(
dsn=SENTRY_URL,
# already catched by handle_marshmallow_errors
ignore_errors=[werkzeug.exceptions.UnprocessableEntity],
integrations=[FlaskIntegration()],
)
log.info("Enabled Sentry {}", SENTRY_URL)
else:
# Could be enabled in print mode
# sentry_sdk_init(transport=print)
log.info("Skipping Sentry, only enabled in PRODUCTION mode")
log.info("Boot completed")
if PRODUCTION and not TESTING and name == MAIN_SERVER_NAME: # pragma: no cover
save_event_log(
event=Events.server_startup,
payload={"server": name},
user=None,
target=None,
)
return flask_app
from entropy_helper import EntropyHelper
from util import number_format, detect_browser_and_platform, get_tool_recommendation
from db import Db
app = Flask(__name__)
app.secret_key = config.secret_key
app.debug = config.debug
app.permanent_session_lifetime = timedelta(days=config.epoch_days)
app.config.update(
USE_MATOMO=config.use_matomo,
MATOMO_URL=config.matomo_url,
MATOMO_SITE_ID=config.matomo_site_id,
)
if config.sentry_dsn:
sentry_sdk.init(config.sentry_dsn, integrations=[FlaskIntegration()])
def read_keyfile():
global key
with open(
config.keyfile,
'rb',
) as fp:
key = fp.read(16)
read_keyfile()
def require_admin_pass(route):
# Initial require, the above line contains our endpoints.
config = json.load(open('config.json'))
endpoints = None
app = Flask(__name__, template_folder='views', static_folder='views/assets')
app.register_blueprint(dash)
app.config['SECRET_KEY'] = config['client_secret']
os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = 'true'
if 'sentry_dsn' in config:
import sentry_sdk
from sentry_sdk.integrations.flask import FlaskIntegration
sentry_sdk.init(config['sentry_dsn'], integrations=[FlaskIntegration()])
@app.before_first_request
def init_app():
def run_gc_forever(loop):
asyncio.set_event_loop(loop)
try:
loop.run_forever()
except (SystemExit, KeyboardInterrupt):
loop.close()
gc_loop = asyncio.new_event_loop()
gc_thread = threading.Thread(target=run_gc_forever, args=(gc_loop, ))
gc_thread.start()
g.gc_loop = gc_loop
def create_app():
global app_created
if not app_created:
BlueprintsManager.register(app)
Migrate(app, db)
app.config.from_object(env('APP_CONFIG',
default='config.ProductionConfig'))
if not app.config['SECRET_KEY']:
if app.config['PRODUCTION']:
app.logger.error(
'SECRET_KEY must be set in .env or environment variables in production'
)
exit(1)
else:
random_secret = secrets.token_hex()
app.logger.warning(
f'Using random secret "{ random_secret }" for development server. '
'This is NOT recommended. Set proper SECRET_KEY in .env or environment variables'
)
app.config['SECRET_KEY'] = random_secret
db.init_app(app)
if app.config['CACHING']:
cache.init_app(app, config={'CACHE_TYPE': 'simple'})
else:
cache.init_app(app, config={'CACHE_TYPE': 'null'})
stripe.api_key = 'SomeStripeKey'
app.config['JSONIFY_PRETTYPRINT_REGULAR'] = False
app.config['FILE_SYSTEM_STORAGE_FILE_VIEW'] = 'static'
app.logger.addHandler(logging.StreamHandler(sys.stdout))
app.logger.setLevel(logging.ERROR)
# set up jwt
app.config['JWT_HEADER_TYPE'] = 'JWT'
app.config['JWT_ACCESS_TOKEN_EXPIRES'] = timedelta(days=1)
app.config['JWT_REFRESH_TOKEN_EXPIRES'] = timedelta(days=365)
app.config['JWT_ERROR_MESSAGE_KEY'] = 'error'
app.config['JWT_TOKEN_LOCATION'] = ['cookies', 'headers']
app.config['JWT_REFRESH_COOKIE_PATH'] = '/v1/auth/token/refresh'
app.config['JWT_SESSION_COOKIE'] = False
app.config['JWT_BLACKLIST_ENABLED'] = True
app.config['JWT_BLACKLIST_TOKEN_CHECKS'] = ['refresh']
_jwt = JWTManager(app)
_jwt.user_loader_callback_loader(jwt_user_loader)
_jwt.token_in_blacklist_loader(is_token_blacklisted)
# setup celery
app.config['CELERY_BROKER_URL'] = app.config['REDIS_URL']
app.config['CELERY_RESULT_BACKEND'] = app.config['CELERY_BROKER_URL']
app.config['CELERY_ACCEPT_CONTENT'] = ['json', 'application/text']
CORS(app, resources={r"/*": {"origins": "*"}})
AuthManager.init_login(app)
if app.config['TESTING'] and app.config['PROFILE']:
# Profiling
app.wsgi_app = ProfilerMiddleware(app.wsgi_app, restrictions=[30])
# development api
with app.app_context():
from app.api.admin_statistics_api.events import event_statistics
from app.api.auth import auth_routes
from app.api.custom.attendees import attendee_blueprint
from app.api.bootstrap import api_v1
from app.api.celery_tasks import celery_routes
from app.api.event_copy import event_copy
from app.api.exports import export_routes
from app.api.imports import import_routes
from app.api.uploads import upload_routes
from app.api.users import user_misc_routes
from app.api.orders import order_misc_routes
from app.api.role_invites import role_invites_misc_routes
from app.api.auth import authorised_blueprint
from app.api.admin_translations import admin_blueprint
from app.api.orders import alipay_blueprint
from app.api.settings import admin_misc_routes
from app.api.server_version import info_route
from app.api.custom.orders import ticket_blueprint
from app.api.custom.orders import order_blueprint
from app.api.custom.invoices import event_blueprint
app.register_blueprint(api_v1)
app.register_blueprint(event_copy)
app.register_blueprint(upload_routes)
app.register_blueprint(export_routes)
app.register_blueprint(import_routes)
app.register_blueprint(celery_routes)
app.register_blueprint(auth_routes)
app.register_blueprint(event_statistics)
app.register_blueprint(user_misc_routes)
app.register_blueprint(attendee_blueprint)
app.register_blueprint(order_misc_routes)
app.register_blueprint(role_invites_misc_routes)
app.register_blueprint(authorised_blueprint)
app.register_blueprint(admin_blueprint)
app.register_blueprint(alipay_blueprint)
app.register_blueprint(admin_misc_routes)
app.register_blueprint(info_route)
app.register_blueprint(ticket_blueprint)
app.register_blueprint(order_blueprint)
app.register_blueprint(event_blueprint)
add_engine_pidguard(db.engine)
if app.config['SQLALCHEMY_DATABASE_URI'].startswith("sqlite://"):
sqlite_datetime_fix()
sa.orm.configure_mappers()
if app.config['SERVE_STATIC']:
app.add_url_rule('/static/<path:filename>',
endpoint='static',
view_func=app.send_static_file)
# sentry
if not app_created and 'SENTRY_DSN' in app.config:
sentry_sdk.init(
app.config['SENTRY_DSN'],
integrations=[
FlaskIntegration(),
RedisIntegration(),
CeleryIntegration(),
SqlalchemyIntegration(),
],
)
# redis
redis_store.init_app(app)
# Initialize Extensions
shell.init_app(app)
limiter.init_app(app)
app_created = True
return app
from opendc.models.user import User
from opendc.util import rest, path_parser, database
from opendc.util.exceptions import AuthorizationTokenError, RequestInitializationError
from opendc.util.json import JSONEncoder
load_dotenv()
TEST_MODE = "OPENDC_FLASK_TESTING" in os.environ
# Setup Sentry if DSN is specified
if 'SENTRY_DSN' in os.environ:
import sentry_sdk
from sentry_sdk.integrations.flask import FlaskIntegration
sentry_sdk.init(integrations=[FlaskIntegration()], traces_sample_rate=0.1)
# Set up database if not testing
if not TEST_MODE:
database.DB.initialize_database(user=os.environ['OPENDC_DB_USERNAME'],
password=os.environ['OPENDC_DB_PASSWORD'],
database=os.environ['OPENDC_DB'],
host=os.environ.get(
'OPENDC_DB_HOST', 'localhost'))
# Set up the core app
FLASK_CORE_APP = Flask(__name__)
FLASK_CORE_APP.testing = TEST_MODE
FLASK_CORE_APP.config['SECRET_KEY'] = os.environ['OPENDC_FLASK_SECRET']
FLASK_CORE_APP.json_encoder = JSONEncoder
import functools
import os
from flask import Flask, Response, send_file, request
from flask_cors import CORS, cross_origin
app = Flask(__name__)
CORS(app)
SENTRY_SDK = os.getenv("SENTRY_SDK")
if SENTRY_SDK:
import sentry_sdk
from sentry_sdk.integrations.flask import FlaskIntegration
sentry_sdk.init(SENTRY_SDK, integrations=[FlaskIntegration()])
def handle_text_turtle(filename='profile.ttl', **kwargs):
return send_file(filename, mimetype='text/turtle')
def handle_other(filename='profile.ttl',
format='trig',
mimetype='application/trig'):
import rdflib
g = rdflib.Graph()
g.parse(source=filename, format='text/turtle')
return Response(g.serialize(format=format), mimetype=mimetype)
from sentry_sdk.integrations.rq import RqIntegration
app = flask.Flask(__name__)
redis_conn = redis.Redis()
http = urllib3.PoolManager()
queue = rq.Queue(connection=redis_conn)
def write_event(event):
with open("events", "a") as f:
f.write(json.dumps(event))
f.write("\n")
sentry_sdk.init(
integrations=[FlaskIntegration(), RqIntegration()],
traces_sample_rate=1.0,
traceparent_v2=True,
debug=True,
transport=write_event,
)
def decode_base64(encoded, redis_key):
time.sleep(1)
r = http.request("GET", "http://httpbin.org/base64/{}".format(encoded))
redis_conn.set(redis_key, r.data)
@app.route("/")
def index():
from bu_cascade.asset_tools import find, update
from flask import Flask, render_template
from flask_classy import FlaskView, route
import sentry_sdk
# Imports from elsewhere in this project
from mail import send_message
from config import WSDL, AUTH, SITE_ID, STAGING_DESTINATION_ID, XML_URL
app = Flask(__name__)
app.config.from_object('config')
if app.config['SENTRY_URL']:
from sentry_sdk.integrations.flask import FlaskIntegration
sentry_sdk.init(dsn=app.config['SENTRY_URL'], integrations=[FlaskIntegration()])
class CascadeBlockProcessor:
def __init__(self):
self.cascade = Cascade(WSDL, AUTH, SITE_ID, STAGING_DESTINATION_ID)
self.codes_found_in_cascade = []
self.codes_not_found_in_banner = []
def get_new_banner_data(self):
return json.loads(requests.get('https://wsapi.bethel.edu/program-data').content)
def process_all_blocks(self, time_to_wait, send_email_after):
new_banner_data = self.get_new_banner_data()
if len(new_banner_data) == 0:
def create_app(config_name="default"):
application = Flask(__name__, instance_relative_config=True)
from jinja2 import select_autoescape
# CONFIG
from config import configs
application.config.from_object(configs[config_name])
print(f"DB INFO: using {application.config['INFO_USED_DB']}")
# APPS
db.init_app(application)
migrate.init_app(application, db)
security.init_app(application, user_datastore)
babel.init_app(application)
turbo.init_app(application)
mail.init_app(application)
dropzone.init_app(application)
if application.config["SENTRY_MONITORING"]:
import sentry_sdk
from sentry_sdk.integrations.flask import FlaskIntegration
from sentry_sdk.integrations.sqlalchemy import SqlalchemyIntegration
sentry_sdk.init(
dsn="https://[email protected]/5776351",
integrations=[FlaskIntegration(), SqlalchemyIntegration()],
traces_sample_rate=1.0,
)
else:
print("No Sentry monitoring.")
# LOGGING
# from .config.config_logging import db_handler, gunicorn_logger
# application.logger.addHandler(gunicorn_logger)
# application.logger.addHandler(db_handler)
# CONTROLLERS
from .controllers import register_all_controllers # noqa: F401
register_all_controllers(application)
from .controllers import register_error_handlers # noqa: F401
register_error_handlers(application)
# MODULES
from app.modules.auth.auth import blueprint as google_oauth_bp
application.register_blueprint(google_oauth_bp, url_prefix="/oauth/")
if application.config["APP_STATE"] in ("test", "testing"):
with application.app_context():
# from app.helpers.tests.fill_db import db_fill
db.create_all()
print("Created database")
# db_fill()
application.jinja_options = {
"autoescape": select_autoescape(enabled_extensions=("html", "html.j2", "xml")),
"line_statement_prefix": "#",
"line_comment_prefix": "##",
}
return application
import sentry_sdk
from flask import Flask, session
from sentry_sdk.integrations.flask import FlaskIntegration
from sentry_sdk.integrations.redis import RedisIntegration
from bot.data import database, logger
from bot.functions import user_setup
sentry_sdk.init(
release=f"{os.getenv('CURRENT_PLATFORM')} Release " +
(f"{os.getenv('GIT_REV')[:8]}"
if os.getenv("CURRENT_PLATFORM") != "Heroku" else
f"{os.getenv('HEROKU_RELEASE_VERSION')}:{os.getenv('HEROKU_SLUG_DESCRIPTION')}"
),
dsn=os.getenv("SENTRY_API_DSN"),
integrations=[FlaskIntegration(), RedisIntegration()],
)
app = Flask(__name__)
app.config["SEND_FILE_MAX_AGE_DEFAULT"] = 0
app.config["SESSION_COOKIE_SAMESITE"] = "Strict"
app.config["SESSION_COOKIE_SECURE"] = True
app.secret_key = os.getenv("FLASK_SECRET_KEY")
FRONTEND_URL = os.getenv("FRONTEND_URL")
DATABASE_SESSION_EXPIRE = 172800 # 2 days
@app.after_request # enable CORS
def after_request(response):
header = response.headers
header["Access-Control-Allow-Origin"] = FRONTEND_URL
header["Access-Control-Allow-Credentials"] = "true"
from belastingen.api.belastingen.exceptions import K2bAuthenticationError
from belastingen.api.belastingen.key2belastingen import K2bConnection
from belastingen.config import (
get_sentry_dsn,
get_tma_certificate,
get_K2B_api_location,
get_bearer_token,
)
logger = logging.getLogger(__name__)
app = Flask(__name__)
if get_sentry_dsn(): # pragma: no cover
sentry_sdk.init(
dsn=get_sentry_dsn(), integrations=[FlaskIntegration()], with_locals=False
)
def get_bsn_from_request(request):
"""
Get the BSN based on a request, expecting a SAML token in the headers
"""
# Load the TMA certificate
tma_certificate = get_tma_certificate()
# Decode the BSN from the request with the TMA certificate
bsn = get_digi_d_bsn(request, tma_certificate)
return bsn
def setup_bot(backend_name: str, logger, config, restore=None) -> ErrBot:
# from here the environment is supposed to be set (daemon / non daemon,
# config.py in the python path )
bot_config_defaults(config)
if hasattr(config, 'BOT_LOG_FORMATTER'):
format_logs(formatter=config.BOT_LOG_FORMATTER)
else:
format_logs(theme_color=config.TEXT_COLOR_THEME)
if config.BOT_LOG_FILE:
hdlr = logging.FileHandler(config.BOT_LOG_FILE)
hdlr.setFormatter(
logging.Formatter(
"%(asctime)s %(levelname)-8s %(name)-25s %(message)s"))
logger.addHandler(hdlr)
if hasattr(config, 'BOT_LOG_SENTRY') and config.BOT_LOG_SENTRY:
sentry_integrations = []
try:
import sentry_sdk
from sentry_sdk.integrations.logging import LoggingIntegration
except ImportError:
log.exception(
"You have BOT_LOG_SENTRY enabled, but I couldn't import modules "
"needed for Sentry integration. Did you install sentry-sdk? "
"(See https://docs.sentry.io/platforms/python for installation instructions)"
)
exit(-1)
sentry_logging = LoggingIntegration(
level=config.SENTRY_LOGLEVEL, event_level=config.SENTRY_EVENTLEVEL)
sentry_integrations.append(sentry_logging)
if hasattr(config,
'BOT_LOG_SENTRY_FLASK') and config.BOT_LOG_SENTRY_FLASK:
try:
from sentry_sdk.integrations.flask import FlaskIntegration
except ImportError:
log.exception(
"You have BOT_LOG_SENTRY enabled, but I couldn't import modules "
"needed for Sentry integration. Did you install sentry-sdk[flask]? "
"(See https://docs.sentry.io/platforms/python/flask for installation instructions)"
)
exit(-1)
sentry_integrations.append(FlaskIntegration())
try:
if hasattr(config, 'SENTRY_TRANSPORT') and isinstance(
config.SENTRY_TRANSPORT, tuple):
mod = importlib.import_module(config.SENTRY_TRANSPORT[1])
transport = getattr(mod, config.SENTRY_TRANSPORT[0])
sentry_sdk.init(dsn=config.SENTRY_DSN,
integrations=sentry_integrations,
transport=transport)
else:
sentry_sdk.init(dsn=config.SENTRY_DSN,
integrations=sentry_integrations)
except ImportError:
log.exception(
f'Unable to import selected SENTRY_TRANSPORT - {config.SENTRY_TRANSPORT}'
)
exit(-1)
logger.setLevel(config.BOT_LOG_LEVEL)
storage_plugin = get_storage_plugin(config)
# init the botplugin manager
botplugins_dir = path.join(config.BOT_DATA_DIR, PLUGINS_SUBDIR)
if not path.exists(botplugins_dir):
makedirs(botplugins_dir, mode=0o755)
plugin_indexes = getattr(config, 'BOT_PLUGIN_INDEXES',
(PLUGIN_DEFAULT_INDEX, ))
if isinstance(plugin_indexes, str):
plugin_indexes = (plugin_indexes, )
# Extra backend is expected to be a list type, convert string to list.
extra_backend = getattr(config, 'BOT_EXTRA_BACKEND_DIR', [])
if isinstance(extra_backend, str):
extra_backend = [extra_backend]
backendpm = BackendPluginManager(config, 'errbot.backends', backend_name,
ErrBot, CORE_BACKENDS, extra_backend)
log.info(f'Found Backend plugin: {backendpm.plugin_info.name}')
repo_manager = BotRepoManager(storage_plugin, botplugins_dir,
plugin_indexes)
try:
bot = backendpm.load_plugin()
botpm = BotPluginManager(
storage_plugin,
config.BOT_EXTRA_PLUGIN_DIR, config.AUTOINSTALL_DEPS,
getattr(config, 'CORE_PLUGINS',
None), lambda name, clazz: clazz(bot, name),
getattr(config, 'PLUGINS_CALLBACK_ORDER', (None, )))
bot.attach_storage_plugin(storage_plugin)
bot.attach_repo_manager(repo_manager)
bot.attach_plugin_manager(botpm)
bot.initialize_backend_storage()
# restore the bot from the restore script
if restore:
# Prepare the context for the restore script
if 'repos' in bot:
log.fatal('You cannot restore onto a non empty bot.')
sys.exit(-1)
log.info(f'**** RESTORING the bot from {restore}')
restore_bot_from_backup(restore, bot=bot, log=log)
print('Restore complete. You can restart the bot normally')
sys.exit(0)
errors = bot.plugin_manager.update_plugin_places(
repo_manager.get_all_repos_paths())
if errors:
log.error('Some plugins failed to load:\n' +
'\n'.join(errors.values()))
bot._plugin_errors_during_startup = "\n".join(errors.values())
return bot
except Exception:
log.exception("Unable to load or configure the backend.")
exit(-1)
def make_application(config_filename=None, tests=False):
if config_filename is None:
config_filename = os.environ.get('ACOUSTID_CONFIG')
script = Script(config_filename, tests=tests)
script.setup_logging()
config = script.config
app = Flask('acoustid.web')
app.config.update(
DEBUG=config.website.debug,
SECRET_KEY=config.website.secret,
MB_OAUTH_CLIENT_ID=config.website.mb_oauth_client_id,
MB_OAUTH_CLIENT_SECRET=config.website.mb_oauth_client_secret,
GOOGLE_OAUTH_CLIENT_ID=config.website.google_oauth_client_id,
GOOGLE_OAUTH_CLIENT_SECRET=config.website.google_oauth_client_secret,
)
app.acoustid_script = script
app.acoustid_config = config
app.acoustid_config_filename = config_filename
app.wsgi_app = ProxyFix(app.wsgi_app)
sentry_sdk.init(config.sentry.web_dsn,
release=GIT_RELEASE,
integrations=[FlaskIntegration()])
# can't use json because of python-openid
app.session_interface = SecureCookieSessionInterface()
app.session_interface.serializer = pickle
@app.context_processor
def inject_common_values():
show_donate_banner = False
if datetime.date.today().month in (11, 12):
show_donate_banner = True
return dict(
account_id=session.get('id'),
show_maintenace_banner=config.website.maintenance,
show_donate_banner=show_donate_banner,
morris_js_version='0.5.1',
raphael_js_version='2.1.4',
bootstrap_version='3.3.6',
jquery_version='1.12.0',
)
def get_flask_request_scope():
try:
return id(request._get_current_object())
except RuntimeError:
return 0
@app.teardown_request
def close_db_session(*args, **kwargs):
db.session.remove()
@app.route('/_health')
def health():
from acoustid.api import get_health_response
return get_health_response(script, request, require_master=True)
@app.route('/_health_docker')
def health_docker():
from acoustid.api import get_health_response
return get_health_response(script, request)
db.session_factory.configure(bind=config.database.create_engine())
db.session = scoped_session(db.session_factory,
scopefunc=get_flask_request_scope)
app.register_blueprint(general_page)
app.register_blueprint(user_page)
app.register_blueprint(apps_page)
app.register_blueprint(metadata_page)
app.register_blueprint(stats_page)
app.register_blueprint(admin_page)
return app
import os
import sentry_sdk
import numpy as np
from flask_cors import CORS
from werkzeug.utils import secure_filename
from flask_wtf.csrf import CSRFProtect, CSRFError
from sentry_sdk.integrations.flask import FlaskIntegration
from flask import Flask, request, redirect, url_for, render_template, jsonify
from config import FLASK_SECRET_KEY, UPLOAD_FOLDER, ALLOWED_EXTENSIONS, LABELS, WTF_CSRF_TIME_LIMIT, SENTRY_INIT
from processing import get_label, upload_file_to_s3, allowed_file
# Sentry Initialization
sentry_sdk.init(dsn=SENTRY_INIT, integrations=[FlaskIntegration()])
# Flask config
app = Flask(__name__)
app.secret_key = FLASK_SECRET_KEY
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
app.config['WTF_CSRF_TIME_LIMIT'] = WTF_CSRF_TIME_LIMIT
CSRFProtect(app)
CORS(app)
@app.route("/", methods=["GET"])
def main():
return render_template('index.html')
@app.route('/', methods=['POST'])
def upload_image():
if 'file' not in request.files:
def add_sentry():
SENTRY_DSN = env.get('SENTRY_DSN', None)
if SENTRY_DSN:
sentry_sdk.init(dsn=SENTRY_DSN, integrations=[FlaskIntegration()])
def create_app():
"""Initialize the App"""
app = Flask(__name__,
static_url_path="/static",
static_folder=path.join(path.abspath(path.dirname(__file__)),
"static"))
"""Flask Config"""
app_settings = getenv("APP_SETTINGS", "src.config.ProductionConfig")
app.config.from_object(app_settings)
if (app_settings == "src.config.ProductionConfig"
and not app.config.get("SEND_MAIL")):
app.logger.warning("Sending Emails disabled on production!")
"""Set FLASK_ENV and FLASK_DEBUG cause that doesn't happen auto anymore"""
if app.config.get("DEBUG"):
environ["FLASK_ENV"] = "development" # pragma: nocover
environ["FLASK_DEBUG"] = "1" # pragma: nocover
if app.config.get("SENTRY_DSN"):
"""Initialize Sentry if we're in production"""
sentry_sdk.init(dsn=app.config.get("SENTRY_DSN"),
environment=app.config.get("SENTRY_ENV"),
release=f"backend@{__version__}",
integrations=[FlaskIntegration(),
CeleryIntegration()],
traces_sample_rate=1.0)
"""Setup Extensions"""
CORS(app)
db.init_app(app)
swagger.init_app(app)
mail.init_app(app)
bcrypt.init_app(app)
socketio.init_app(app,
cors_allowed_origins="*",
json=json,
message_queue=app.config.get("SOCKETIO_MESSAGE_QUEUE"))
from src.common.json import JSONEncoderBase
app.json_encoder = JSONEncoderBase
"""Register Blueprints"""
from src.api.auth import auth_blueprint
from src.api.hackers import hackers_blueprint
from src.api.sponsors import sponsors_blueprint
from src.api.stats import stats_blueprint
from src.api.events import events_blueprint
from src.api.club_events import club_events_blueprint
from src.api.email_verification import email_verify_blueprint
app.register_blueprint(auth_blueprint, url_prefix="/api")
app.register_blueprint(hackers_blueprint, url_prefix="/api")
app.register_blueprint(sponsors_blueprint, url_prefix="/api")
app.register_blueprint(stats_blueprint, url_prefix="/api")
app.register_blueprint(events_blueprint, url_prefix="/api")
app.register_blueprint(club_events_blueprint, url_prefix="/api")
app.register_blueprint(email_verify_blueprint, url_prefix="/api")
"""Register Error Handlers"""
from src.common import error_handlers
app.register_error_handler(HTTPException, error_handlers.handle_exception)
"""Initialize Celery"""
celery = make_celery(app)
@before_render_template.connect_via(app)
def _sentry_pre_render_template(sender, template, context, **extra):
parent = sentry_sdk.Hub.current.scope.span
if parent is not None:
span = parent.start_child(op="flask.render_template")
span.set_data("flask.render_template.sender", sender)
span.set_data("flask.render_template.template", template)
span.set_data("flask.render_template.context", context)
span.set_data("flask.render_template.extra", extra)
g._sentry_span_render_template = span
@template_rendered.connect_via(app)
def _sentry_template_rendered(sender, template, context, **extra):
span = g.pop("_sentry_span_render_template", None)
if span is not None:
span.finish()
return app, celery
import logging
import time
import os
import pickle
from pathlib import Path
import sentry_sdk
import tokenize_util
import torch
from flask import Flask, request, jsonify
from infer import infill_with_ilm
from sentry_sdk.integrations.flask import FlaskIntegration
from transformers import GPT2LMHeadModel
sentry_sdk.init(dsn=os.getenv("SENTRY_DSN"), integrations=[FlaskIntegration()])
logging.basicConfig(format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", level=logging.INFO)
logger = logging.getLogger(__name__)
MODEL_DIR = os.environ.get("MODEL_DIR", "/data/")
logging.info(f"MODEL_DIR = {MODEL_DIR}")
# MASK_ID = 103
try:
if torch.cuda.is_available():
device = torch.device("cuda")
else:
device = torch.device("cpu")
logger.info(f"infilling is set to run on {device}")
def create_app():
import config
import logging.config
import os
from flask_jwt_extended import JWTManager
from . import api, models
from app import helpers
from app import services
from app import command
def load_app_config(app):
"""
Load app's configurations
:param flask.Flask app:
:return:
"""
app.config.from_object(config)
app.config.from_pyfile('config.py', silent=True)
app = flask.Flask(__name__,
instance_relative_config=True,
instance_path=os.path.join(config.ROOT_DIR, 'instance'))
load_app_config(app)
# Register new flask project here and get new dsn: https://sentry.io
dns = SENTRY_DSN if os.environ.get('SEND_REPORT') == 'true' else None
app.config['SENTRY_CONFIG'] = {
'ignore_exceptions': [
NotFoundException, UnAuthorizedException, BadRequestException,
ForbiddenException
],
'level':
logging.ERROR,
}
sentry_sdk.init(dsn=dns,
integrations=[FlaskIntegration()],
environment=app.config['ENV_MODE'],
in_app_exclude=['app.extensions.exceptions'],
before_send=before_send)
# setup jwt extended
app.config['JWT_SECRET_KEY'] = os.environ['SECRET_KEY']
app.config['JWT_TOKEN_LOCATION'] = ['headers']
# How long an access token should live before it expires. Set by minutes (int)
app.config['JWT_ACCESS_TOKEN_EXPIRES'] = int(
os.environ['TOKEN_UPTIME']) * 60
app.config['JWT_COOKIE_CSRF_PROTECT'] = False
from app.commons.uet_constant import ACCESS_TOKEN_KEY, EMPTY_STRING
app.config['JWT_HEADER_NAME'] = ACCESS_TOKEN_KEY
app.config['JWT_HEADER_TYPE'] = EMPTY_STRING
jwt = JWTManager(app)
app.config['CORS_SUPPORTS_CREDENTIALS'] = True
# setup logging
logging.config.fileConfig(app.config['LOGGING_CONFIG_FILE'],
disable_existing_loggers=False)
app.secret_key = config.FLASK_APP_SECRET_KEY
models.init_app(app)
api.init_app(app)
services.init_app(app)
command.init_command(app)
CORS(app)
return app
import logging
import os
from flask import Flask, request, current_app
from flask_basicauth import BasicAuth
from flask_migrate import Migrate
from flask_sqlalchemy import SQLAlchemy
import sentry_sdk
from sentry_sdk.integrations.flask import FlaskIntegration
from config import Config
sentry_sdk.init(dsn=Config.SENTRY_DSN, integrations=[FlaskIntegration()])
basic_auth = BasicAuth()
db = SQLAlchemy()
migrate = Migrate()
def create_app(config_class=Config):
app = Flask(__name__)
app.config.from_object(config_class)
basic_auth.init_app(app)
db.init_app(app)
migrate.init_app(app, db)
from app.contracts import bp as contracts_bp
app.register_blueprint(contracts_bp)
def create_app(test_config=None):
if dsn := os.getenv('SENTRY_DSN'):
sentry_sdk.init(dsn=dsn, integrations=[FlaskIntegration(), SqlalchemyIntegration()])
# Blog configuration values.
import sentry_sdk
from flask import Flask
from flask_caching import Cache
from playhouse.flask_utils import FlaskDB
from playhouse.pool import PooledMySQLDatabase, PooledPostgresqlDatabase
from sentry_sdk.integrations.flask import FlaskIntegration
import config
DATABASE = PooledPostgresqlDatabase(**config.db)
if config.cache:
CACHE_TYPE = "redis"
else:
CACHE_TYPE = "null"
CACHE_REDIS_DB = config.redisDB
if config.sentryDSN:
sentry_sdk.init(dsn=config.sentryDSN, integrations=[FlaskIntegration()])
# Create a Flask WSGI app and configure it using values from the module.
app = Flask(__name__)
app.config.from_object(__name__)
cache = Cache(app)
flask_db = FlaskDB(app)
db = flask_db.database
from flask_cors import CORS
from flasgger import Swagger
from sentry_sdk.integrations.flask import FlaskIntegration
from typing import Optional, MutableMapping, Any, Tuple, Union
from multinet import auth
from multinet.auth import google
from multinet import api
from multinet.db import register_legacy_workspaces
from multinet import uploaders, downloaders
from multinet.errors import ServerError
from multinet.util import load_secret_key, regex_allowed_origins, get_allowed_origins
sentry_dsn = os.getenv("SENTRY_DSN", default="")
sentry_sdk.init(dsn=sentry_dsn, integrations=[FlaskIntegration()])
def create_app(config: Optional[MutableMapping] = None) -> Flask:
"""Create a Multinet app instance."""
app = Flask(__name__)
if config is not None:
app.config.update(config)
CORS(
app,
origins=regex_allowed_origins(get_allowed_origins()),
supports_credentials=True,
)
Swagger(app, template_file="swagger/template.yaml")
import sentry_sdk
from sentry_sdk.integrations.flask import FlaskIntegration
from sentry_sdk.integrations.sqlalchemy import SqlalchemyIntegration
from flask_cors import CORS
from model import db
from utils import register_all_error_handlers, rechaptcha
from views import UploadView
app = Flask(__name__)
app.config.from_object(Config)
if Config.SENTRY_DSN:
sentry_sdk.init(dsn=Config.SENTRY_DSN,
integrations=[FlaskIntegration(),
SqlalchemyIntegration()],
send_default_pii=True,
release=Config.RELEASE_ID,
environment=Config.RELEASEMODE)
db.init_app(app)
register_all_error_handlers(app)
CORS(app)
rechaptcha.init_app(app)
@app.before_first_request
def init_db():
db.create_all()
def create_app():
global app_created
if not app_created:
BlueprintsManager.register(app)
Migrate(app, db)
app.config.from_object(env('APP_CONFIG', default='config.ProductionConfig'))
db.init_app(app)
_manager = Manager(app)
_manager.add_command('db', MigrateCommand)
if app.config['CACHING']:
cache.init_app(app, config={'CACHE_TYPE': 'simple'})
else:
cache.init_app(app, config={'CACHE_TYPE': 'null'})
stripe.api_key = 'SomeStripeKey'
app.secret_key = 'super secret key'
app.config['JSONIFY_PRETTYPRINT_REGULAR'] = False
app.config['FILE_SYSTEM_STORAGE_FILE_VIEW'] = 'static'
app.logger.addHandler(logging.StreamHandler(sys.stdout))
app.logger.setLevel(logging.ERROR)
# set up jwt
app.config['JWT_HEADER_TYPE'] = 'JWT'
app.config['JWT_ACCESS_TOKEN_EXPIRES'] = timedelta(days=1)
app.config['JWT_REFRESH_TOKEN_EXPIRES'] = timedelta(days=365)
app.config['JWT_ERROR_MESSAGE_KEY'] = 'error'
app.config['JWT_TOKEN_LOCATION'] = ['cookies', 'headers']
app.config['JWT_REFRESH_COOKIE_PATH'] = '/v1/auth/token/refresh'
app.config['JWT_SESSION_COOKIE'] = False
app.config['JWT_BLACKLIST_ENABLED'] = True
app.config['JWT_BLACKLIST_TOKEN_CHECKS'] = ['refresh']
_jwt = JWTManager(app)
_jwt.user_loader_callback_loader(jwt_user_loader)
_jwt.token_in_blacklist_loader(is_token_blacklisted)
# setup celery
app.config['CELERY_BROKER_URL'] = app.config['REDIS_URL']
app.config['CELERY_RESULT_BACKEND'] = app.config['CELERY_BROKER_URL']
app.config['CELERY_ACCEPT_CONTENT'] = ['json', 'application/text']
CORS(app, resources={r"/*": {"origins": "*"}})
AuthManager.init_login(app)
if app.config['TESTING'] and app.config['PROFILE']:
# Profiling
app.wsgi_app = ProfilerMiddleware(app.wsgi_app, restrictions=[30])
# development api
with app.app_context():
from app.api.admin_statistics_api.events import event_statistics
from app.api.auth import auth_routes
from app.api.attendees import attendee_misc_routes
from app.api.bootstrap import api_v1
from app.api.celery_tasks import celery_routes
from app.api.event_copy import event_copy
from app.api.exports import export_routes
from app.api.imports import import_routes
from app.api.uploads import upload_routes
from app.api.users import user_misc_routes
from app.api.orders import order_misc_routes
from app.api.role_invites import role_invites_misc_routes
from app.api.auth import ticket_blueprint, authorised_blueprint
from app.api.admin_translations import admin_blueprint
from app.api.orders import alipay_blueprint
from app.api.settings import admin_misc_routes
app.register_blueprint(api_v1)
app.register_blueprint(event_copy)
app.register_blueprint(upload_routes)
app.register_blueprint(export_routes)
app.register_blueprint(import_routes)
app.register_blueprint(celery_routes)
app.register_blueprint(auth_routes)
app.register_blueprint(event_statistics)
app.register_blueprint(user_misc_routes)
app.register_blueprint(attendee_misc_routes)
app.register_blueprint(order_misc_routes)
app.register_blueprint(role_invites_misc_routes)
app.register_blueprint(ticket_blueprint)
app.register_blueprint(authorised_blueprint)
app.register_blueprint(admin_blueprint)
app.register_blueprint(alipay_blueprint)
app.register_blueprint(admin_misc_routes)
sa.orm.configure_mappers()
if app.config['SERVE_STATIC']:
app.add_url_rule('/static/<path:filename>',
endpoint='static',
view_func=app.send_static_file)
# sentry
if not app_created and 'SENTRY_DSN' in app.config:
sentry_sdk.init(app.config['SENTRY_DSN'], integrations=[FlaskIntegration()])
# redis
redis_store.init_app(app)
# elasticsearch
if app.config['ENABLE_ELASTICSEARCH']:
client.init_app(app)
connections.add_connection('default', client.elasticsearch)
with app.app_context():
try:
cron_rebuild_events_elasticsearch.delay()
except Exception:
pass
app_created = True
return app, _manager, db, _jwt
