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'
