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 *
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'