from proxypool.utils.parse import parse_redis_connection_string env = Env() env.read_env() # definition of flags IS_WINDOWS = platform.system().lower() == 'windows' # definition of dirs ROOT_DIR = dirname(dirname(abspath(__file__))) LOG_DIR = join(ROOT_DIR, env.str('LOG_DIR', 'logs')) # definition of environments DEV_MODE, TEST_MODE, PROD_MODE = 'dev', 'test', 'prod' APP_ENV = env.str('APP_ENV', DEV_MODE).lower() APP_DEBUG = env.bool('APP_DEBUG', True if APP_ENV == DEV_MODE else False) APP_DEV = IS_DEV = APP_ENV == DEV_MODE APP_PROD = IS_PROD = APP_ENV == PROD_MODE APP_TEST = IS_TEST = APP_ENV == TEST_MODE # redis host REDIS_HOST = env.str('REDIS_HOST', '47.115.201.101') # redis port REDIS_PORT = env.int('REDIS_PORT', 6379) # redis password, if no password, set it to None REDIS_PASSWORD = env.str('REDIS_PASSWORD', None) # redis db, if no choice, set it to 0 REDIS_DB = env.int('REDIS_DB', 0) # redis connection string, like redis://[password]@host:port or rediss://[password]@host:port/0 REDIS_CONNECTION_STRING = env.str('REDIS_CONNECTION_STRING', None)
# Build paths inside the project like this: path.join(BASE_DIR, ...) BASE_DIR = path.dirname(path.dirname(path.abspath(__file__))) env = Env() env.read_env(path.join(BASE_DIR, '.env'), recurse=False) # Quick-start development settings - unsuitable for production # See https://docs.djangoproject.com/en/2.0/howto/deployment/checklist/ # SECURITY WARNING: keep the secret key used in production secret! SECRET_KEY = env('SECRET_KEY', 'v8sk33sy82!uw3ty=!jjv5vp7=s2phrzw(m(hrn^f7e_#1h2al') # SECURITY WARNING: don't run with debug turned on in production! DEBUG = env.bool('DEBUG', True) # True if you want to allow users to be able to create an account ALLOW_SIGNUP = env.bool('ALLOW_SIGNUP', True) # ALLOWED_HOSTS = [] # Application definition INSTALLED_APPS = [ 'whitenoise.runserver_nostatic', 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'server.apps.ServerConfig', 'api.apps.ApiConfig', 'widget_tweaks', 'rest_framework', 'rest_framework.authtoken', 'django_filters', 'social_django',
DATABASES = { 'default': { 'ENGINE': 'django.db.backends.postgresql_psycopg2', 'HOST': env('DB_HOST'), 'PORT': env('DB_PORT'), 'NAME': env('DB_NAME'), 'USER': env('DB_USER'), 'PASSWORD': env('DB_PASSWORD'), } } INSTALLED_APPS = ['datacenter'] SECRET_KEY = env('SECRET_KEY') DEBUG = env.bool("DEBUG", False) ROOT_URLCONF = "project.urls" ALLOWED_HOSTS = ['*'] BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) TEMPLATES = [ { 'BACKEND': 'django.template.backends.django.DjangoTemplates', 'DIRS': [os.path.join(BASE_DIR, 'templates')], 'APP_DIRS': True, }, ] USE_L10N = True
import os from environs import Env from app.basedir import BASE_DIR import sentry_sdk from sentry_sdk.integrations.django import DjangoIntegration from garpix_notify.settings import * # noqa env = Env() env.read_env(os.path.join(BASE_DIR, '.env'), recurse=True) ENABLE_GARPIX_AUTH = env.bool('ENABLE_GARPIX_AUTH', False) # SECURITY WARNING: keep the secret key used in production secret! SECRET_KEY = env('SECRET_KEY') # SECURITY WARNING: don't run with debug turned on in production! DEBUG = env.bool('DEBUG', True) API_URL = 'api' # or api/v1, or api/v2, etc ALLOWED_HOSTS = ['*'] SITE_ID = 1 # Application definition INSTALLED_APPS = [ 'tabbed_admin', 'modeltranslation', 'polymorphic_tree', 'polymorphic',
from environs import Env from dotenv import load_dotenv load_dotenv() env = Env() env.read_env() BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) COMPANY_COORDINATES = [55.751244, 37.618423] ALLOWED_HOSTS = [] SECRET_KEY = os.getenv("SECRET_KEY", "REPLACE_ME") DEBUG = env.bool("DEBUG", True) INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'debug_toolbar', 'blog', ] MIDDLEWARE = [ 'debug_toolbar.middleware.DebugToolbarMiddleware', 'django.middleware.security.SecurityMiddleware',
"django.template.context_processors.static", "django.template.context_processors.tz", "django.contrib.messages.context_processors.messages", ] }, } ] # Quick-start development settings - unsuitable for production # See https://docs.djangoproject.com/en/1.7/howto/deployment/checklist/ # SECURITY WARNING: keep the secret key used in production secret! SECRET_KEY = env.str("SECRET_KEY") # SECURITY WARNING: don't run with debug turned on in production! DEBUG = env.bool("DEBUG") if DEBUG: logger.warning("RUNNING IN DEBUG MODE") else: logger.info("RUNNING IN PRODUCTION") ALLOWED_HOSTS = [host.replace(" ", "") for host in env.list("ALLOWED_HOSTS")] BASE_URL = os.environ["BASE_URL"] # Application definition INSTALLED_APPS = ( "django.contrib.auth", "django.contrib.contenttypes", "django.contrib.sessions", "django.contrib.messages",
from environs import Env env = Env() env.read_env() # Build paths inside the project like this: BASE_DIR / 'subdir'. BASE_DIR = Path(__file__).resolve().parent.parent mimetypes.add_type("text/css", ".css", True) # Quick-start development settings - unsuitable for production # See https://docs.djangoproject.com/en/3.1/howto/deployment/checklist/ # SECURITY WARNING: keep the secret key used in production secret! SECRET_KEY = env("SECRET_KEY", 'secret') # SECURITY WARNING: don't run with debug turned on in production! DEBUG = env.bool("DEBUG") ALLOWED_HOSTS = ['104.248.23.29', '127.0.0.1', 'formula-spa.herokuapp.com', 'formula-spa.ru', 'www.formula-spa.ru', 'formulaspa.ru', 'www.formulaspa.ru'] # Application definition INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'cloudinary_storage', 'cloudinary',
# flask from flask import Flask, render_template, jsonify, make_response from flask_cors import CORS, cross_origin app = Flask(__name__, static_url_path='', static_folder='frontend/dist', template_folder='frontend/dist') env = Env() env.read_env() cors = CORS(app) app.config['DEBUG'] = env.bool('DEBUG', default=True) app.config['SECRET_KEY'] = env.str('SECRET_KEY', default=uuid.uuid4().hex) app.config['CORS_HEADERS'] = 'Content-Type' db = Store() # flask routes @app.route('/') def home(): try: context = {'modules': server.modules} except: context = {} return render_template("index.html", **context)
env = Env() CONFIG_DIR = path.join(path.dirname(path.abspath(__file__)), "configs") ACTION_DEFINITIONS_DIR = path.join(CONFIG_DIR, "actions") if not settings.configured or not hasattr(settings, "SIGAN_CALIBRATION_FILE"): SIGAN_CALIBRATION_FILE = path.join(CONFIG_DIR, "sigan_calibration.json.example") else: SIGAN_CALIBRATION_FILE = settings.SIGAN_CALIBRATION_FILE if not settings.configured or not hasattr(settings, "SENSOR_CALIBRATION_FILE"): SENSOR_CALIBRATION_FILE = path.join(CONFIG_DIR, "sensor_calibration.json.example") else: SENSOR_CALIBRATION_FILE = settings.SENSOR_CALIBRATION_FILE __cmd = path.split(sys.argv[0])[-1] RUNNING_TESTS = "test" in __cmd if not settings.configured or not hasattr(settings, "MOCK_RADIO"): MOCK_RADIO = env.bool("MOCK_RADIO", default=False) or RUNNING_TESTS else: MOCK_RADIO = settings.MOCK_RADIO if not settings.configured or not hasattr(settings, "MOCK_RADIO_RANDOM"): MOCK_RADIO_RANDOM = env.bool("MOCK_RADIO_RANDOM", default=False) else: MOCK_RADIO_RANDOM = settings.MOCK_RADIO_RANDOM USRP_CONNECTION_ARGS = env("USRP_CONNECTION_ARGS", default="num_recv_frames=650")
# increase this if you are getting read request timeouts ELASTICSEARCH_TIMEOUT = env.int('ELASTICSEARCH_TIMEOUT', default=10) # Elasticsearch index chunk size (how many documents to index at a time) ELASTICSEARCH_CHUNK_SIZE = env.int('ELASTICSEARCH_CHUNK_SIZE', default=2000) # the maximum size of the request in bytes (default: 100MB) ELASTICSEARCH_MAX_CHUNK_BYTES = env.int( 'ELASTICSEARCH_MAX_CHUNK_BYTES', default=104857600, ) # the size of the threadpool to use for the bulk requests ELASTICSEARCH_THREAD_COUNT = env.int('ELASTICSEARCH_THREAD_COUNT', default=4) # the size of the task queue between the main thread # (producing chunks to send) and the processing threads. ELASTICSEARCH_QUEUE_SIZE = env.int('ELASTICSEARCH_QUEUE_SIZE', default=4) ELASTICSEARCH_VERIFY_CERTS = env.bool( 'ELASTICSEARCH_VERIFY_CERTS', default=True, ) # turn on SSL ELASTICSEARCH_USE_SSL = env.bool('ELASTICSEARCH_USE_SSL', default=False) # don't show warnings about ssl certs verification ELASTICSEARCH_SSL_SHOW_WARN = env.bool( 'ELASTICSEARCH_SSL_SHOW_WARN', default=False, ) # provide a path to CA certs on disk ELASTICSEARCH_CA_CERTS = env.str('ELASTICSEARCH_CA_CERTS', default=None) # PEM formatted SSL client certificate ELASTICSEARCH_CLIENT_CERT = env.str('ELASTICSEARCH_CLIENT_CERT', default=None) # PEM formatted SSL client key ELASTICSEARCH_CLIENT_KEY = env.str('ELASTICSEARCH_CLIENT_KEY', default=None) ELASTICSEARCH_AWS_REGION = env.str('ELASTICSEARCH_AWS_REGION', default=None)
import importlib from environs import Env # type: ignore from os import path from typing import List env = Env() env.read_env() wallets_module = importlib.import_module("lnbits.wallets") wallet_class = getattr(wallets_module, env.str("LNBITS_BACKEND_WALLET_CLASS", default="VoidWallet")) ENV = env.str("QUART_ENV", default="production") DEBUG = env.bool("QUART_DEBUG", default=False) or ENV == "development" HOST = env.str("HOST", default="127.0.0.1") PORT = env.int("PORT", default=5000) LNBITS_PATH = path.dirname(path.realpath(__file__)) LNBITS_DATA_FOLDER = env.str("LNBITS_DATA_FOLDER", default=path.join(LNBITS_PATH, "data")) LNBITS_ALLOWED_USERS: List[str] = env.list("LNBITS_ALLOWED_USERS", default=[], subcast=str) LNBITS_DISABLED_EXTENSIONS: List[str] = env.list("LNBITS_DISABLED_EXTENSIONS", default=[], subcast=str) LNBITS_SITE_TITLE = env.str("LNBITS_SITE_TITLE", default="LNbits") WALLET = wallet_class() DEFAULT_WALLET_NAME = env.str("LNBITS_DEFAULT_WALLET_NAME", default="LNbits wallet") PREFER_SECURE_URLS = env.bool("LNBITS_FORCE_HTTPS", default=True) SERVICE_FEE = env.float("LNBITS_SERVICE_FEE", default=0.0)
import requests import sys from environs import Env env = Env() env.read_env() show_detail = env.bool("DETAIL",True) APITOKEN=env("APITOKEN") MILESTONES="https://api.clubhouse.io/api/v3/milestones" URL=MILESTONES + "?token=%s" % APITOKEN tokenurl = "?token=%s" % APITOKEN EPICS=MILESTONES + "/%d/epics" EPIC_URL = "https://api.clubhouse.io/api/v3/epic/%d" def get_date(milestone, key): dt = milestone.get(key, None) if dt == None or dt == 'None': dt = milestone.get(key + '_override', '') if dt == None or dt == 'None': dt = 'unscheduled' else: dt = '(projected) ' + dt return dt def show_epics(milestone): epic_response = requests.get((EPICS % milestone.get('id')) + tokenurl) if response.status_code == 200: epics = epic_response.json()
"pool": { "dsn": env.str("AUTH_DB_URL"), "min_size": env.int("AUTH_DB_MIN_SIZE", 0), "max_size": env.int("AUTH_DB_MAX_SIZE", 5), "max_queries": env.int("AUTH_DB_MAX_QUERIES", 1000), "timeout": env.float("AUTH_DB_TIMEOUT", 10), "command_timeout": env.float("AUTH_DB_COMMAND_TIMEOUT", 5), }, "logger": { "name": "audit", }, }, "hunter_service": { "bind": { "name_or_url": env.str("HUNTER_DB_URL"), "echo": env.bool("HUNTER_DB_ECHO", False), "echo_pool": env.bool("HUNTER_DB_ECHO_POOL", False), "encoding": env.str("HUNTER_DB_ENCODING", "utf-8"), "max_overflow": env.int("HUNTER_DB_MAX_OVERFLOW", 5), "pool_pre_ping": env.bool("HUNTER_DB_POOL_PRE_PING", False), "pool_size": env.int("HUNTER_DB_POOL_SIZE", 5), "pool_recycle": env.int("HUNTER_DB_POOL_RECYCLE", 3600), "pool_timeout": env.int("HUNTER_DB_POOL_TIMEOUT", 10), }, "days": env.int("HUNTER_DELTA_DAYS", 180), "schema": env.str("HUNTER_DB_SCHEMA", "yavert"), "table": env.str("HUNTER_DB_TABLE", "hundata"), "timeout": env.float("HUNTER_QUERY_TIMEOUT", 10), "logger": { "name": "hunter", },
from pathlib import Path import os from environs import Env env = Env() env.read_env() # Build paths inside the project like this: BASE_DIR / 'subdir'. BASE_DIR = Path(__file__).resolve().parent.parent # Quick-start development settings - unsuitable for production # See https://docs.djangoproject.com/en/3.1/howto/deployment/checklist/ # SECURITY WARNING: don't run with debug turned on in production! DEBUG = env.bool("DEBUG", default=True) # SECURITY WARNING: keep the secret key used in production secret! SECRET_KEY = env("SECRET_KEY", default='defaultsecretkey') ALLOWED_HOSTS = [] # Application definition INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles',
class Config: ENV_VARS = { 'API_ALLOW_DEBUG', 'API_HOST', 'API_WS_PORT', 'CACHE_HOST', 'CACHE_PORT', 'CACHE_SIGN_KEY', 'CACHE_TIMEOUT', 'CACHE_TTL', 'ENV', 'LOG_LEVEL', 'ROLLBAR_ACCESS_TOKEN', 'ROLLBAR_LEVEL', 'VERSION', } def __init__(self): self._config = None self.env = Env() self.env.read_env() print( # noqa: T001 'Using overridden values for', self.ENV_VARS.intersection(os.environ.keys()), file=sys.stderr, ) def __getitem__(self, value): if self._config is None: raise RuntimeError('Config is not loaded, cannot access it') return self._config[value] def setup_config(self): # API must not start in prod like nev if we don't have a sign key for cache. # This is for security reasons. env = self.env.str('ENV', 'production') cache_sign_key = self.env.str('CACHE_SIGN_KEY', '') if env != 'development' and not cache_sign_key: raise EnvironmentError('You must supply a CACHE_SIGN_KEY env var') self._config = MappingProxyType({ 'api': { 'allow_debug': self.env.bool('API_ALLOW_DEBUG', False), # Binding to all interfaces, bandit don't allow this (#104) 'host': self.env.str('API_HOST', '0.0.0.0'), # noqa: S104 'ws_port': self.env.int('API_WS_PORT', 8181), }, 'cache': { 'host': self.env.str('CACHE_HOST', 'aot-redis'), 'port': self.env.int('CACHE_PORT', 6379), # Sign key must be of type bytes, not str. 'sign_key': cache_sign_key.encode('utf-8'), 'timeout': self.env.int('CACHE_TIMEOUT', 5), 'ttl': self.env.int('CACHE_TTL', 2 * 24 * 60 * 60), # 2 days }, # Amount of time to wait for pending futures before forcing them to shutdown. 'cleanup_timeout': self.env.int('CLEANUP_TIMEOUT', 5), 'env': env, 'log': { 'level': self.env.str('LOG_LEVEL', None), }, 'rollbar': { 'access_token': self.env.str('ROLLBAR_ACCESS_TOKEN', None), 'level': self.env.int('ROLLBAR_LEVEL', 30), }, 'version': self.env.str('VERSION', 'latest'), })
# increase this if you are getting read request timeouts ELASTICSEARCH_TIMEOUT = env.int('ELASTICSEARCH_TIMEOUT', default=10) # Elasticsearch index chunk size (how many documents to index at a time) ELASTICSEARCH_CHUNK_SIZE = env.int('ELASTICSEARCH_CHUNK_SIZE', default=2000) # the maximum size of the request in bytes (default: 100MB) ELASTICSEARCH_MAX_CHUNK_BYTES = env.int( 'ELASTICSEARCH_MAX_CHUNK_BYTES', default=104857600, ) # the size of the threadpool to use for the bulk requests ELASTICSEARCH_THREAD_COUNT = env.int('ELASTICSEARCH_THREAD_COUNT', default=4) # the size of the task queue between the main thread # (producing chunks to send) and the processing threads. ELASTICSEARCH_QUEUE_SIZE = env.int('ELASTICSEARCH_QUEUE_SIZE', default=4) ELASTICSEARCH_VERIFY_CERTS = env.bool( 'ELASTICSEARCH_VERIFY_CERTS', default=True, ) # Postgres: PG_URL = env.str('PG_URL', default=None) PG_HOST = env.str('PG_HOST', default='localhost') PG_USER = env.str('PG_USER') PG_PORT = env.int('PG_PORT', default=5432) PG_PASSWORD = env.str('PG_PASSWORD', default=None) PG_SSLMODE = env.str('PG_SSLMODE', default=None) PG_SSLROOTCERT = env.str('PG_SSLROOTCERT', default=None) # Redis: REDIS_URL = env.str('REDIS_URL', default=None) REDIS_SCHEME = env.str('REDIS_SCHEME', default='redis') REDIS_HOST = env.str('REDIS_HOST', default='localhost')
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)
env = Env() logger = logging.getLogger("dll.settings") # Build paths inside the project like this: os.path.join(BASE_DIR, ...) BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) # Quick-start development settings - unsuitable for production # See https://docs.djangoproject.com/en/2.2/howto/deployment/checklist/ # SECURITY WARNING: keep the secret key used in production secret! SECRET_KEY = os.getenv("DJANGO_SECRET_KEY", "SET_ME") # SECURITY WARNING: don't run with debug turned on in production! DEBUG = env.bool("DJANGO_DEBUG", False) ALLOWED_HOSTS = env.list("DJANGO_ALLOWED_HOSTS", ["*"]) # DJANGO_ADMINS=John:[email protected],Jane:[email protected] ADMINS = [x.split(":") for x in env.list("DJANGO_ADMINS", [])] # Application definition INSTALLED_APPS = [ "django.contrib.admin", "django.contrib.auth", "django.contrib.contenttypes", "django.contrib.sessions", "django.contrib.messages", "django.contrib.staticfiles",
import os from dotenv import find_dotenv from environs import Env env = Env() env.read_env(find_dotenv('.env')) BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) TEMPLATE_SECRET_KEY = 'dq+sh59b@7+91zd(vx0iwr^h59_$ezd(m9r5+k)0vdgna-a)ka' SECRET_KEY = env('SECRET_KEY', TEMPLATE_SECRET_KEY) ALLOWED_HOSTS = env.list('ALLOWED_HOSTS') DEBUG = env.bool('DEBUG', False) INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', ] MIDDLEWARE = [ 'django.middleware.security.SecurityMiddleware', 'django.contrib.sessions.middleware.SessionMiddleware', 'django.middleware.common.CommonMiddleware', 'django.middleware.csrf.CsrfViewMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.messages.middleware.MessageMiddleware', 'django.middleware.clickjacking.XFrameOptionsMiddleware', ]
from pathlib import Path from environs import Env env = Env() env.read_env() BOT_TOKEN = env.str("KITCHEN_BOT_TOKEN") SKIP_UPDATES = env.bool("SKIP_UPDATES", False) WORK_PATH: Path = Path(__file__).parent.parent ADMINS_ID = env.list("ADMINS_ID") REDIS_HOST = env.str("REDIS_HOST", default="localhost") REDIS_PORT = env.int("REDIS_PORT", default=6379) POSTGRES_HOST = env.str("POSTGRES_HOST", default="localhost") POSTGRES_PORT = env.int("POSTGRES_PORT", default=5432) POSTGRES_DB = env.str("POSTGRES_DB") POSTGRES_USER = env.str("POSTGRES_USER") POSTGRES_PASSWORD = env.str("POSTGRES_PASSWORD") POSTGRES_URI = f"postgresql://{POSTGRES_USER}:{POSTGRES_PASSWORD}@{POSTGRES_HOST}:{POSTGRES_PORT}/{POSTGRES_DB}"
# app/config.py from environs import Env env = Env() env.read_env() FLASK_ENV = env.str('FLASK_ENV', default='production') DEBUG = env.bool('FLASK_DEBUG', default=False) SECRET_KEY = env.str('SECRET_KEY') MAX_CONTENT_LENGTH = env.int('MAX_CONTENT_LENGTH', default=None)
from environs import Env env = Env() env.read_env() # reading .env file # Build paths inside the project like this: os.path.join(BASE_DIR, ...) BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) # Quick-start development settings - unsuitable for production # See https://docs.djangoproject.com/en/2.1/howto/deployment/checklist/ # SECURITY WARNING: keep the secret key used in production secret! SECRET_KEY = env("DJANGO_SECRET_KEY") # SECURITY WARNING: don't run with debug turned on in production! DEBUG = env.bool("DJANGO_DEBUG", default=False) ALLOWED_HOSTS = [] # Application definition INSTALLED_APPS = [ 'crispy_forms', 'users.apps.UsersConfig', 'blog.apps.BlogConfig', 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', ]
from environs import Env env = Env() env.read_env() TOKEN = env.str("TOKEN") PSNR_THRESHOLD = env.int("PSNR_THRESHOLD") IMAGE_DIR = env.path("IMAGE_DIR") IMAGE_DIR.mkdir(exist_ok=True, parents=True) DB_CONNECTION = env.str("DB_CONNECTION") DB_ECHO = env.bool("DB_ECHO", False)
import os from environs import Env env = Env() env.read_env() BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) SECRET_KEY = env.str('SECRET_KEY', default='SECRET') DEBUG = env.bool('DEBUG', default=False) ALLOWED_HOSTS = ['*'] INSTALLED_APPS = [ 'users', 'recipes', 'api', 'about', 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'sorl.thumbnail', 'debug_toolbar', ] MIDDLEWARE = [
import sys import os from environs import Env env = Env() FROM_EXAMPLE = env.bool('FROM_EXAMPLE', False) if FROM_EXAMPLE: from dotenv import load_dotenv load_dotenv('./mishards/.env.example') else: env.read_env() SERVER_VERSIONS = ['0.8.0'] DEBUG = env.bool('DEBUG', False) MAX_RETRY = env.int('MAX_RETRY', 3) LOG_LEVEL = env.str('LOG_LEVEL', 'DEBUG' if DEBUG else 'INFO') LOG_PATH = env.str('LOG_PATH', '/tmp/mishards') LOG_NAME = env.str('LOG_NAME', 'logfile') TIMEZONE = env.str('TIMEZONE', 'UTC') from utils.logger_helper import config config(LOG_LEVEL, LOG_PATH, LOG_NAME, TIMEZONE) SERVER_PORT = env.int('SERVER_PORT', 19530) SERVER_TEST_PORT = env.int('SERVER_TEST_PORT', 19530) WOSERVER = env.str('WOSERVER') MAX_WORKERS = env.int('MAX_WORKERS', 50)
ALLOWED_HOSTS = env.list('ALLOWED_HOSTS', []) # Organisation name and e-mail address, used in e-mail templates etc. ORG_LONG_NAME = env.str('ORG_LONG_NAME', 'Acme Corporation') ORG_SHORT_NAME = env.str('ORG_SHORT_NAME', 'ACME') ORG_EMAIL = env.str('ORG_EMAIL', '*****@*****.**') ORG_URL = env.str('ORG_URL', 'https://www.example.org/') ORG_GUIDE_URL = env.str('ORG_GUIDE_URL', 'https://guide.example.org/') # Email settings EMAIL_HOST = env.str('EMAIL_HOST', None) EMAIL_PORT = env.int('EMAIL_PORT', None) EMAIL_HOST_USER = env.str('EMAIL_HOST_USER', None) EMAIL_HOST_PASSWORD = env.str('EMAIL_HOST_PASSWORD', None) EMAIL_USE_TLS = env.bool('EMAIL_USE_TLS', False) EMAIL_USE_SSL = env.bool('EMAIL_USE_SSL', False) EMAIL_SUBJECT_PREFIX = env.str('EMAIL_SUBJECT_PREFIX', None) SERVER_EMAIL = DEFAULT_FROM_EMAIL = env.str('SERVER_EMAIL', None) # Application definition INSTALLED_APPS = [ 'scout_apm.django', 'hypha.cookieconsent', 'hypha.images', 'hypha.apply.activity', 'hypha.apply.categories', 'hypha.apply.funds', 'hypha.apply.dashboard', 'hypha.apply.flags', 'hypha.apply.home',
import os from environs import Env env = Env() env.read_env('.env') BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) TEMPLATE_SECRET_KEY = 'dq+sh59b@7+91zd(vx0iwr^h59_$ezd(m9r5+k)0vdgna-a)ka' SECRET_KEY = os.environ.get('SECRET_KEY', TEMPLATE_SECRET_KEY) DEBUG = env.bool('DEBUG') ALLOWED_HOSTS = env.list('ALLOWED_HOSTS') INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', ] MIDDLEWARE = [ 'django.middleware.security.SecurityMiddleware', 'django.contrib.sessions.middleware.SessionMiddleware', 'django.middleware.common.CommonMiddleware', 'django.middleware.csrf.CsrfViewMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.messages.middleware.MessageMiddleware', 'django.middleware.clickjacking.XFrameOptionsMiddleware', ]
from src.routes.setup_routes import setup_all_routes from src.routes.entry_point import api_entry_point from src.orm.database_postgresql import DialectDbPostgresql from sanic_cors import CORS, cross_origin #Create Sanic app app = Sanic(__name__) # CORS(app) # app.blueprint(swagger_blueprint) #Setup env env = Env() env.read_env() # read .env file, if it exists port = env.str("PORT", "8002") host = env.str("HOST", "127.0.0.1") debug = env.bool("DEBUG", False) access_log = env.bool("ACESS_LOG", False) MIME_TYPE_JSONLD = "application/ld+json" @app.middleware("request") async def print_on_request(request): pass @app.route("/") def handle_request(request: Request): base_iri = request.scheme + '://' + request.host _headers = { 'Access-Control-Expose-Headers': 'Link',
ACCOUNT_EMAIL_VERIFICATION = "none" # TODO: configure email verification # Set up Email EMAIL_BACKEND = env("EMAIL_BACKEND", default="sgbackend.SendGridBackend") if EMAIL_BACKEND == "sgbackend.SendGridBackend": SENDGRID_API_KEY = env("SENDGRID_API_KEY", default=None) if not SENDGRID_API_KEY: warnings.warn( "`SENDGRID_API_KEY` has not been configured. You will not receive emails." ) elif EMAIL_BACKEND == "django.core.mail.backends.smtp.EmailBackend": EMAIL_HOST = env("EMAIL_HOST", default="localhost") EMAIL_HOST_USER = env("EMAIL_HOST_USER", default=None) EMAIL_HOST_PASSWORD = env("EMAIL_HOST_PASSWORD", default=None) EMAIL_PORT = env("EMAIL_PORT", default=587) EMAIL_USE_TLS = env.bool("EMAIL_USE_TLS", default=True) SWAGGER_SETTINGS = { "SHOW_REQUEST_HEADERS": True, "SECURITY_DEFINITIONS": { "api_key": { "type": "apiKey", "in": "header", "name": "Authorization" } }, } LOGIN_URL = "/admin/login/" LOGOUT_URL = "/admin/logout/"
from datetime import datetime, timedelta from sklearn.metrics import mean_squared_error from scipy.optimize import curve_fit from scipy.integrate import odeint from scipy.optimize import basinhopping from yabox import DE from tqdm import tqdm import sigmoid as sg from environs import Env env = Env() env.str("CUDA_DEVICE_ORDER", 'PCI_BUS_ID') env.str("CUDA_VISIBLE_DEVICES", '0,1,2,3,4,5') env.int("NUMBA_ENABLE_CUDASIM", 1) env.bool("OMPI_MCA_opal_cuda_support", True) #parallel computation import ray ray.shutdown() ray.init(num_gpus=96, num_cpus=6) import unicodedata #register function for parallel processing @ray.remote(memory=8 * 1024 * 1024 * 1024, num_gpus=10, num_cpus=0) class Learner(object): def __init__(self, districtRegion, start_date, predict_range,s_0, e_0, a_0, i_0, r_0, d_0, \ startNCases, weigthCases, weigthRecov, weigthDeath, end_date, ratio, cleanRecovered, version, \
from environs import Env env = Env() env.read_env() # Build paths inside the project like this: os.path.join(BASE_DIR, ...) BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) # Quick-start development settings - unsuitable for production # See https://docs.djangoproject.com/en/3.2/howto/deployment/checklist/ # SECURITY WARNING: keep the secret key used in production secret! SECRET_KEY = env.str("SECRET_KEY") # SECURITY WARNING: don't run with debug turned on in production! DEBUG = env.bool("DEBUG", default=False) ALLOWED_HOSTS = env.list("ALLOWED_HOSTS") BASE_URL = env.str("BASE_URL") # Turn this off because of existing database we work with SILENCED_SYSTEM_CHECKS = ["fields.W342"] # Application definition INSTALLED_APPS = [ "django.contrib.admin", "django.contrib.auth", "apps.scouts_auth", "apps.members", "apps.equipment",
from environs import Env import socket env = Env() env.read_env() # Build paths inside the project like this: BASE_DIR / 'subdir'. BASE_DIR = Path(__file__).resolve().parent.parent # Quick-start development settings - unsuitable for production # See https://docs.djangoproject.com/en/3.1/howto/deployment/checklist/ # SECURITY WARNING: keep the secret key used in production secret! SECRET_KEY = env("DJANGO_SECRET_KEY") # SECURITY WARNING: don't run with debug turned on in production! DEBUG = env.bool('DJANGO_DEBUG', default=False) ALLOWED_HOSTS = ['.herokuapp.com', 'localhost', '127.0.0.1'] SECURE_SSL_REDIRECT = env.bool("DJANGO_SECURE_SSL_REDIRECT", default=True) # Application definition INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'django.contrib.sites',
from environs import Env env = Env() env.read_env() SECRET_KEY = env('SECRET_KEY', '') DEBUG = env.bool('DEBUG', False) HTTP_HOST = env('HTTP_HOST', 'localhost') HTTP_PORT = env.int('HTTP_PORT', 8085) DB_HOST = env('DB_HOST', 'localhost') DB_PORT = env.int('DB_PORT', 5432) DB_NAME = env('DB_NAME', 'airy') DB_USERNAME = env('DB_USERNAME', 'airy') DB_PASSWORD = env('DB_PASSWORD', 'airy') TIMEZONE = env('TIMEZONE', 'Europe/Moscow') SMTP_SERVER = env('SMTP_SERVER', 'localhost') SMTP_PORT = env.int('SMTP_PORT', 25) SMTP_USER = env('SMTP_USER', '') SMTP_PASSWORD = env('SMTP_PASSWORD', '') SMTP_SENDER = env('SMTP_SENDER', 'no-reply@localhost') USER_NAME = env('USER_NAME', 'username') USER_PASSWORD = env('USER_PASSWORD', 'password') USER_EMAIL = env('USER_EMAIL')
EMAIL_PORT = env('EMAIL_PORT', 587) EMAIL_HOST_USER = env('EMAIL_HOST_USER') EMAIL_HOST_PASSWORD = env('EMAIL_HOST_PASSWORD') EMAIL_USE_TLS = env('EMAIL_USE_TLS', True) # Build paths inside the project like this: os.path.join(BASE_DIR, ...) BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) # Quick-start development settings - unsuitable for production # See https://docs.djangoproject.com/en/2.0/howto/deployment/checklist/ # SECURITY WARNING: keep the secret key used in production secret! SECRET_KEY = env('SECRET_KEY') # SECURITY WARNING: don't run with debug turned on in production! DEBUG = env.bool('DEBUG', True) ALLOWED_HOSTS = env.list('ALLOWED_HOSTS', ['*']) OL_URL = env('OL_URL') # Application definition INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'django.contrib.humanize', 'django_rename_app',
PRD = 'prd' ENV_TYPE = None def get_env(): if 'HALO_STAGE' in os.environ: return os.environ['HALO_STAGE'] return LOC ENV_NAME = get_env() os.environ.setdefault("DJANGO_CONFIGURATION", ENV_NAME) FUNC_NAME='halo_current_account' from .extend import * #@TODO load config data from env var if possible and if not from env file SERVER_LOCAL = env.bool('SERVER_LOCAL', default=False) AWS_REGION = 'us-east-1'#env.str('AWS_REGION') DB_URL = env.str('DYNAMODB_URL') SECRET_JWT_KEY = env.str('SECRET_JWT_KEY') STAGE_URL=env.bool('STAGE_URL',default=True) SITE_NAME = env.str('SITE_NAME') # SECURITY WARNING: keep the secret key used in production secret! # Make this unique, and don't share it with anybody. SECRET_KEY = env.str('SECRET_KEY') ### #Given a version number MAJOR.MINOR.PATCH, increment the: # #MAJOR version when you make incompatible changes, #MINOR version when you add functionality in a backwards-compatible manner, and
import os from environs import Env env = Env() env.read_env() FLASK_ENV = env("FLASK_ENV") LOG_LEVEL = (env("LOG_LEVEL", default="") or logging.getLevelName(logging.WARNING)).upper() LOCAL_TIMEZONE = env("LOCAL_TIMEZONE", default="Europe/Berlin") TELEGRAM_TOKEN = env("TELEGRAM_TOKEN", default=None) TELEGRAM_IDLE_TIMEOUT = env.int("TELEGRAM_IDLE_TIMEOUT", default=120) # By default, database will be refreshed every time a test runs. REFRESH_TEST_DATABASE = env.bool("REFRESH_TEST_DATABASE", default=True) LONG_OVERDUE = env.int("LONG_OVERDUE", default=14) MEDIUM_OVERDUE = env.int("MEDIUM_OVERDUE", default=7) ICONS = env.list("ICONS") TOGGL_API_TOKEN = env("TOGGL_API_TOKEN") #: Working hours HOME_HOURS = env.int("HOME_HOURS") #: How many minutes before the reminder should be set HOME_MINUTES_BEFORE = env.int("HOME_MINUTES_BEFORE") #: Toggl clients to count as working hours