def get_int_key(name, required=False):
if name in DEFAULTS:
default = DEFAULTS[name]
else:
default = None
if not (data := env.int(name, default=default)) and not required:
log.warn('No int key: ' + name)
return None
def _openParams(pfile):
# Try to load environment variables
if set(DOCKER_MANDATORY_VARENV).issubset(set(os.environ)):
return {
'grdf': {
'username': env(DOCKER_MANDATORY_VARENV[0]),
'password': env(DOCKER_MANDATORY_VARENV[1]),
'pce': env(DOCKER_MANDATORY_VARENV[2])
},
'influx': {
'host': env(DOCKER_MANDATORY_VARENV[3]),
'port': env.int(DOCKER_OPTIONAL_VARENV[0], default=8086),
'db': env(DOCKER_MANDATORY_VARENV[4]),
'username': env(DOCKER_MANDATORY_VARENV[5]),
'password': env(DOCKER_MANDATORY_VARENV[6]),
'ssl': env.bool(DOCKER_OPTIONAL_VARENV[1], default=True),
'verify_ssl': env.bool(DOCKER_OPTIONAL_VARENV[2], default=True)
},
'mqtt': {
'host': env(DOCKER_MANDATORY_VARENV[7]),
'port': env.int(DOCKER_OPTIONAL_VARENV[3], default=1883),
'keepalive': env.int(DOCKER_OPTIONAL_VARENV[4], default=60),
'topic': env(DOCKER_OPTIONAL_VARENV[5], default='gazpar/')
}
}
# Try to load .params then programs_dir/.params
elif os.path.isfile(os.getcwd() + pfile):
p = os.getcwd() + pfile
elif os.path.isfile(os.path.dirname(os.path.realpath(__file__)) + pfile):
p = os.path.dirname(os.path.realpath(__file__)) + pfile
else:
if (os.getcwd() + pfile !=
os.path.dirname(os.path.realpath(__file__)) + pfile):
logging.error('file %s or %s not exist',
os.path.realpath(os.getcwd() + pfile),
os.path.dirname(os.path.realpath(__file__)) + pfile)
else:
logging.error('file %s not exist', os.getcwd() + pfile)
sys.exit(1)
try:
f = open(p, 'r')
try:
array = json.load(f)
except ValueError as e:
logging.error('decoding JSON has failed', e)
sys.exit(1)
except IOError:
logging.error('cannot open %s', p)
sys.exit(1)
else:
f.close()
return array
def get_postgres_uri() -> str:
host = env.str("POSTGRES_HOST")
port = env.int("POSTGRES_PORT")
user = env.str("POSTGRES_USER")
password = env.str("POSTGRES_PASSWORD")
db = env.str("POSTGRES_DB")
return f"postgresql://{user}:{password}@{host}:{port}/{db}"
def generate(cls):
load_dotenv()
return cls.Struct(mock_api=env.bool('MOCK_API', default=False),
api_key=env.str('AIRNOW_API_KEY'),
zip_code=env.str('ZIP_CODE'),
poll_interval=env.int('POLL_INTERVAL', default=300),
debug=env.bool('DEBUG', default=False))
def generate_date_style_xml(self) -> str:
"""
generate style_xml for date
:return: rendered style_xml for a date
"""
# set style filename
style_file: str = "{}-project.mml".format(self.request_date_to_string())
if env.bool("CACHE", default=False):
# try if exists to get cache style_xml
try:
current_style_xml = cache.get(style_file)
if current_style_xml:
return current_style_xml
except (redis.exceptions.ConnectionError, redis.exceptions.DataError) as exc:
print(exc)
# render current_style_xml with style_xml_template
template: Template = Template(self.style_xml_template)
current_style_xml: str = template.render(date=self.request_date)
if env.bool("CACHE", default=False):
# upload style_xml file to redis cache
cache.set(style_file, current_style_xml, ex=env.int("CAHCE_EXPIRE_TIME", default=3600))
return current_style_xml
def _set_env_config(self):
"""
Read .env file and set configs to be accessed from app.
"""
logger.debug('Set env config')
self.DEBUG = env.bool('DEBUG')
self.APP_PORT = env.int('APP_PORT')
self.MYSQL_HOST = env('MYSQL_HOST')
self.MYSQL_PORT = env.int('MYSQL_PORT')
self.MYSQL_DATABASE = env('MYSQL_DATABASE')
self.MYSQL_USER = env('MYSQL_USER')
self.MYSQL_PASSWORD = env('MYSQL_PASSWORD')
self.MYSQL_ROOT_PASSWORD = env('MYSQL_ROOT_PASSWORD')
self.SHUTDOWN_WAIT_TIME = env.int('SHUTDOWN_WAIT_TIME')
self.PUBLIC_KEY = env('PUBLIC_KEY')
self.PRIVATE_KEY = env('PRIVATE_KEY')
self.WORD_SALT = env('WORD_SALT')
def render_tile(self) -> bytes:
"""
generate tile or load it from redis cache
:return: tile as png image in bytes format
"""
tile_name: str = '/tmp/{}-{}-{}-{}.png'.format(
self.request_date_to_string(), self.zoom, self.x_pixel,
self.y_pixel)
if env.bool("CACHE", default=False):
# try if exists to get cache style_xml
try:
tile_content = cache.get(tile_name)
if tile_content:
return tile_content
except (redis.exceptions.ConnectionError,
redis.exceptions.DataError) as exc:
print(exc)
os.chdir(os.environ['STYLE_PATH'])
map: mapnik.Map = mapnik.Map(self.width, self.height)
mapnik.load_map_from_string(map, self.generate_date_style_xml())
prj: mapnik.Projection = mapnik.Projection(
"+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +wktext +no_defs +over"
)
p0 = self.from_px_to_ll(
(self.width * self.x_pixel, self.height * (self.y_pixel + 1)),
self.zoom)
p1 = self.from_px_to_ll(
(self.width * (self.x_pixel + 1), self.height * self.y_pixel),
self.zoom)
c0 = prj.forward(mapnik.Coord(p0[0], p0[1]))
c1 = prj.forward(mapnik.Coord(p1[0], p1[1]))
bbox: mapnik.Envelope = mapnik.Envelope(c0.x, c0.y, c1.x, c1.y)
map.zoom_to_box(bbox)
image: mapnik.Image = mapnik.Image(self.width, self.height)
mapnik.render(map, image)
# todo generate tile without save it to hdd
mapnik.render_to_file(map, tile_name)
tile_content: bytes = open(tile_name, 'rb').read()
os.remove(tile_name)
if env.bool("CACHE", default=False):
# upload style_xml file to redis cache
cache.set(tile_name,
tile_content,
ex=env.int("CAHCE_EXPIRE_TIME", default=3600))
return tile_content
def __init__(self):
self.db_connection_string = env.str("DB_CONNECTION_STRING", default="")
self.telegram_api_key = env.str("TELEGRAM_API_KEY", default="")
self.seq_host = env.str("SEQ_LOG_HOST", default="")
self.start_time = self._read_time(
env.str("START_TIME", default="09:00"))
self.end_time = self._read_time(env.str("END_TIME", default="23:59"))
self.language = self._read_language(env.str("LANGUAGE", default="tr"))
self.it_lang_server = env.str("ITALIAN_LANGUAGE_SERVER", default="")
self.game_stopped = env.bool("GAME_STOPPED", default=False)
self.email_enabled = env.bool("EMAIL_ENABLED", default=False)
self.moderator = env.int("MODERATOR", default=1065263859)
class Config:
DISABLE_AUTH = False
SECRET_KEY = os.urandom(16)
# Файл с переменными ".env"
env.read_envfile()
LOG_LEVEL = env.str('LOG_LEVEL', default='INFO')
DEBUG = False
if LOG_LEVEL == 'DEBUG':
DEBUG = True
REST_TIME = env.int('REST_TIME', default=4)
APPNAME = env.str('APPNAME', default='default application')
OLD_DAYS_LOGINS = env.int('OLD_LOGINS', default=17)
PREFIX_OO = env.list('PREFIX_OO', default=[])
# options for flask
LOGGER_NAME = APPNAME
API_HOST = env.str('API_HOST', default='localhost')
API_PORT = env.int('API_PORT', default=5050)
CSRF_ENABLED = True
DISABLE_REAL_NAMES = env.bool('DISABLE_REAL_NAMES', default=False)
# options for base
DB_HOST = env.str('DB_HOST', default='localhost')
DB_PORT = env.int('DB_PORT', default=5432)
DB_BASE = env.str('DB_BASE', default='postgres')
DB_USER = env.str('DB_USER', default='postgres')
DB_PASS = env.str('DB_PASS', default='')
# options for LDAP
LD_SERVER = env.str('LD_SERVER', default='ldap://localhost:389')
LD_USER = env.str('LD_USER', default='')
LD_PASS = env.str('LD_PASS', default='')
LD_BASE_DN = env.str('LD_BASE_DN', default='')
LD_PAGE_SIZE = env.int('LD_PAGE_SIZE', default=1000)
def setup_config(app, file_name='.config'):
path_to_file = os.path.join(app['project_root'], file_name)
if isfile(path_to_file):
env.read_envfile(file_name)
app['config'] = {
'HOST': env.str('SERVER_HOST'),
'PORT': env.int('SERVER_PORT'),
'POSTGRES_DATABASE': env.str('POSTGRES_DATABASE'),
'POSTGRES_USER': env.str('POSTGRES_USER'),
'POSTGRES_PASSWORD': env.str('POSTGRES_PASSWORD'),
'POSTGRES_HOST': env.str('POSTGRES_HOST'),
'POSTGRES_PORT': env.str('POSTGRES_PORT'),
'REDIS_HOST': env.str('REDIS_HOST'),
'REDIS_PORT': env.str('REDIS_PORT'),
'BOT_TOKEN': env.str('BOT_TOKEN'),
'BOT_CHANNEL': env.str('BOT_CHANNEL')
}
from envparse import env
from . import cli
env.read_envfile(cli.CONFIG_FILE)
CLICKHOUSE_LOGGING_ENABLED = env.bool("CLICKHOUSE_LOGGING_ENABLED", default=False)
CLICKHOUSE_HOST = env.str("CLICKHOUSE_HOST", default="localhost")
CLICKHOUSE_USER = env.str("CLICKHOUSE_USER", default="default")
CLICKHOUSE_PASSWORD = env.str("CLICKHOUSE_PASSWORD", default="")
CLICKHOUSE_PORT = env.int("CLICKHOUSE_PORT", default=9000)
CLICKHOUSE_DB = env.str("CLICKHOUSE_DB", default="default")
import os
import sys
from envparse import env
path = os.path.abspath(os.path.dirname(sys.argv[0]))
if os.path.isfile(os.path.join(path, '.env')):
env.read_envfile(os.path.join(path, '.env'))
DATABASE_URL = env.str('DATABASE_CON') + os.path.join(path,
env.str('DATABASE_NAME'))
HEROKU_URL = env.str('HEROKU_URL')
TRAVEL_ROUTE = env.str('TRAVEL_ROUTE')
CHAT_ID = env.int('CHAT_ID')
# celery
BROKER_URL = env.str(
'BROKER_URL') # 'amqp://*****:*****@127.0.0.1:5672/myvhost'
CELERY_RESULT_BACKEND = env.str('CELERY_RESULT_BACKEND') # 'rpc'
AIRPORT_CITY_MAP = {
'MOW': 'Moscow',
'SVO': 'Sheremetevo',
'DME': 'Domodedovo',
'LWN': 'Gyumri',
'EVN': 'Yerevan',
'BOJ': 'Burgas'
}
from envparse import env
env.read_envfile()
AMQP_HOSTNAME = env('KOMPAQ_AMQP_HOSTNAME', default='localhost')
AMQP_VHOST = env('KOMPAQ_AMQP_VHOST', default='/')
AMQP_PORT = env.int('KOMPAQ_AMQP_PORT', default=5672)
AMQP_USERNAME = env('KOMPAQ_AMQP_USERNAME', default='guest')
AMQP_PASSWORD = env('KOMPAQ_AMQP_PASSWORD', default='guest')
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]
# Database
DATABASES = {
'default': {
'ENGINE': env.str('DB_ENGINE'),
'HOST': env.str('DB_HOST'),
'NAME': env.str('DB_NAME'),
'USER': env.str('DB_USER'),
'PASSWORD': env.str('DB_PASSWORD'),
'PORT': env.int('DB_PORT'),
}
}
# Password validation
AUTH_PASSWORD_VALIDATORS = [
{
'NAME':
'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
},
{
'NAME':
'django.contrib.auth.password_validation.MinimumLengthValidator',
},
{
'NAME':
USE_TZ = True
STATIC_URL = "/static/"
STATIC_ROOT = env.str("DJANGO_STATIC_ROOT", default="static/")
STATICFILES_DIRS = [
os.path.join(BASE_DIR, "..", "frontend", "theme", "dist", "assets"),
os.path.join(FRONTEND_DIR, "new", "dist"),
]
MEDIA_ROOT = env.str("DJANGO_MEDIA_ROOT", default="media/")
RQ_ENABLED = env.bool("RQ_ENABLED", default=True)
RQ_QUEUES = {
"default": {
"HOST": env.str("REDIS_HOST", default="localhost"),
"PORT": env.int("REDIS_PORT", default=6379),
"DB": env.int("REDIS_DB", default=0),
"PASSWORD": env.str("REDIS_PASSWORD", default=""),
"DEFAULT_TIMEOUT": 360,
}
}
POCKET_CONSUMER_KEY = env.str("POCKET_CONSUMER_KEY", default="")
REST_FRAMEWORK = {
"DEFAULT_FILTER_BACKENDS":
["django_filters.rest_framework.DjangoFilterBackend"],
"DEFAULT_PERMISSION_CLASSES":
("rest_framework.permissions.IsAuthenticated", ),
"DEFAULT_PAGINATION_CLASS":
"rest_framework.pagination.PageNumberPagination",
from envparse import env
env.read_envfile() # Read .env
ENV = env.str('NODE_ENV', default='production')
DEBUG = ENV != 'production'
CACHE = {
'STRATEGY': 'redis',
'PARAMS': {
'host': env('REDIS_HOST', default='localhost'),
'port': env.int('REDIS_PORT', default=6379),
}
}
ROUTES = {
'URL_PREFIX': '/v1/'
}
GITHUB = {
'CLIENT_ID': env('SIR_GITHUB_CLIENT_ID'),
'CLIENT_SECRET': env('SIR_GITHUB_CLIENT_SECRET'),
}
def __init__(self, page_db):
self.page_db = page_db
from cw<%= appname%>.scraped_websites import scraped_whole_pages_pagination
self.wp_status = WholePagesStatus(scraped_whole_pages_pagination, self.page_db, env.int('scraped_pages_count'))
super(SpiderWholePageDispatch, self).__init__()
def test_int():
expected = int(env_vars['INT'])
assert_type_value(int, expected, env('INT', cast=int))
assert_type_value(int, expected, env.int('INT'))
from envparse import env
MAX_IMG_DIMENSIONAL = env.int("MAX_IMG_DIMENSIONAL", default=1024)
SOURCE_IMG_PATH = env.str("SOURCE_IMG_PATH",
default="images/source/source.jpg")
STYLE_IMG_PATH = env.str("STYLE_IMG_PATH", default="images/style/style.jpg")
RESULT_IMG_PATH = env.str("RESULT_IMG_PATH", default="images/result/")
ITERATIONS_NUM = env.int("ITERATIONS_NUM", default=1000)
CONTENT_WEIGHT = env.float("CONTENT_WEIGHT", default=1e3)
STYLE_WEIGHT = env.float("STYLE_WEIGHT", default=1e-2)
from os.path import isfile
from envparse import env
if isfile('.env'):
env.read_envfile('.env')
DEBUG = env.bool('DEBUG', default=False)
TOKEN_SECRET_KEY = env.str('TOKEN_SECRET_KEY')
SITE_HOST = env.str('HOST', default='127.0.0.1')
SITE_PORT = env.int('PORT', default=8701)
DATABASE_URL = env.str('DATABASE_URL', default='mysql://*****:*****@localhost:3306/pinax_mysite')
DATABASE_URL_r = env.str('DATABASE_URL_r', default='mysql://*****:*****@localhost:3306/pinax_mysite') # 只读库
REDIS_URL = env.str('REDIS_URL', default=False) # cluster
# REDIS_URL_1 = env.str('REDIS_URL_1', default=False)
# REDIS_URL_2 = env.str('REDIS_URL_2', default=False)
# REDIS_URL_3 = env.str('REDIS_URL_3', default=False)
# REDIS_URL = env.str('REDIS_URL', default=False) # cluster
VERIFY_SMS_CHANNEL = env.json('VERIFY_SMS_CHANNEL') # help='根据包名确定推送中心的产品id'
STATUS = {
'OK': 1,
'ERROR': 2,
'INFO': 3,
'UPDATE_USERS': 4
}
import datetime
import secrets
from envparse import env
TELEGRAM_TOKEN = env.str("TELEGRAM_TOKEN")
BOT_PUBLIC_PORT = env.int("BOT_PUBLIC_PORT", default=8080)
DOMAIN = env.str("DOMAIN", default="example.com")
SECRET_KEY = secrets.token_urlsafe(48)
WEBHOOK_BASE_PATH = env.str("WEBHOOK_BASE_PATH", default="/webhook")
WEBHOOK_PATH = f"{WEBHOOK_BASE_PATH}/{SECRET_KEY}"
WEBHOOK_URL = f"https://{DOMAIN}{WEBHOOK_PATH}"
REDIS_HOST = env.str("REDIS_HOST", default="localhost")
REDIS_PORT = env.int("REDIS_PORT", default=6379)
REDIS_DB_FSM = env.int("REDIS_DB_FSM", default=0)
REDIS_DB_JOBSTORE = env.int("REDIS_DB_JOBSTORE", default=1)
REDIS_DB_JOIN_LIST = env.int("REDIS_DB_JOIN_LIST", default=2)
POSTGRES_HOST = env.str("POSTGRES_HOST", default="localhost")
POSTGRES_PORT = env.int("POSTGRES_PORT", default=5432)
POSTGRES_PASSWORD = env.str("POSTGRES_PASSWORD", default="")
POSTGRES_USER = env.str("POSTGRES_USER", default="aiogram")
POSTGRES_DB = env.str("POSTGRES_DB", default="aiogram")
POSTGRES_URI = f"postgresql://{POSTGRES_USER}:{POSTGRES_PASSWORD}@{POSTGRES_HOST}:{POSTGRES_PORT}/{POSTGRES_DB}"
JOIN_MESSAGE_CLEANER = datetime.timedelta(minutes=5)
SUPERUSER_STARTUP_NOTIFIER = env.bool("SUPERUSER_STARTUP_NOTIFIER",
default=False)
from envparse import env
from lib.Predictor import Predictor
from lib.MyEncoder import MyEncoder
# from lib.IO import IOManager
from io import BytesIO
import base64
import paho.mqtt.client as mqtt
# model_dir = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "trained"))
env.read_envfile()
MQ_HOST = env.str("MQ_HOST", default='192.168.179.7')
MQ_PORT = env.int("MQ_PORT", default=1883)
# host = '192.168.179.7'
# port = 1883
topic_image = '/pub/gun/image'
topic_predicted = '/sub/gun/predicted'
YOLO_MODEL_PATH = env.str("YOLO_MODEL_PATH", default='model_data/yolo-tiny.h5')
YOLO_ANCHORS_PATH = env.str("YOLO_ANCHORS_PATH",
default='model_data/tiny_yolo_anchors.txt')
YOLO_CLASSES_PATH = env.str("YOLO_CLASSES_PATH",
default='model_data/coco_classes.txt')
# model_path = 'model_data/yolo-tiny.h5'
# anchors_path = 'model_data/tiny_yolo_anchors.txt'
# classes_path = 'model_data/coco_classes.txt'
'handlers': ['console'],
'propagate': False,
},
},
}
SENTRY_DSN = env.str('SENTRY_DSN', default=None)
if SENTRY_DSN:
RAVEN_CONFIG = {
'dsn': SENTRY_DSN,
}
# RestFul
REST_FRAMEWORK = {
'DEFAULT_RENDERER_CLASSES': ('rest_framework.renderers.JSONRenderer', ),
'PAGE_SIZE': env.int('PAGE_SIZE', default=50),
}
# Application
SITE_NAME = 'Store Search API'
SITE_URL = env.str('SITE_URL', default='http://local.store_search.com.br')
INSTALLED_APPS = [
'raven.contrib.django.raven_compat',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.staticfiles',
'storages',
'rest_framework',
'v1.apps.V1Config',
]
import os
from envparse import env
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
env.read_envfile(os.path.join(BASE_DIR, '.env'))
API_ADDRESS = env.str('API_ADDRESS')
API_PORT = env.int('API_PORT', default=5000)
UPLOADS_DIR = env.str('UPLOADS_DIR', default='uploads/')
UPLOADS_PATH = os.path.join(BASE_DIR, UPLOADS_DIR)
from envparse import env
RABBIT_HOST = env.str('RABBIT_HOST')
RABBIT_PORT = env.int('RABBIT_PORT')
RABBIT_USER = env.str('RABBIT_USER')
RABBIT_PASS = env.str('RABBIT_PASS')
MONGO_HOST = env.str('MONGO_HOST')
MONGO_PORT = env.int('MONGO_PORT')
MONGO_DBNAME = env.str('MONGO_DBNAME')
from envparse import env
env.read_envfile()
# BOT
TELEGRAM_BOT_TOKEN = env.str('TELEGRAM_BOT_TOKEN')
SKIP_UPDATES = env.bool('SKIP_UPDATES')
LOGFILE = env.str('LOGFILE')
OWNER_ID = env.int('OWNER_ID')
# APP
APP_HOST = env.str('APP_HOST', default='localhost')
APP_PORT = env.int('APP_PORT', default=5000)
# REDIS
REDIS_HOST = env.str('REDIS_HOST', default='localhost')
REDIS_PORT = env.int('REDIS_PORT', default=6379)
# WEBHOOK
WEBHOOK_USE = env.bool('WEBHOOK_USE')
WEBHOOK_HOST = env.str('WEBHOOK_HOST')
WEBHOOK_PATH = env.str('WEBHOOK_PATH')
WEBHOOK_PORT = env.int('WEBHOOK_PORT')
# DATABASE
POSTGRES_HOST = env.str('POSTGRES_HOST', default='localhost')
POSTGRES_PORT = env.int('DB_PORT', default=5432)
POSTGRES_USER = env.str('POSTGRES_USER', default='postgres')
POSTGRES_PASSWORD = env.str('POSTGRES_PASSWORD', default=None)
POSTGRES_DB = env.str('POSTGRES_DB')
from envparse import env
# Number of threads in executor
# https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.ThreadPoolExecutor
THREAD_POOL_SIZE = env.int('RAGE_SRV_THREAD_POOL_SIZE', default=4)
# Redis connection settings
REDIS_HOST = env.str('RAGE_SRV_REDIS_HOST', default='127.0.0.1')
REDIS_PORT = env.int('RAGE_SRV_REDIS_PORT', default=6379)
REDIS_DB = env.int('RAGE_SRV_REDIS_DB', default=1)
# Cover-Rage binding address settings. `SRV_SCHEME` could be one of: 'http', 'https'
SRV_SCHEME = env.str('RAGE_SRV_SCHEME', default='https')
SRV_HOST = env.str('RAGE_SRV_HOST')
# Cover-Rage API urls
SRV_API_SEND_RESULTS_URL = '/api/results/{public_token}/'
SRV_API_GITHUB_WEB_HOOK_URL = '/api/github/{public_token}/'
# TODO: change url from API end point to regular view
SRV_STATUS_URL = '/api/status/{public_token}/{sha}/'
# Minimal good coverage percentage (required for background color of badge)
# If project's coverage is less then value of this settings - badge background color will be red.
# If it's greater or equal - badge background color will be green.
# If it's zero (undefined) - badge background color will be orange.
STATICFILES_DIRS = [
os.path.join(BASE_DIR, 'static'),
]
# Media
MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
# Authentication
LOGOUT_REDIRECT_URL = 'home'
LOGIN_REDIRECT_URL = 'home'
# Fixtures
FIXTURE_DIRS = [
os.path.join(BASE_DIR, 'dips', 'tests', 'fixtures'),
]
# Elasticsearch
# RFC-1738 formatted URLs can be used. E.g.:'https://*****:*****@host:443/'
ES_HOSTS = env('ES_HOSTS', cast=list, subcast=str)
ES_TIMEOUT = env.int('ES_TIMEOUT', default=10)
ES_POOL_SIZE = env.int('ES_POOL_SIZE', default=10)
ES_INDEXES_SETTINGS = {
'number_of_shards': env.int('ES_INDEXES_SHARDS', default=1),
'number_of_replicas': env.int('ES_INDEXES_REPLICAS', default=0),
}
log = logging.getLogger('app')
log.setLevel(logging.DEBUG)
f = logging.Formatter('[L:%(lineno)d]# %(levelname)-8s [%(asctime)s] %(message)s', datefmt = '%d-%m-%Y %H:%M:%S')
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
ch.setFormatter(f)
log.addHandler(ch)
if isfile('.env'):
env.read_envfile('.env')
DEBUG = env.bool('DEBUG', default=False)
SITE_HOST = env.str('HOST')
SITE_PORT = env.int('PORT')
SECRET_KEY = env.str('SECRET_KEY')
MYSQL_HOST = env.str('MYSQL_HOST')
MYSQL_DB_NAME = env.str('MYSQL_DB_NAME')
MYSQL_USER = env.str('MYSQL_USER')
MYSQL_PASSWORD = env.str('MYSQL_PASSWORD')
PLAYERS_IN_GAME = 2
STATUS = {
'OK': 1,
'ERROR': 2,
'INFO': 3,
'UPDATE_USERS': 4
}
import os
from envparse import env
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
env.read_envfile(os.path.join(BASE_DIR, '.env'))
UPLOAD_DIR = os.path.join(BASE_DIR, 'uploads/')
POSTGRES_HOST = env.str('DB_HOST', default='localhost')
POSTGRES_PORT = env.int('DB_PORT', default=5432)
POSTGRES_PASSWORD = env.str('DB_PASSWORD', default='')
POSTGRES_USER = env.str('DB_USERNAME')
POSTGRES_DB = env.str('DB_NAME')
POSTGRES_URI = f'postgresql://{POSTGRES_USER}:{POSTGRES_PASSWORD}@{POSTGRES_HOST}:{POSTGRES_PORT}/{POSTGRES_DB}'
from envparse import env
deploy = True
try:
deploy = env.int('DEPLOY')
except:
pass
if deploy:
from wall.settings.deploy import *
else:
from wall.settings.local import *
def test_int():
expected = int(env_vars['INT'])
assert_type_value(int, expected, env('INT', cast=int))
assert_type_value(int, expected, env.int('INT'))
logging.disable(logging.CRITICAL)
PASSWORD_HASHERS = (
'django.contrib.auth.hashers.MD5PasswordHasher',
)
DEBUG = False
TEMPLATE_DEBUG = False
TESTS_IN_PROGRESS = True
MIGRATION_MODULES = DisableMigrations()
DJOSER = {
'PASSWORD_RESET_CONFIRM_URL': '#/password/reset/confirm/{uid}/{token}',
'ACTIVATION_URL': '#/activate/{uid}/{token}'
}
SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https')
SESSION_COOKIE_SECURE = True
CSRF_COOKIE_SECURE = True
if DEBUG:
EMAIL_BACKEND = os.getenv('EMAIL_BACKEND', 'django.core.mail.backends.console.EmailBackend')
else:
EMAIL_BACKEND = os.getenv('EMAIL_BACKEND', 'django.core.mail.backends.smtp.EmailBackend')
DEFAULT_FROM_EMAIL = os.getenv('DEFAULT_FROM_EMAIL', '*****@*****.**')
EMAIL_HOST = os.getenv('EMAIL_HOST', 'localhost')
EMAIL_HOST_USER = os.getenv('EMAIL_HOST_USER', '')
EMAIL_HOST_PASSWORD = os.getenv('EMAIL_HOST_PASSWORD', '')
EMAIL_PORT = env.int('EMAIL_PORT', default=25)
EMAIL_SUBJECT_PREFIX = os.getenv('EMAIL_SUBJECT_PREFIX', '[LessPass] ')
EMAIL_USE_TLS = env.bool('EMAIL_USE_TLS', default=False)
EMAIL_USE_SSL = env.bool('EMAIL_USE_SSL', default=False)
from envparse import env
from app.utils import cli
env.read_envfile(cli.CONFIG_FILE)
def get_project_root() -> Path:
return Path(__file__).parent.parent
local_dir = get_project_root() # каталог с ботом
TELEGRAM_TOKEN = env.str("TELEGRAM_TOKEN", default="")
BOT_PUBLIC_PORT = env.int("BOT_PUBLIC_PORT", default=8080)
LOGS_BASE_PATH = env.str("LOGS_BASE_PATH", default="logs")
SKIP_UPDATES = env.bool("SKIP_UPDATES", default=False)
DOMAIN = env.str("DOMAIN", default="example.com")
SECRET_KEY = secrets.token_urlsafe(48)
WEBHOOK_BASE_PATH = env.str("WEBHOOK_BASE_PATH", default="/tg/webhook")
WEBHOOK_PATH = f"{WEBHOOK_BASE_PATH}/{SECRET_KEY}"
WEBHOOK_URL = f"https://{DOMAIN}{WEBHOOK_PATH}/{TELEGRAM_TOKEN}"
CHECK_IP = env.bool("CHECK_IP", default=False)
POSTGRES_HOST = env.str("POSTGRES_HOST", default="localhost")
POSTGRES_PORT = env.int("POSTGRES_PORT", default=5432)
POSTGRES_PASSWORD = env.str("POSTGRES_PASSWORD", default="")
POSTGRES_USER = env.str("POSTGRES_USER", default="postgres")
POSTGRES_DB = env.str("POSTGRES_DB", default="forge")
from enum import Enum
import os
from envparse import env
env.read_envfile()
class TTSSource(Enum):
Web = 'web'
Local = 'local'
SERVER_PORT = env.int('SERVER_PORT')
BROKER_URL = env('BROKER_URL')
TTS_SOURCE = TTSSource(env('TTS_SOURCE'))
TMPDIR_PATH = env('TMPDIR_PATH')
if not os.path.exists(TMPDIR_PATH):
os.mkdir(TMPDIR_PATH)
TMPDIR_CLEAN_INTERVAL_M = env.int('TMPDIR_CLEAN_INTERVAL_M')
from os.path import isfile
from envparse import env
if isfile('.env'):
env.read_envfile('.env')
DEBUG = env.bool('DEBUG', default=False)
SITE_HOST = env.str('HOST')
SITE_PORT = env.int('PORT')
SECRET_KEY = env.str('SECRET_KEY')
MONGO_HOST = env.str('MONGO_HOST')
MONGO_DB_NAME = env.str('MONGO_DB_NAME')
MESSAGE_COLLECTION = 'messages'
USER_COLLECTION = 'users'
logging.disable(logging.CRITICAL)
PASSWORD_HASHERS = (
'django.contrib.auth.hashers.MD5PasswordHasher',
)
DEBUG = False
TEMPLATE_DEBUG = False
TESTS_IN_PROGRESS = True
MIGRATION_MODULES = DisableMigrations()
DJOSER = {
'PASSWORD_RESET_CONFIRM_URL': '#/password/reset/confirm/{uid}/{token}',
'ACTIVATION_URL': '#/activate/{uid}/{token}'
}
SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https')
SESSION_COOKIE_SECURE = True
CSRF_COOKIE_SECURE = True
if DEBUG:
EMAIL_BACKEND = os.getenv('EMAIL_BACKEND', 'django.core.mail.backends.console.EmailBackend')
else:
EMAIL_BACKEND = os.getenv('EMAIL_BACKEND', 'django.core.mail.backends.smtp.EmailBackend')
DEFAULT_FROM_EMAIL = os.getenv('DEFAULT_FROM_EMAIL', '*****@*****.**')
EMAIL_HOST = os.getenv('EMAIL_HOST', 'localhost')
EMAIL_HOST_USER = os.getenv('EMAIL_HOST_USER', '')
EMAIL_HOST_PASSWORD = os.getenv('EMAIL_HOST_PASSWORD', '')
EMAIL_PORT = env.int('EMAIL_PORT', default=25)
EMAIL_SUBJECT_PREFIX = os.getenv('EMAIL_SUBJECT_PREFIX', '[LessPass] ')
EMAIL_USE_TLS = env.bool('EMAIL_USE_TLS', default=False)
EMAIL_USE_SSL = env.bool('EMAIL_USE_SSL', default=False)
