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
