from datetime import timedelta from environs import Env # Теперь используем вместо библиотеки python-dotenv библиотеку environs env = Env() env.read_env() BOT_TOKEN = env.str("BOT_TOKEN") # Забираем значение типа str ADMINS = env.list("ADMINS") # Тут у нас будет список из админов IP = env.str("ip") # Тоже str, но для айпи адреса хоста PG_USER = env.str("PG_USER") PG_PASSWORD = env.str("PG_PASSWORD") PG_DB = env.str("PG_DB") PG_PORT = env.str("PG_PORT") PG_HOST = env.str("PG_HOST") REDIS_HOST = env.str("REDIS_HOST") REDIS_PORT = env.str("REDIS_PORT") REDIS_PASSWORD = env.str("REDIS_PASSWORD") EXAMPLE_IMGS = ( "AgACAgIAAxkBAANHYE3U7lJcgbf1U0O9ylGGBeOuZ3YAAgayMRuI1HFKLtjiqSTIcgeoZ4meLgADAQADAgADeQADP8UDAAEeBA", "AgACAgIAAxkBAANJYE3U9uDsrNZpza-od4sfY4AihI8AAgOyMRuI1HFK4JvEfAyW9q-h0Q-bLgADAQADAgADeQADCgQEAAEeBA", "AgACAgIAAxkBAANNYE3VZ5BG0B6UgKrh2sFqOjdDtDAAAgmyMRuI1HFK8bYL4g_sQ2NoZomeLgADAQADAgADeQADjMwDAAEeBA" ) repeat_stages = [ timedelta(minutes=30), timedelta(hours=1),
import os from pathlib import Path 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: keep the secret key used in production secret! SECRET_KEY = env.str('SECRET_KEY', 'REPLACE_ME') # SECURITY WARNING: don't run with debug turned on in production! DEBUG = env.bool('DEBUG', False) ALLOWED_HOSTS = env.list('ALLOWED_HOSTS', ['127.0.0.1']) # Application definition INSTALLED_APPS = [ '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() ENVIRONMENT = env.str("ENVIRONMENT") BOT_ERTAOZ_TOKEN = env.str("BOT_ERTAOZ_TOKEN") BOT_ERTAOZ_WEBHOOK_PORT = env.int("PORT") CORONA_API_ID = env.str("CORONA_API_ID") IMGFLIP_API_USERNAME = env.str("IMGFLIP_API_USERNAME") IMGFLIP_API_PASSWORD = env.str("IMGFLIP_API_PASSWORD") WEATHER_API_ID = env.str("WEATHER_API_ID") ADVENT_OF_CODE_SESSION_ID = env.str("ADVENT_OF_CODE_SESSION_ID")
import logging from environs import Env from playhouse.postgres_ext import PostgresqlExtDatabase logging.basicConfig( format= "%(asctime)s - %(name)s - %(levelname)s - %(funcName)s:%(lineno)d - %(message)s", level=logging.INFO, ) env = Env() env.read_env() TOKEN = env.str("TELEGRAM_TOKEN") COIN_API = "https://api.coingecko.com/api/v3/" # time in seconds UPDATE_TIME = env.int("UPDATE_TIME") # database DB_NAME = env.str("DB_NAME") DB_USER = env.str("DB_USER") DB_PASSWORD = env.str("DB_PASSWORD") DB_HOST = env.str("DB_HOST", "db") DB_PORT = env.int("DB_PORT", 5432) db = PostgresqlExtDatabase(database=DB_NAME, user=DB_USER, password=DB_PASSWORD, host=DB_HOST)
os.environ["TTL"] = "-2" os.environ["NODE_ENV"] = "invalid" os.environ["EMAIL"] = "^_^" env = Env() # simple validator try: env.int("TTL", validate=lambda n: n > 0) # => 'sloria' except EnvError as err: print(err) # marshmallow validator try: env.str( "NODE_ENV", validate=OneOf( ["production", "development"], error="NODE_ENV must be one of: {choices}" ), ) except EnvError as err: print(err) # multiple validators try: env.str("EMAIL", validate=[Length(min=4), Email()]) except EnvError as err: print(err)
TG_PROXY = auto() TG_TOKEN = auto() IS_DEBUG = auto() REDIS_HOST = auto() REDIS_PORT = auto() if __name__ == '__main__': env = Env() env.read_env() env_configuration: bool = env.bool( ConfigurationParameters.ENV_CONFIGURATION.name, False) if env_configuration: tg_token = env(ConfigurationParameters.TG_TOKEN.name) feeds_path = env.str(ConfigurationParameters.FEEDS_PATH.name) redis_host = env.str(ConfigurationParameters.REDIS_HOST.name) redis_port = env.int(ConfigurationParameters.REDIS_PORT.name, DEFAULT_REDIS_PORT) is_debug = env.bool(ConfigurationParameters.IS_DEBUG.name, DEFAULT_IS_DEBUG) tg_proxy = env(ConfigurationParameters.TG_PROXY.name, DEFAULT_TG_PROXY) main(tg_token=tg_token, feeds_path=feeds_path, redis_host=redis_host, redis_port=redis_port, is_debug=is_debug, tg_proxy=tg_proxy) else:
import platform from os.path import dirname, abspath, join from environs import Env from loguru import logger 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', '127.0.0.1') # 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
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())
# -*- coding: utf-8 -*- """Application configuration. Most configuration is set via environment variables. For local development, use a .env file to set environment variables. """ from environs import Env env = Env() env.read_env() ENV = env.str("FLASK_ENV", default="production") DEBUG = ENV == "development" SQLALCHEMY_DATABASE_URI = env.str("DATABASE_URL") SECRET_KEY = env.str("SECRET_KEY") SEND_FILE_MAX_AGE_DEFAULT = env.int("SEND_FILE_MAX_AGE_DEFAULT") BCRYPT_LOG_ROUNDS = env.int("BCRYPT_LOG_ROUNDS", default=13) DEBUG_TB_ENABLED = DEBUG DEBUG_TB_INTERCEPT_REDIRECTS = False CACHE_TYPE = "simple" # Can be "memcached", "redis", etc. SQLALCHEMY_TRACK_MODIFICATIONS = False CELERY_BROKER_URL = 'redis://*****:*****@example.com'
from environs import Env import os from os.path import join, exists env = Env() env.read_env("MaLSTM.conf", recurse=False) # model configuration OUTPUT_UNITS = env.int("OUTPUT_UNITS") MAXLEN = env.int("MAXLEN") NO_OF_UNIQUE_WORDS = env.int("NO_OF_UNIQUE_WORDS") EMBED_DIM = env.int("EMBED_DIM") HOLDOUT_RATIO = env.float("HOLDOUT_RATIO") BATCH_SIZE = env.int("BATCH_SIZE") LEARNING_RATE = env.float("LEARNING_RATE") NO_OF_ITERATIONS = env.int("NO_OF_ITERATIONS") SEED = env.int("SEED") FOLDER = env.str("ROOT_LOGDIR") if not exists(join(os.getcwd(), FOLDER)): os.mkdir(join(os.getcwd(), FOLDER)) ROOT_LOGDIR = join(os.getcwd(), FOLDER)
"django.template.context_processors.request", "django.template.context_processors.i18n", "django.template.context_processors.media", "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",
Most configuration is set via environment variables. For local development, use a .env file to set environment variables. """ from os.path import abspath, dirname, join from environs import Env basedir = dirname(abspath(__file__)) env = Env() env.read_env() ENV = env.str('FLASK_ENV', default='production') DEBUG = ENV == 'development' SQLALCHEMY_DATABASE_URI = env.str('DATABASE_URL', default='sqlite:////' + join(basedir, 'db.sqlite3')) SECRET_KEY = env.str('SECRET_KEY') BCRYPT_LOG_ROUNDS = env.int('BCRYPT_LOG_ROUNDS', default=13) DEBUG_TB_ENABLED = DEBUG DEBUG_TB_INTERCEPT_REDIRECTS = False CACHE_TYPE = 'simple' # Can be "memcached", "redis", etc. SQLALCHEMY_TRACK_MODIFICATIONS = False WEBPACK_MANIFEST_PATH = 'webpack/manifest.json' SECURITY_PASSWORD_SALT = SECRET_KEY SECURITY_TRACKABLE = True SECURITY_USER_IDENTITY_ATTRIBUTES = 'username' SECURITY_CLI_USERS_NAME = False
from environs import Env from dvvset import DVVSet import boto3 from botocore.config import Config from botocore.utils import fix_s3_host env = Env() env.read_env('.env') #logger = logging.getLogger(__name__) # pylint: disable=invalid-name for name in ['botocore', 's3transfer', 'boto3']: logging.getLogger(name).setLevel(logging.CRITICAL) BASE_URL = env.str("BASE_URL", "https://lightupon.cloud") USERNAME_1 = env.str("USERNAME_1") PASSWORD_1 = env.str("PASSWORD_1") USERNAME_2 = env.str("USERNAME_2") PASSWORD_2 = env.str("PASSWORD_2") TEST_BUCKET_1 = env.str("TEST_BUCKET_1") TEST_BUCKET_2 = env.str("TEST_BUCKET_2") UPLOADS_BUCKET_NAME = env.str("UPLOADS_BUCKET_NAME") ACCESS_KEY = env.str("ACCESS_KEY") SECRET_KEY = env.str("SECRET_KEY") HTTP_PROXY = env.str("HTTP_PROXY") RIAK_ACTION_LOG_FILENAME = ".riak_action_log.xml" FILE_UPLOAD_CHUNK_SIZE = 2000000
import os from pathlib import Path from environs import Env custom_app_env = Env() custom_app_env.read_env(recurse=False) EVENTY_UPLOADS_DIR = custom_app_env.str("EVENTY_UPLOADS_DIR", default="uploads/")
import dj_database_url import os 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__))) ALLOWED_HOSTS = env.list('ALLOWED_HOSTS', []) SECRET_KEY = env.str('SECRET_KEY', 'REPLACE_ME') DEBUG = env.bool('DEBUG', 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.humanize', 'property.apps.PropertyConfig', ] MIDDLEWARE = [
from environs import Env env = Env() env.read_env() ENVIRONMENT = env.str("ENVIRONMENT") BOT_ERTAOZ_TOKEN = env.str("BOT_ERTAOZ_TOKEN") BOT_ERTAOZ_WEBHOOK_PORT = env.int("PORT") CORONA_API_ID = env.str("CORONA_API_ID") IMGFLIP_API_USERNAME = env.str("IMGFLIP_API_USERNAME") IMGFLIP_API_PASSWORD = env.str("IMGFLIP_API_PASSWORD") WEATHER_API_ID = env.str("WEATHER_API_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())
# -*- coding: utf-8 -*- """Application configuration. Most configuration is set via environment variables. For local development, use a .env file to set environment variables. """ from environs import Env env = Env() env.read_env() ENV = env.str('FLASK_ENV', default='production') DEBUG = ENV == 'development' SECRET_KEY = env.str('SECRET_KEY') BCRYPT_LOG_ROUNDS = env.int('BCRYPT_LOG_ROUNDS', default=13) DEBUG_TB_ENABLED = DEBUG DEBUG_TB_INTERCEPT_REDIRECTS = False CACHE_TYPE = 'simple' # Can be "memcached", "redis", etc. SQLALCHEMY_TRACK_MODIFICATIONS= False
from pathlib import Path from environs import Env import django_heroku 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.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 = ['.herokuapp.com', 'localhost', '127.0.0.1'] # Application definition INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'crispy_forms', 'accounts',
import os from pathlib import Path from environs import Env env = Env() env.read_env() DATABASES = { 'default': { 'ENGINE': 'django.db.backends.postgresql_psycopg2', 'HOST': env.str('DB_HOST'), 'PORT': env.int('DB_PORT'), 'NAME': env.str('DB_NAME'), 'USER': env.str('DB_USER'), 'PASSWORD': env.str('DB_PASSWORD'), } } INSTALLED_APPS = ['datacenter'] SECRET_KEY = env.str('SECRET_KEY') DEBUG = env.bool('DEBUG', default=False) ROOT_URLCONF = "project.urls" ALLOWED_HOSTS = ['*'] BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) TEMPLATES = [
import discord from datetime import datetime, timedelta from enum import Enum from random import randint, choice import uuid from collections import deque from discord.ext import commands from environs import Env from discord.ext import tasks, commands env = Env() env.read_env() SUPER_SECRET_API_KEY = env.str("SUPER_SECRET_API_TOKEN") description = "A simple bot to delegate chores in our house. Originally developed for Riverknoll 24" bot = commands.Bot(command_prefix="$", description=description) @bot.event async def on_connect(): print("Developer Test Server has connected!") @bot.event async def on_ready(): print('Logged on as {0}!'.format(bot.user)) @bot.event
import logging import os from pathlib import Path from environs import Env BASE_DIR = Path(__file__).resolve().parent.parent env = Env() env.read_env() SECRET_KEY = env.str( 'SECRET_KEY', default='hw2(+p5!vzlygt53f!jqd7oif9=&yyaxz=0$t_i%##v+o16dj%') DEBUG = env.bool('DEBUG', default=True) ALLOWED_HOSTS = ['*'] INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'graphene_django', 'huey.contrib.djhuey', 'chowkidar', 'user', 'event', 'judging', 'certificate' # 'payment', ] MIDDLEWARE = [ 'framework.utils.auth.CORSMiddleware', 'django.middleware.security.SecurityMiddleware', 'django.contrib.sessions.middleware.SessionMiddleware', 'django.middleware.common.CommonMiddleware',
#!/usr/bin/env python3 # # Copyright (c) 2019-2021 LG Electronics, Inc. # # This software contains code licensed as described in LICENSE. # from environs import Env import lgsvl print("Python API Quickstart #20: Enabling and disabling sensors") env = Env() sim = lgsvl.Simulator( env.str("LGSVL__SIMULATOR_HOST", lgsvl.wise.SimulatorSettings.simulator_host), env.int("LGSVL__SIMULATOR_PORT", lgsvl.wise.SimulatorSettings.simulator_port)) if sim.current_scene == lgsvl.wise.DefaultAssets.map_borregasave: sim.reset() else: sim.load(lgsvl.wise.DefaultAssets.map_borregasave) spawns = sim.get_spawn() state = lgsvl.AgentState() state.transform = spawns[1] ego = sim.add_agent( env.str("LGSVL__VEHICLE_0", lgsvl.wise.DefaultAssets.ego_lincoln2017mkz_apollo5), lgsvl.AgentType.EGO, state)
# https://docs.djangoproject.com/en/2.2/ref/settings/#internal-ips If # IN_DOCKER, the IP address that needs to go here to enable the debugging # toolbar can change each time the bridge network is brought down. It's # possible to extract the correct address from an incoming request, so if # IN_DOCKER and DEBUG=true, then the `api_v1_root` view will insert the correct # IP when the first request comes in. INTERNAL_IPS = ["127.0.0.1"] # See /env.template if not IN_DOCKER or RUNNING_TESTS: SECRET_KEY = "!j1&*$wnrkrtc-74cc7_^#n6r3om$6s#!fy=zkd_xp(gkikl+8" DEBUG = True ALLOWED_HOSTS = [] else: SECURE_PROXY_SSL_HEADER = ("HTTP_X_FORWARDED_PROTO", "https") SECRET_KEY = env.str("SECRET_KEY") DEBUG = env.bool("DEBUG", default=False) ALLOWED_HOSTS = env.str("DOMAINS").split() + env.str("IPS").split() POSTGRES_PASSWORD = env("POSTGRES_PASSWORD") SESSION_COOKIE_SECURE = IN_DOCKER CSRF_COOKIE_SECURE = IN_DOCKER SESSION_COOKIE_AGE = 900 # seconds SESSION_EXPIRE_SECONDS = 900 # seconds SESSION_EXPIRE_AFTER_LAST_ACTIVITY = True SESSION_TIMEOUT_REDIRECT = "/api/auth/logout/?next=/api/v1/" # Application definition API_TITLE = "SCOS Sensor API"
from environs import Env # Получаем значение переменых env = Env() env.read_env() BOT_TOKEN = env.str("BOT_TOKEN") # Забираем значение типа str ADMINS = env.str("ADMINS") # Тут у нас будет список из админов IP = env.str("ip") # Тоже str, но для айпи адреса хоста
from flask import Flask, request from flask_migrate import Migrate from flask_sqlalchemy import SQLAlchemy from flask_cors import CORS 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,
# Параметры конфигурации приложения from environs import Env import aiohttp # Инициализация переменной для чтения переменных окружения или файла-.env env = Env() env.read_env() # Прокси для Телеграма - неактуально, потому что разблокировали в России, # но в некоторых случаях может быть нужно proxy_enabled = False # Читаем переменные окружения TELEGRAM_API_TOKEN = env.str("TELEGRAM_API_TOKEN") YANDEX_API_KEY = env.str("YANDEX_API_KEY") PROXY_URL = None PROXY_AUTH = None if proxy_enabled: PROXY_URL = env.str("TELEGRAM_PROXY_URL", '') PROXY_AUTH = aiohttp.BasicAuth(login=env.str("TELEGRAM_PROXY_LOGIN"), password=env.str("TELEGRAM_PROXY_PASSWORD")) # Считываем настройки базы данных DB_HOST = env.str("DB_HOST") DB_USER = env.str("DB_USER") DB_PASSWORD = env.str("DB_PASSWORD") DB_NAME = env.str("DB_NAME") DB_TYPE = env.int("DB_TYPE", 1) # Database type: 1 - Postgresql, 0 - SQLite3
# -*- coding: utf-8 -*- """Application configuration. Most configuration is set via environment variables. For local development, use a .env file to set environment variables. """ from environs import Env env = Env() env.read_env() ENV = env.str('FLASK_ENV', default='production') DEBUG = ENV == 'development' SQLALCHEMY_DATABASE_URI = env.str('DATABASE_URL') SECRET_KEY = env.str('SECRET_KEY') BCRYPT_LOG_ROUNDS = env.int('BCRYPT_LOG_ROUNDS', default=13) DEBUG_TB_ENABLED = DEBUG DEBUG_TB_INTERCEPT_REDIRECTS = False CACHE_TYPE = 'simple' # Can be "memcached", "redis", etc. SQLALCHEMY_TRACK_MODIFICATIONS = False #./webpack/manifest.json #WEBPACK_MANIFEST_PATH = 'None'
from environs import Env env = Env() env.read_env() BOT_TOKEN = env.str("BOT_TOKEN") ADMINS = env.list("ADMINS")
import os import django_heroku 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.0/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 = True ALLOWED_HOSTS = ["*"] # 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 environs import Env env = Env() env.read_env() DATABASES = { 'default': { 'ENGINE': 'django.db.backends.postgresql_psycopg2', 'HOST': env.str("HOST"), 'PORT': env.str("PORT"), 'NAME': env.str("NAME"), 'USER': env.str("USER"), 'PASSWORD': env.str("PASSWORD"), } } INSTALLED_APPS = ['datacenter'] SECRET_KEY = 'REPLACE_ME' DEBUG = env.bool("DEBUG") ROOT_URLCONF = "project.urls" ALLOWED_HOSTS = ['*'] BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) TEMPLATES = [ {
from environs import Env from invite0 import data env = Env() env.read_env() SERVER_NAME = env.str('INVITE0_DOMAIN') ORG_NAME = env.str('ORG_NAME') ORG_LOGO = env.url('ORG_LOGO', default=None).geturl() USER_FIELDS = env.list( 'USER_FIELDS', default=['picture', 'nickname', 'given_name', 'family_name']) REQUIRED_USER_FIELDS = env.list('REQUIRED_USER_FIELDS', default=[]) INVITE_EXPIRATION_DAYS = env.decimal('INVITE_EXPIRATION_DAYS', default=5) INVITE_SUBJECT = env.str('INVITE_SUBJECT', default=f'{ORG_NAME} | Sign Up') INVITE_PERMISSION = env.str('INVITE_PERMISSION', default='send:invitation') WELCOME_URL = env.url('WELCOME_URL', default=None).geturl() SECRET_KEY = env.str('SECRET_KEY') MAIL_SERVER = env.str('MAIL_SERVER') MAIL_PORT = env.str('MAIL_PORT') MAIL_USE_TLS = env.bool('MAIL_USE_TLS', default=False) MAIL_USE_SSL = env.bool('MAIL_USE_SSL', default=False) MAIL_USERNAME = env.str('MAIL_USERNAME') MAIL_PASSWORD = env.str('MAIL_PASSWORD') MAIL_SENDER_NAME = env.str('MAIL_SENDER_NAME', default=None) MAIL_SENDER_ADDRESS = env.str('MAIL_SENDER_ADDRESS') MAIL_MAX_EMAILS = env.int('MAIL_MAX_EMAILS', default=None) AUTH0_CLIENT_ID = env.str('AUTH0_CLIENT_ID')
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'), })
# -*- coding: utf-8 -*- """Application configuration. Most configuration is set via environment variables. For local development, use a .env file to set environment variables. """ import os from environs import Env env = Env() env.read_env() ENV = env.str("FLASK_ENV", default="production") DEBUG = ENV == "development" SQLALCHEMY_DATABASE_URI = env.str("DATABASE_URL") SECRET_KEY = env.str("SECRET_KEY") BCRYPT_LOG_ROUNDS = env.int("BCRYPT_LOG_ROUNDS", default=13) DEBUG_TB_ENABLED = DEBUG DEBUG_TB_INTERCEPT_REDIRECTS = False CACHE_TYPE = "simple" # Can be "memcached", "redis", etc. SQLALCHEMY_TRACK_MODIFICATIONS = False WEBPACK_MANIFEST_PATH = "webpack/manifest.json" UPLOADS_DEFAULT_DEST = os.path.abspath(os.curdir) + env.str("UPLOADS_DEFAULT_DEST") UPLOADS_DEFAULT_URL = env.str("UPLOADS_DEFAULT_URL") CELERY_BROKER_URL = env.str("CELERY_BROKER_URL") CELERY_RESULT_BACKEND = env.str("CELERY_RESULT_BACKEND") MAIL_SERVER = env.str("MAIL_SERVER") MAIL_PORT = env.str("MAIL_PORT")
os.environ['TTL'] = '-2' os.environ['NODE_ENV'] = 'invalid' os.environ['EMAIL'] = '^_^' env = Env() # simple validator try: env.int('TTL', validate=lambda n: n > 0) # => 'sloria' except EnvError as err: print(err) # marshmallow validator try: env.str('NODE_ENV', validate=OneOf(['production', 'development'], error='NODE_ENV must be one of: {choices}')) except EnvError as err: print(err) # multiple validators try: env.str('EMAIL', validate=[Length(min=4), Email()]) except EnvError as err: print(err)
# The average number of requests Scrapy should be sending in parallel to # each remote server # AUTOTHROTTLE_TARGET_CONCURRENCY = 1.0 # Enable showing throttling stats for every response received: # AUTOTHROTTLE_DEBUG = False # Enable and configure HTTP caching (disabled by default) # See https://docs.scrapy.org/en/latest/topics/downloader-middleware.html#httpcache-middleware-settings # HTTPCACHE_ENABLED = True # HTTPCACHE_EXPIRATION_SECS = 0 # HTTPCACHE_DIR = 'httpcache' # HTTPCACHE_IGNORE_HTTP_CODES = [] # HTTPCACHE_STORAGE = 'scrapy.extensions.httpcache.FilesystemCacheStorage' RedisDB = env.int("RedisDB", 5) RedisHOST = env.str("RedisHost", 'host') RedisPORT = env.int("RedisPort", 'port') RedisPASSWD = env.str("PASSWD", 'password') # connection Redis redisConnection = Redis(host=RedisHOST, port=RedisPORT, password=RedisPASSWD, db=RedisDB, health_check_interval=30) # test example # conn.set("a", 'b') # print(conn.get('a')) # conn.lpush("GuShiWen:start_urls", "http://gushiwen.org") # print(conn.keys('*')) # print(conn.lrange("GuShiWen:start_urls", 0, 0))
# Django settings for checkerservice project. #https://blog.apptension.com/2017/11/09/how-to-configure-django-project-for-multiple-environments/ import os from environs import Env import json print("start base") BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) env = Env() ENV = env.str('FLASK_ENV', default='production') DEBUG = ENV == 'development' SQLALCHEMY_DATABASE_URI = env.str('DATABASE_URL') SECRET_KEY = env.str('SECRET_KEY') BCRYPT_LOG_ROUNDS = env.int('BCRYPT_LOG_ROUNDS', default=13) DEBUG_TB_ENABLED = DEBUG DEBUG_TB_INTERCEPT_REDIRECTS = False CACHE_TYPE = 'simple' # Can be "memcached", "redis", etc. SQLALCHEMY_TRACK_MODIFICATIONS = False WEBPACK_MANIFEST_PATH = 'webpack/manifest.json' WTF_CSRF_CHECK_DEFAULT = False LOC = 'loc' DEV = 'dev' TST = 'tst' PRD = 'prd'
# -*- coding: utf-8 -*- """Application configuration. Most configuration is set via environment variables. For local development, use a .env file to set environment variables. """ from environs import Env env = Env() env.read_env() ENV = env.str('FLASK_ENV', default='production') DEBUG = ENV == 'development' SQLALCHEMY_DATABASE_URI = env.str('DATABASE_URL') SECRET_KEY = env.str('SECRET_KEY') BCRYPT_LOG_ROUNDS = env.int('BCRYPT_LOG_ROUNDS', default=13) DEBUG_TB_ENABLED = DEBUG DEBUG_TB_INTERCEPT_REDIRECTS = False CACHE_TYPE = 'simple' # Can be "memcached", "redis", etc. SQLALCHEMY_TRACK_MODIFICATIONS = False WEBPACK_MANIFEST_PATH = 'webpack/manifest.json'