Exemple #1
0
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),
Exemple #2
0
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',
Exemple #3
0
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")
Exemple #4
0
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)
Exemple #6
0
    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:
Exemple #7
0
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
Exemple #8
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())
Exemple #10
0
# -*- 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'
Exemple #11
0
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",
Exemple #13
0
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
Exemple #14
0
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
Exemple #15
0
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/")
Exemple #16
0
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")
Exemple #18
0
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())
Exemple #19
0
# -*- 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

Exemple #20
0
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',
Exemple #21
0
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 = [
Exemple #22
0
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
Exemple #23
0
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',
Exemple #24
0
#!/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)
Exemple #25
0
# 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"
Exemple #26
0
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, но для айпи адреса хоста
Exemple #27
0
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,
Exemple #28
0
# Параметры конфигурации приложения

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
Exemple #29
0
# -*- 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'
Exemple #30
0
from environs import Env

env = Env()
env.read_env()

BOT_TOKEN = env.str("BOT_TOKEN")
ADMINS = env.list("ADMINS")
Exemple #31
0
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",
Exemple #32
0
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 = [
    {
Exemple #33
0
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'),
        })
Exemple #35
0
# -*- 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)
Exemple #37
0
# 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))
Exemple #38
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'
Exemple #39
0
# -*- 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'