def __init__(self, environment="dev"):
super().__init__()
reload(config)
if environment == 'dev':
self.config = config.DevelopmentConfig()
elif environment == 'prod':
self.config = config.ProductionConfig()
if self.config.DISCORD_BOT_KEY:
if self.config.DISCORD_BOT_KEY.endswith("TOKEN_GOES_HERE"):
raise exception.HoloError(
"Bot key not updated from default value.")
else:
self.bot_token = self.config.DISCORD_BOT_KEY
else:
raise exception.HoloError(
"Bot key blank or missing from configuration file.")
self._logger = logging.getLogger('HoloPearl')
log_handler = logging.StreamHandler()
log_handler.setFormatter(
logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
self._logger.addHandler(log_handler)
self._logger.setLevel(self.config.LOG_LEVEL)
self.next_anime_host = None
self.next_anime_date = None
def get_configuration():
if os.environ['ENVIRON'] == config.Environments.DEVELOPMENT.name:
return config.DevelopmentConfig()
elif os.environ['ENVIRON'] == config.Environments.PRODUCTION.name:
return config.ProductionConfig()
else:
raise EnvironmentError('Unknown Environment')
def create_app():
try:
cfg = config.ProductionConfig() if os.environ.get('ENV') == 'prod' else config.DevelopmentConfig()
except KeyringError as e:
print(e)
quit(1)
if all([cfg.MAIL_USERNAME, cfg.MAIL_PASSWORD, cfg.RECIPIENT]):
app = Flask(__name__)
app.config.from_object(cfg)
return app
else:
print("Configure python-keyring variables MAIL_USER, MAIL_PASSWORD and RECIPIENT for 'scheduled_mail' service")
quit(1)
from flask import send_from_directory
from werkzeug.utils import secure_filename
import authentication
import config
app = Flask(__name__, )
APP_ROOT = os.path.dirname(os.path.abspath(__file__))
UPLOAD_FOLDER = os.path.join(APP_ROOT, "files")
app.config["UPLOAD_FOLDER"] = UPLOAD_FOLDER
# Load config
devEnvironment = os.environ.get('FLASK_ENV')
print("FLASK_ENV = ", devEnvironment)
if devEnvironment == "development":
app.config.from_object(config.DevelopmentConfig())
elif devEnvironment == "production":
app.config.from_object(config.ProductionConfig())
@app.route('/')
def hello_world():
return render_template("home.html")
@app.route("/home")
def home_handler():
return render_template("home.html")
@app.route("/signup", methods=['GET', 'POST'])
# chunky
terminal_text = """
__ __
.-----.---.-.-----.-----.----.______| |_.----.---.-.--| |.-----.----.
| _ | _ | _ | -__| _|______| _| _| _ | _ || -__| _|
| __|___._| __|_____|__| |____|__| |___._|_____||_____|__|
|__| |__|
"""
cira.KEY_FILE = "../key.json"
if __name__ == '__main__':
print(terminal_text)
print(" [*] paper-trader started ")
config.DevelopmentConfig()
cassandra_classic.run_cassandra()
print(" [*] paper-trader stopped")
# Fraktur
terminal_text_big = """
s ..
:8 dF
.d`` .d`` .u . .88 .u . '88bu. .u .
@8Ne. .u u @8Ne. .u .u .d88B :@8c :888ooo .d88B :@8c u '*88888bu .u .d88B :@8c
%8888:u@88N us888u. %8888:u@88N ud8888. ="8888f8888r -*8888888 ="8888f8888r us888u. ^"*8888N ud8888. ="8888f8888r
`888I 888. .@88 "8888" `888I 888. :888'8888. 4888>'88" 8888 4888>'88" .@88 "8888" beWE "888L :888'8888. 4888>'88"
888I 888I 9888 9888 888I 888I d888 '88%" 4888> ' 8888 4888> ' 9888 9888 888E 888E d888 '88%" 4888> '
888I 888I 9888 9888 888I 888I 8888.+" 4888> 8888 4888> 9888 9888 888E 888E 8888.+" 4888>
uW888L 888' 9888 9888 uW888L 888' 8888L .d888L .+ 88888888 .8888Lu= .d888L .+ 9888 9888 888E 888F 8888L .d888L .+
def getConfig():
return config.DevelopmentConfig()
import pandas as pd
from sqlalchemy import exc
from analytics_backend import db
from analytics_backend.utils.date_time import convert_date_format
import constants
import config
current_config = config.DevelopmentConfig()
class ParamsAppModel(db.Model):
__tablename__ = 'ref_ParamApp'
id = db.Column(db.BIGINT, primary_key=True)
sys_created_date = db.Column(db.DateTime)
report_date = db.Column(db.DateTime)
prev_lower_bound = db.Column(db.DateTime)
prev_upper_bound = db.Column(db.DateTime)
lower_bound = db.Column(db.DateTime)
upper_bound = db.Column(db.DateTime)
business_account_id = db.Column(db.BIGINT)
param_name = db.Column(db.String(255))
param_data_type = db.Column(db.String(255))
param_name_cd = db.Column(db.String(255))
ts_granularity = db.Column(db.String(30))
def __init__(self, param_name):
self.param_name = param_name
import os
from app import create_app, db
from app.models import User, Role
import config
app = create_app(config.DevelopmentConfig())
@app.shell_context_processor
def make_shell_context():
return dict(db=db, User=User, Role=Role)
import os
from dotenv import load_dotenv
import config
from dnsviz_api.app import create_app
load_dotenv()
if os.getenv('FLASK_ENV') == "development":
app_config = config.DevelopmentConfig()
else:
app_config = config.ProductionConfig()
app = create_app(app_config)
if __name__ == "__main__":
app.run(host="0.0.0.0", port=int(os.getenv("PORT", 5000)))
from os import environ
import config
from server import create_app
if 'FLASK_ENV' not in environ or environ['FLASK_ENV'] == 'development':
config_obj = config.DevelopmentConfig()
elif environ['FLASK_ENV'] == 'production':
config_obj = config.ProductionConfig()
elif environ['FLASK_ENV'] == 'testing':
config_obj = config.TestingConfig()
else:
raise ValueError("Unknown FLASK_ENV")
app = create_app(config_obj)
import flask
import flask_login
import flask_sqlalchemy
import config
from hubstaff.services.client import HubStaff
# create and configure the app
app = flask.Flask(__name__, instance_relative_config=True)
app.app_context().push()
# set config object base on ENV
env = os.environ.get('FLASK_ENV')
if env == 'dev' or env == 'development':
env_config = config.DevelopmentConfig()
elif env == 'prod' or env == 'production':
env_config = config.ProductionConfig()
elif env == 'test' or env == 'testing':
env_config = config.TestingConfig()
else:
env_config = config.DevelopmentConfig()
app.config.from_object(env_config)
# register SQLAlchemy
db = flask_sqlalchemy.SQLAlchemy()
db.init_app(app)
# register Flask-Login's login manager
login_manager = flask_login.LoginManager()
#!/usr/bin/env python from flask import Flask import config from flask_restful import Api from flask.ext.sqlalchemy import SQLAlchemy app = Flask(__name__, static_url_path='') api = Api(app) configuration = config.DevelopmentConfig() app.config.from_object(configuration) db = SQLAlchemy(app) from app import routes from app import models routes.initialize() models.initialize()
logger.setLevel(level=logging.INFO)
return logger
if __name__ == '__main__':
ENV = os.getenv('ENV', None)
TF_LOGGER = setup_logger('tensorflow', False)
LOGGER = setup_logger()
APP = App()
if ENV is None:
LOGGER.info(
"Environment variable 'ENV' not set, returning development configs."
)
ENV = 'DEV'
if ENV == 'DEV':
APP.config = config.DevelopmentConfig(LOGGER, ENV)
elif ENV == 'TEST':
APP.config = config.TestConfig(LOGGER, ENV)
elif ENV == 'PROD':
APP.config = config.ProductionConfig(LOGGER, ENV)
else:
raise ValueError('Invalid environment name')
APP.ci_config = config.CIConfig
OUTPUT_DIR = '/home/frans/Documents/tsprediction/model'
LOGGER.info('Cleanning ouput directory')
shutil.rmtree(OUTPUT_DIR, ignore_errors=True) # start fresh each time
LOGGER.info('Outpout directory clean')
APP.experiment_fn(OUTPUT_DIR)
