def _read_env(self) -> dict:
env = Env()
env.read_env()
with env.prefixed("GIFT_APP_"):
with env.prefixed("DB_"):
config_vars = {
"db": {
"name": env("NAME"),
"host": env("HOST"),
"username": env("USERNAME"),
"password": env("PASSWORD", None),
"port": env.int("PORT", 5432),
}
}
return config_vars
def create_app(no_db: bool = False):
env = Env()
env.read_env()
logger = logging.getLogger(__name__)
logger.addHandler(logging.StreamHandler(sys.stdout))
app = Flask(__name__)
app.register_blueprint(core, url_prefix='/api')
with env.prefixed('WOL_'):
logger.setLevel(env.log_level('LOG_LEVEL', logging.DEBUG))
if not env('NO_DB', False) and not no_db and models: # TODO: shit
app.config['DATABASE'] = env.str('DATABASE_URL', 'postgres://postgres@localhost:5432/wol')
models.db.init_app(app)
app.register_blueprint(crud, url_prefix='/api')
app.register_blueprint(pages)
@app.errorhandler(ValidationError)
def handle_validation(error: ValidationError):
response = jsonify(error.messages)
response.status_code = 400
return response
@app.errorhandler(NotImplementedError)
def handle_not_implemented(_error: NotImplementedError):
return Response(status=501)
return app
def fromenv(cls):
"""
Create a `wcraas_common.AMQPConfig` from Environment Variables.
>>> conf = AMQPConfig.fromenv()
>>> type(conf)
<class 'wcraas_common.config.AMQPConfig'>
>>> conf._fields
('host', 'port', 'user', 'password')
>>> conf.host
'localhost'
>>> conf.port
5672
>>> conf.user
'guest'
>>> conf.password
'guest'
"""
env = Env()
env.read_env()
with env.prefixed("COTTONTAIL_"):
return cls(
host=env.str("HOST", "localhost"),
port=env.int("PORT", 5672),
user=env.str("USER", "guest"),
password=env.str("PASS", "guest"),
)
def fromenv(cls):
"""
Create a `wcraas_storage.MongoConfig` from Environment Variables.
>>> conf = MongoConfig.fromenv()
>>> type(conf)
<class 'config.MongoConfig'>
>>> conf._fields
('host', 'port', 'db', 'user', 'password')
>>> conf.host
'localhost'
>>> conf.port
27017
"""
env = Env()
env.read_env()
with env.prefixed('MONGO_'):
return cls(
host=env.str("HOST", "localhost"),
port=env.int("PORT", 27017),
db=env.str("DB", "wcraas"),
user=env.str("USER", None),
password=env.str("PASS", None),
)
def main():
args = _parse_args()
env = Env()
env.read_env()
with env.prefixed('YADES_'):
config = {
'mongodb_uri':
env.str('MONGODB_URI', args.db_uri),
'mongodb_name':
env.str('MONGODB_NAME', args.db_name),
'smtp_host':
env('SMTP_HOST', args.host),
'smtp_port':
env.int('SMTP_PORT', args.port),
'collect_statistic':
env.bool('COLLECT_STATISTIC', args.collect_statistic),
'emails_count_limit':
env.int('EMAILS_COUNT_LIMIT', args.emails_count_limit),
}
logging.basicConfig(level=logging.INFO)
loop = asyncio.get_event_loop()
db = AsyncIOMotorClient(config['mongodb_uri'],
io_loop=loop)[config['mongodb_name']]
controller = Controller(db, config, loop)
server = loop.run_until_complete(controller.run())
try:
loop.run_forever()
except KeyboardInterrupt:
logging.info('Stopping server')
server.close()
loop.run_until_complete(server.wait_closed())
loop.stop()
def _load_app_options(env: Env):
from octokit.utils import get_json_data as octokit_get_json_data
global APP_NAME, APP_DESCRIPTION, APP_ORGANIZATION, APP_PUBLIC
global APP_DEFAULT_EVENTS, APP_DEFAULT_PERMISSIONS
valid_events = octokit_get_json_data("events.json")
with env.prefixed("APP_"):
APP_NAME = env.str("NAME", "gh-app")
APP_DESCRIPTION = env.str("DESCRIPTION", "")
APP_ORGANIZATION = env.str("ORGANIZATION", None)
APP_PUBLIC = env.bool("PUBLIC", True)
with env.prefixed("DEFAULT_"):
APP_DEFAULT_EVENTS = env.list("EVENTS",
"push",
validate=ContainsOnly(valid_events))
APP_DEFAULT_PERMISSIONS = env.dict("PERMISSIONS", "metadata=read")
def main():
env = Env()
env.read_env()
with env.prefixed('YADES_'):
parser = argparse.ArgumentParser(description="")
parser.add_argument('--host',
type=str,
default=env('API_HOST', 'localhost'),
help='Host to listen on')
parser.add_argument('--port',
type=int,
default=env.int('API_PORT', 8080),
help='Port to listen on')
parser.add_argument('--db-uri',
type=str,
default=env.str('MONGODB_URI',
'mongodb://localhost:27017'),
help='Uri of mongodb server')
parser.add_argument('--db-name',
type=str,
default=env.str('MONGODB_NAME', 'yades'),
help='Name of mongodb database')
parser.add_argument(
'--allowed-domains',
nargs='+',
default=env.list('ALLOWED_DOMAINS', []),
help='Domains that can be used for receiving emails')
args = parser.parse_args()
config = {
'mongodb_uri': args.db_uri,
'mongodb_name': args.db_name,
'api_host': args.host,
'api_port': args.port,
'allowed_domains': args.allowed_domains,
}
logging.basicConfig(level=logging.DEBUG)
if not config['allowed_domains']:
raise Exception('No allowed domains specified')
loop = asyncio.get_event_loop()
db = AsyncIOMotorClient(config['mongodb_uri'],
io_loop=loop)[config['mongodb_name']]
app = create_app(loop, config, db)
app.on_cleanup.append(close_db)
run_app(app, host=config['api_host'], port=config['api_port'])
def _load_app_registration_options(env: Env):
"""
TODO: decrypt these with Credstash, SecretsManager, or ParameterStore.
ref: https://github.com/aws/chalice/issues/859#issuecomment-547676237
ref: https://environ-config.readthedocs.io/en/stable/tutorial.html
ref: https://bit.ly/why-you-shouldnt-use-env-variables-for-secret-data
:param env:
:return:
"""
global APP_ID, APP_CLIENT_ID, APP_CLIENT_SECRET, APP_PEM, APP_WEBHOOK_SECRET
with env.prefixed("APP_"):
APP_ID = env.str("ID", None)
APP_CLIENT_ID = env.str("CLIENT_ID", None)
APP_CLIENT_SECRET = env.str("CLIENT_SECRET", None)
APP_PEM = env.str("PEM", None)
APP_WEBHOOK_SECRET = env.str("WEBHOOK_SECRET", None)
class LektorEnv:
def __init__(self, config=None):
self.env = Env()
if not config:
self.prefix = DEFAULT_PREFIX
else:
self.prefix = config.get("envvar.prefix", DEFAULT_PREFIX)
def envvars(self, name, var_type=None, no_prefix=False):
prefix = "" if no_prefix else self.prefix
with self.env.prefixed(prefix):
if var_type:
return getattr(self.env, var_type)(name)
else:
return self.env(name)
def fromenv(cls):
"""
Create a `wcraas_control.RedisConfig` from Environment Variables.
>>> conf = RedisConfig.fromenv()
>>> type(conf)
<class 'config.RedisConfig'>
>>> conf._fields
('host', 'port')
>>> conf.host
'localhost'
>>> conf.port
6379
"""
env = Env()
env.read_env()
with env.prefixed("REDIS_"):
return cls(host=env.str("HOST", "localhost"), port=env.int("PORT", 6379))
async def run():
env = Env()
env.read_env()
with env.prefixed("EVENT_HUB_"):
CONNECTION_STRING = env('CONN_STR')
FULLY_QUALIFIED_NAMESPACE = env('HOSTNAME')
EVENTHUB_NAME = env('NAME')
SAS_POLICY = env('SAS_POLICY')
SAS_KEY = env('SAS_KEY')
CONSUMER_GROUP = env('CONSUMER_GROUP', "$Default")
producer_client = EventHubProducerClient.from_connection_string(
conn_str=CONNECTION_STRING,
eventhub_name=
EVENTHUB_NAME, # EventHub name should be specified if it doesn't show up in connection string.
logging_enable=
False, # To enable network tracing log, set logging_enable to True.
retry_total=3, # Retry up to 3 times to re-do failed operations.
transport_type=TransportType.
Amqp # Use Amqp as the underlying transport protocol.
)
consumer_client = EventHubConsumerClient.from_connection_string(
conn_str=CONNECTION_STRING,
consumer_group=CONSUMER_GROUP,
eventhub_name=
EVENTHUB_NAME, # EventHub name should be specified if it doesn't show up in connection string.
logging_enable=
False, # To enable network tracing log, set logging_enable to True.
retry_total=3, # Retry up to 3 times to re-do failed operations.
transport_type=TransportType.
Amqp # Use Amqp as the underlying transport protocol.
)
async with producer_client:
p = await producer_client.get_partition_ids()
print(p)
print('foobar')
asyncio.create_task(run()).result()
def _load_ghe_options(env: Env):
global GHE_HOST, GHE_PROTO, GHE_API_URL, GHE_API_SPEC
with env.prefixed("GHE_"):
GHE_API_SPEC = env.str(
"API_SPEC",
"api.github.com",
validate=OneOf(specifications.keys(),
error="GHE_API_SPEC must be one of: {choices}"),
)
if GHE_API_SPEC == "api.github.com":
GHE_PROTO = "https"
GHE_HOST = "github.com"
GHE_API_URL = urlparse("https://api.github.com")
else:
GHE_PROTO = env.str(
"PROTO",
"https",
validate=OneOf(["http", "https"],
error="GHE_PROTO must be one of: {choices}"),
)
GHE_HOST = env.str("HOST")
GHE_API_URL = env.url("GHE_API_URL",
f"{GHE_PROTO}://{GHE_HOST}/api/v3")
"Unable to delete at index...") # TODO: better error message
self._db.child("users").child(user_id).child("feeds").set(feeds)
return feed
def update_fetch_date(self, user_id):
datetime_str = date_to_string(now())
self._db.child("users").child(user_id).child("last_fetch").set(
datetime_str)
def get_fetch_date(self, user_id):
datetime_str = self._db.child("users").child(user_id).child(
"last_fetch").get().val()
if datetime_str:
return string_to_date(datetime_str)
else:
return None
def get_users(self):
return self._db.child("users").get().val()
with env.prefixed('FIREBASE_'):
config = {
"apiKey": env('APIKEY'),
"authDomain": env('AUTHDOMAIN'),
"databaseURL": env('DATABASEURL'),
"storageBucket": env('STORAGEBUCKET')
}
database = Database(config)
from environs import Env
env = Env()
@env.parser_for('secure_ssl_header')
def _(value):
if not value:
return None
return value, 'https'
with env.prefixed('DJANGO_'):
DEBUG = env.bool('DEBUG', default=True)
SECRET_KEY = env.str('SECRET_KEY', default='asdf')
ALLOWED_HOSTS = env.list('ALLOWED_HOSTS', default=[])
CACHES = {'default': env.dj_cache_url('CACHE_URL', default='dummy://')}
SECURE_PROXY_SSL_HEADER = env.secure_ssl_header('SECURE_PROXY_SSL_HEADER',
default=None)
INSTALLED_APPS = ['django.contrib.sessions']
SESSION_ENGINE = 'django.contrib.sessions.backends.signed_cookies'
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.middleware.common.CommonMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'emojiclock.middlewares.timezone_middleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
# Copyright (c) 2020 Zero A.E., LLC
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
from environs import Env
env = Env()
env.read_env()
# Configuration Options
ZTR_LIMIT = 1_000
with env.prefixed("ZTR_"):
with env.prefixed("DYNAMODB_"):
ZTR_DYNAMODB_URL = env.str("URL", default=None)
ZTR_DYNAMODB_TABLE_PREFIX = env.str("TABLE_PREFIX")
os.environ["GITHUB_USER"] = "******"
os.environ["API_KEY"] = "123abc"
os.environ["SHIP_DATE"] = "1984-06-25"
os.environ["ENABLE_LOGIN"] = "******"
os.environ["MAX_CONNECTIONS"] = "42"
os.environ["GITHUB_REPOS"] = "webargs,konch,ped"
os.environ["COORDINATES"] = "23.3,50.0"
os.environ["MYAPP_HOST"] = "lolcathost"
os.environ["MYAPP_PORT"] = "3000"
env = Env()
# reading an environment variable
gh_user = env("GITHUB_USER") # => 'sloria'
# casting
api_key = env.str("API_KEY") # => '123abc'
date = env.date("SHIP_DATE") # => datetime.date(1984, 6, 25)
# providing a default value
enable_login = env.bool("ENABLE_LOGIN", False) # => True
enable_feature_x = env.bool("ENABLE_FEATURE_X", False) # => False
# parsing lists
gh_repos = env.list("GITHUB_REPOS") # => ['webargs', 'konch', 'ped']
coords = env.list("COORDINATES", subcast=float) # => [23.3, 50.0]
with env.prefixed("MYAPP_"):
host = env("HOST", "localhost")
port = env.int("PORT", 5000)
pprint(env.dump(), indent=2)
# Which domains can access this site?
ALLOWED_HOSTS: List[str] = env.list("ALLOWED_HOSTS", ["localhost"])
############################## ENV: DIRECTORIES ##############################
# Where persistent data will be placed
DATA_DIR = env.path("DATA_DIR", os.fspath(BASE_PATH / "run"))
# The Google Sheets ID of the vocabulary list.
# Obtain this ID
ONESPOT_GOOGLE_SHEETS_ID = env("ONESPOT_GOOGLE_SHEETS_ID", None)
############################### ENV: DATABASES ###############################
with env.prefixed("DATABASE_"):
DATABASE_ENGINE = env("ENGINE", "django.db.backends.sqlite3")
DATABASE_NAME = env("NAME", os.fspath(DATA_DIR / "db.sqlite3"))
DATABASE_LOG_LEVEL = env.log_level("LOG_LEVEL", "WARN")
############################# ENV: STATIC FILES ##############################
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/2.2/howto/static-files/
with env.prefixed("STATIC_"):
# Where collectstatic will dump files:
STATIC_ROOT = env("ROOT", None)
# The URL prefix for all static files. MUST end with a slash!
STATIC_URL = env("URL", "/static/")
############################# ENV: MEDIA FILES ##############################
from environs import Env
os.environ["GITHUB_USER"] = "******"
os.environ["API_KEY"] = "123abc"
os.environ["SHIP_DATE"] = "1984-06-25"
os.environ["ENABLE_LOGIN"] = "******"
os.environ["MAX_CONNECTIONS"] = "42"
os.environ["GITHUB_REPOS"] = "webargs,konch,ped"
os.environ["COORDINATES"] = "23.3,50.0"
os.environ["MYAPP_HOST"] = "lolcathost"
os.environ["MYAPP_PORT"] = "3000"
env = Env()
# reading an environment variable
gh_user = env("GITHUB_USER") # => 'sloria'
# casting
api_key = env.str("API_KEY") # => '123abc'
date = env.date("SHIP_DATE") # => datetime.date(1984, 6, 25)
# providing a default value
enable_login = env.bool("ENABLE_LOGIN", False) # => True
enable_feature_x = env.bool("ENABLE_FEATURE_X", False) # => False
# parsing lists
gh_repos = env.list("GITHUB_REPOS") # => ['webargs', 'konch', 'ped']
coords = env.list("COORDINATES", subcast=float) # => [23.3, 50.0]
with env.prefixed("MYAPP_"):
host = env("HOST", "localhost")
port = env.int("PORT", 5000)
pprint(env.dump(), indent=2)
import os
from environs import Env
# Prefixed envvars
os.environ['CANTEEN_HOST'] = 'lolcathost'
os.environ['CANTEEN_PORT'] = '3000'
# A non-prefixed envvar
os.environ['NODE_ENV'] = 'production'
env = Env()
with env.prefixed('CANTEEN_'):
host = env.str('HOST', 'localhost')
port = env.int('PORT', 5000)
node_env = env.str('NODE_ENV', 'development')
assert host == 'lolcathost'
assert port == 3000
assert node_env == 'production'
print(env.dump())
import os
from environs import Env
env = Env()
env.read_env()
SYNONYMS_SEARCH_URL = 'https://rusvectores.org/tayga_upos_skipgram_300_2_2019/' \
'{word}/api/json/'
CORPUS_EXAMPLES_MARKER = lambda ex: f"<b>{ex.upper()}</b>" # noqa
with env.prefixed('API_'):
API_VERSION = env('VERSION', '0.1.0')
API_HOST = env('HOST')
API_PORT = env.int('PORT')
API_DEBUG = env.bool('DEBUG', False)
with env.prefixed('LOGGER_'):
LOGGER_NAME = env('NAME', 'Vocabulary')
LOGGER_LEVEL = env.log_level('LEVEL', 'debug')
with env.prefixed('DB_'):
DB_DSN_TEMPLATE = "postgresql+{driver}://{username}:{password}@" \
"{host}:{port}/{name}"
DB_HOST = env('HOST')
DB_PORT = env.int('PORT')
DB_USERNAME = env('USERNAME')
DB_PASSWORD = env('PASSWORD')
DB_NAME = env('NAME')
DB_ISOLATION_LEVEL = env('ISOLATION_LEVEL', 'REPEATABLE READ')
# -*- coding: utf-8 -*-
#################################
# env环境变量
#################################
from environs import Env
from spider_admin_pro.config import detault_config
env = Env()
env.read_env()
pre_fix = 'SPIDER_ADMIN_PRO_'
with env.prefixed(pre_fix):
# flask 服务配置
FLASK_PORT = env.int('PORT', detault_config.FLASK_PORT)
FLASK_HOST = env.str('HOST', detault_config.FLASK_HOST)
# 登录账号密码
BASIC_AUTH_USERNAME = env.str('USERNAME',
detault_config.BASIC_AUTH_USERNAME)
BASIC_AUTH_PASSWORD = env.str('PASSWORD',
detault_config.BASIC_AUTH_PASSWORD)
BASIC_AUTH_JWT_KEY = env.str('JWT_KEY', detault_config.BASIC_AUTH_JWT_KEY)
# token过期时间，单位天
BASIC_AUTH_EXPIRES = env.int('EXPIRES', detault_config.BASIC_AUTH_EXPIRES)
# scrapyd地址, 结尾不要加斜杆
│ │ └── model_450000.p
│ :
│ └── CT-24
├── great_code_summarization
└── xl_net_code_summarization
"""
from environs import Env
from pathlib import Path
env = Env(expand_vars=True)
env_file_path = Path(f"{Path.home()}/.config/code_transformer/.env")
if env_file_path.exists():
env.read_env(env_file_path, recurse=False)
with env.prefixed("CODE_TRANSFORMER_"):
_DATA_PATH = env("DATA_PATH")
_BINARY_PATH = env("BINARY_PATH")
MODELS_SAVE_PATH = env("MODELS_PATH")
LOGS_PATH = env("LOGS_PATH")
CSN_RAW_DATA_PATH = env("CSN_RAW_DATA_PATH", f"{_DATA_PATH}/raw/csn")
CODE2SEQ_RAW_DATA_PATH = env("CODE2SEQ_RAW_DATA_PATH",
f"{_DATA_PATH}/raw/code2seq")
CODE2SEQ_EXTRACTED_METHODS_DATA_PATH = env(
"CODE2SEQ_EXTRACTED_METHODS_DATA_PATH",
f"{_DATA_PATH}/raw/code2seq-methods")
DATA_PATH_STAGE_1 = env("DATA_PATH_STAGE_1", f"{_DATA_PATH}/stage1")
DATA_PATH_STAGE_2 = env("DATA_PATH_STAGE_2", f"{_DATA_PATH}/stage2")
"""A module for interactions with the Steam Workshop."""
from os import rename
from environs import Env
from requests import get, post
from lzma import LZMADecompressor
from json import dumps
env = Env()
env.read_env()
with env.prefixed("STEAM_"):
key = env.str("API_KEY")
blacklist = set(env.list("BLACKLIST"))
def search(text="", app=4000, perpage=20, cursor="*"):
while cursor:
print("Cursor: {}".format(cursor))
resp = get(url="https://api.steampowered.com/IPublishedFileService/QueryFiles/v1/", params={
"key": key,
"input_json": dumps({
"cursor": cursor,
"numperpage": perpage,
"creator_appid": app,
"appid": app,
"search_text": text,
"return_children": True,
"return_short_description": True,
"requiredtags": "Addon",
"required_flags": "Addon",
__all__ = [
"SALT",
"N",
"R",
"P",
"DKLEN",
"SECRET",
"ALGORITHM",
"DB_URL",
]
from environs import Env
env = Env()
with env.prefixed("SCRYPT_"):
SALT = env.str("SALT", "secret_salt").encode()
N = env.int("N", 16384)
R = env.int("R", 8)
P = env.int("P", 1)
DKLEN = env.int("DKLEN", 128)
with env.prefixed("JWT_"):
SECRET = env.str("SECRET", "secret")
ALGORITHM = env.str("ALGORITHM", "HS256")
with env.prefixed("DB_"):
DB_URL = env.str("URL", "postgres:postgres@localhost/upi")
MANAGERS = ADMINS
DATABASES = {"default": env.dj_db_url("DATABASE_URL")}
try:
email = env.dj_email_url("EMAIL_URL")
EMAIL_HOST = email["EMAIL_HOST"]
EMAIL_PORT = email["EMAIL_PORT"]
EMAIL_HOST_PASSWORD = email["EMAIL_HOST_PASSWORD"]
EMAIL_HOST_USER = email["EMAIL_HOST_USER"]
EMAIL_USE_TLS = email["EMAIL_USE_TLS"]
EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
except EnvError:
try:
with env.prefixed('AWS_SES_'):
AWS_SES_ACCESS_KEY_ID = env('ACCESS_KEY_ID')
AWS_SES_SECRET_ACCESS_KEY = env('SECRET_ACCESS_KEY')
AWS_SES_REGION_NAME = env('REGION_NAME')
AWS_SES_REGION_ENDPOINT = env('REGION_ENDPOINT')
AWS_SES_CONFIGURATION_SET = env('CONFIGURATION_SET')
EMAIL_BACKEND = 'django_ses.SESBackend'
except EnvError:
if DEBUG:
EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'
else:
EMAIL_BACKEND = 'django.core.mail.backends.dummy.EmailBackend'
SERVER_EMAIL = '*****@*****.**'
DEFAULT_FROM_EMAIL = SERVER_EMAIL
from lib.timeDomain import timeDomain
from lib.multiScaleEntropy import sampEn
from lib.DFA import scalingExponent
from lib.poincare import correlation_coef, eclipse_fitting_methods
env = Env()
env.read_env()
env_mode = env.str(
"FLASK_ENV",
default="development",
validate=OneOf(["production", "development"],
error="FLASK_ENV must be one of: {choices}"),
).upper()
with env.prefixed(env_mode):
with env.prefixed("_DB_"):
db_user = env.str("USER", default="test_user")
db_password = env.str("PASSWORD", default="test_password")
db_host = env.str("HOST", default="localhost")
db_port = env.int("PORT", default=3306)
db_name = env.str("NAME", default="phs_backend")
db_uri = "mysql://{db_user}:{db_password}@{db_host}:{db_port}/{db_name}".format(
db_user=db_user,
db_password=db_password,
db_host=db_host,
db_port=db_port,
db_name=db_name)
app = Flask(__name__)
from environs import Env
from sentry_sdk.integrations.celery import CeleryIntegration
from sentry_sdk.integrations.flask import FlaskIntegration
env = Env()
env.read_env()
ENV = env.str("FLASK_ENV", default="production")
DEBUG = ENV == "development"
DIFFBOX_TOKEN = env.str("DIFFBOX_TOKEN")
USE_MAIL = env.bool("USE_MAIL", False)
USE_EVERNOTE = env.bool("USE_EVERNOTE", True)
with env.prefixed("MAIL_"):
MAIL_SERVER = env.str("SERVER")
MAIL_USERNAME = env.str("USERNAME")
MAIL_PASSWORD = env.str("PASSWORD")
MAIL_PORT = env.int("PORT", 25)
MAIL_USE_TLS = env.bool("USE_TLS", False)
MAIL_USE_SSL = env.bool("USE_SSL", False)
MAIL_DEFAULT_SENDER = env.str("DEFAULT_SENDER")
MAIL_RECIPIENTS = env.str("RECIPIENTS")
with env.prefixed("EVERNOTE_"):
EVERNOTE_TOKEN = env.str("TOKEN")
EVERNOTE_SANDBOX = env.bool("SANDBOX", False)
EVERNOTE_CHINA = env.bool("CHINA", False)
# Celery
import logging
from environs import Env
from marshmallow.validate import OneOf
MODES = ['unfollow']
def get_logging_level_by_name(name: str) -> int:
return logging.getLevelName(name)
env = Env()
env.read_env()
with env.prefixed('INSTABOT_'):
main_params = dict(mode=env.str(
name='MODE',
default='unfollow',
validate=OneOf(choices=['unfollow'],
error="INSTABOT_MODE must be one of: {choices}")),
limit=env.int(name='REQUESTS_LIMIT', default=1000),
requests_interval=env.float(name='REQUESTS_INTERVAL',
default=10),
ajax_header=env.str(name='AJAX_HEADER',
default='33a6d878c17d'),
random_intervals=env.bool(name='RANDOM_INTERVALS',
default=True),
on_error_interval=env.float(name='ON_ERROR_INTERVAL',
default=120))
# Flask-User settings
USER_APP_NAME = APP_NAME
USER_ENABLE_CHANGE_PASSWORD = True # Allow users to change their password
USER_ENABLE_CHANGE_USERNAME = False # Allow users to change their username
USER_ENABLE_CONFIRM_EMAIL = True # Force users to confirm their email
USER_ENABLE_FORGOT_PASSWORD = True # Allow users to reset their passwords
USER_ENABLE_EMAIL = True # Register with Email
USER_ENABLE_REGISTRATION = True # Allow new users to register
USER_REQUIRE_RETYPE_PASSWORD = True # Prompt for `retype password` in:
USER_ENABLE_USERNAME = False # Register and Login with username
USER_AFTER_LOGIN_ENDPOINT = 'main.home_page'
USER_AFTER_LOGOUT_ENDPOINT = 'main.home_page'
# Load environment settings
with env.prefixed("X12_"):
SECRET_KEY = env("SECRET_KEY")
DEBUG = env.bool("DEBUG", False)
SQLALCHEMY_ECHO = env.bool("SQLALCHEMY_ECHO", False)
SQLALCHEMY_DATABASE_URI = env("SQLALCHEMY_DATABASE_URI")
MAIL_SERVER = env("MAIL_SERVER", "smtp.gmail.com")
MAIL_PORT = env.int("MAIL_PORT", 587)
MAIL_USE_SSL = env.bool("MAIL_USE_SSL", False)
MAIL_USE_TLS = env.bool("MAIL_USE_TLS", True)
MAIL_USERNAME = env("MAIL_USERNAME")
MAIL_PASSWORD = env("MAIL_PASSWORD")
MAIL_DEFAULT_SENDER = env("MAIL_DEFAULT_SENDER", "X Æ A-12 Administrator")
USER_EMAIL_SENDER_NAME = env("USER_EMAIL_SENDER_NAME")
USER_EMAIL_SENDER_EMAIL = env("USER_EMAIL_SENDER_EMAIL")
SERVER_PUBLIC_NOTIFICATION_KEY = env("SERVER_PUBLIC_NOTIFICATION_KEY")
SERVER_PRIVATE_NOTIFICATION_KEY = env("SERVER_PRIVATE_NOTIFICATION_KEY")
from environs import Env
from marshmallow.validate import OneOf
import logging
env = Env()
with env.prefixed("GLUTEMULO_"):
backend = env("BACKEND", default=None)
config = {
"backend": backend,
"log_level": getattr(
logging,
env.str(
"LOG_LEVEL",
"INFO",
validate=OneOf(
"DEBUG INFO WARN ERROR".split(),
error="LOG_LEVEL must be one of: {choices}",
),
),
),
}
ingestor_enabled = config["ingestor_enabled"] = env.bool("INGESTOR_ENABLED", False)
with env.prefixed("INGESTOR_"):
if ingestor_enabled:
config.update(
{
"ingestor_topic": env("TOPIC", None),
"ingestor_bootstap_servers": env.list("BOOTSTRAP_SERVERS"),
"ingestor_group_id": env("GROUP_ID"),
import os
from environs import Env
# Prefixed envvars
os.environ["CANTEEN_HOST"] = "lolcathost"
os.environ["CANTEEN_PORT"] = "3000"
# A non-prefixed envvar
os.environ["NODE_ENV"] = "production"
env = Env()
with env.prefixed("CANTEEN_"):
host = env.str("HOST", "localhost")
port = env.int("PORT", 5000)
node_env = env.str("NODE_ENV", "development")
assert host == "lolcathost"
assert port == 3000
assert node_env == "production"
print(env.dump())
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]
WSGI_APPLICATION = '_core.wsgi.application'
# Database
with env.prefixed('DB_') as e:
DATABASES = {
'default': dict(
ENGINE='django.contrib.gis.db.backends.postgis',
NAME=e('NAME'),
USER=e('USER'),
PASSWORD=e('PASS'),
HOST=e('HOST'),
PORT=e('PORT')
)
}
AUTH_PASSWORD_VALIDATORS = [
{
'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
},
