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
class config: DEFAULT_USER_AGENT = env.str('DEFAULT_USER_AGENT', default='Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/61.0.3163.91 Safari/537.36') BASE_URL = env.str('BASE_URL', default='https://www.olx.ua/') PHONE_URL = env.str('PHONE_URL', default='https://www.olx.ua/ajax/misc/contact/phone/') CATEGORY = env.str('CATEGORY', default='nedvizhimost') SUB_CATEGORY = env.str('SUB_CATEGORY', default='arenda-kvartir') SUB_SUB_CATEGORY = env.str('SUB_SUB_CATEGORY', default='dolgosrochnaya-arenda-kvartir') CITY = env.str('CITY', default='odessa') DISTRICT_ID = env.int('DISTRICT_ID', default=89) MIN_PRICE = env.int('MIN_PRICE', default=1000) MAX_PRICE = env.int('MAX_PRICE', default=5000) MIN_ROOMS = env.int('MIN_ROOMS', default=1) MAX_ROOMS = env.int('MAX_ROOMS', default=1) WITH_PHOTOS = int(env.bool('WITH_PHOTOS', default=True)) WITH_PROMOTED = env.bool('WITH_PROMOTED', default=False) PUBLICATION_DATE = [item.lower() for item in env.list('PUBLICATION_DATE', default=['сегодня', 'вчера'])] USER_EMAIL = env.str('USER_EMAIL', default=None) USER_PASSWORD = env.str('USER_PASSWORD', default=None) DB_CONFIG = { 'apiKey': env.str('DB_API_KEY', default=''), 'authDomain': env.str('DB_AUTH_DOMAIN', default=''), 'databaseURL': env.str('DB_DATABASE_URL', default=''), 'storageBucket': env.str('DB_STORAGE_BUCKET', default=''), } TELEGRAM_BOT_API_URL = env.str('TELEGRAM_BOT_API_URL', default='https://api.telegram.org/bot') TELEGRAM_BOT_KEY = env.str('TELEGRAM_BOT_KEY', default=None) TELEGRAM_CHAT_IDS = env.list('TELEGRAM_CHAT_IDS', default=[]) LOG_FILENAME = env.str('LOG_FILENAME', default='olx_parser_log')
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))
class Config: """ The base configuration option. Contains the defaults. """ DEBUG = False DEVELOPMENT = False STAGING = False PRODUCTION = False TESTING = False CACHING = False PROFILE = False SQLALCHEMY_RECORD_QUERIES = False FLASK_ADMIN_SWATCH = 'lumen' VERSION = VERSION_NAME SQLALCHEMY_TRACK_MODIFICATIONS = True ERROR_404_HELP = False CSRF_ENABLED = True SERVER_NAME = env('SERVER_NAME', default=None) CORS_HEADERS = 'Content-Type' SQLALCHEMY_DATABASE_URI = env('DATABASE_URL', default=None) SQLALCHEMY_ENGINE_OPTIONS = {'pool_pre_ping': True} SERVE_STATIC = env.bool('SERVE_STATIC', default=False) DATABASE_QUERY_TIMEOUT = 0.1 SENTRY_DSN = env('SENTRY_DSN', default=None) ENABLE_ELASTICSEARCH = env.bool('ENABLE_ELASTICSEARCH', default=False) ELASTICSEARCH_HOST = env('ELASTICSEARCH_HOST', default='localhost:9200') REDIS_URL = env('REDIS_URL', default='redis://localhost:6379/0') CELERY_BACKKEND = env('CELERY_BACKEND', default='redis') # API configs SOFT_DELETE = True PROPOGATE_ERROR = env.bool('PROPOGATE_ERROR', default=False) DASHERIZE_API = True API_PROPOGATE_UNCAUGHT_EXCEPTIONS = env.bool( 'API_PROPOGATE_UNCAUGHT_EXCEPTIONS', default=True) ETAG = True if not SQLALCHEMY_DATABASE_URI: print('`DATABASE_URL` either not exported or empty') exit() BASE_DIR = basedir FORCE_SSL = os.getenv('FORCE_SSL', 'no') == 'yes' if SERVE_STATIC: UPLOADS_FOLDER = BASE_DIR + '/static/uploads/' TEMP_UPLOADS_FOLDER = BASE_DIR + '/static/uploads/temp/' UPLOAD_FOLDER = UPLOADS_FOLDER STATIC_URL = '/static/' STATIC_ROOT = 'staticfiles' STATICFILES_DIRS = (os.path.join(BASE_DIR, 'static'), ) if FORCE_SSL: PREFERRED_URL_SCHEME = 'https'
def get_bool_key(name, required=False): if name in DEFAULTS: default = DEFAULTS[name] else: default = None if not (data := env.bool(name, default=default)) and not required: log.warn('No bool key: ' + name) return False
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)
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 test_get_project__force_env_use__url_token_and_name(self): self.env.update( dict(KECHAIN_URL=TEST_URL, KECHAIN_TOKEN=TEST_TOKEN, KECHAIN_SCOPE_ID=TEST_SCOPE_ID, KECHAIN_FORCE_ENV_USE='True')) with self.env: self.assertTrue(env.bool(KechainEnv.KECHAIN_FORCE_ENV_USE)) self.assertEqual(get_project().name, TEST_SCOPE_NAME)
def test_get_project__force_env_use__only_url(self): self.env.update( dict(KECHAIN_URL=TEST_URL, KECHAIN_FORCE_ENV_USE='True')) with self.env: self.assertTrue(env.bool(KechainEnv.KECHAIN_FORCE_ENV_USE)) with self.assertRaisesRegex( ClientError, "should be provided as environment variable"): # Error: KECHAIN_SCOPE or KECHAIN_SCOPE_ID should be provided as environment variable get_project()
def __init__(self, save_to_file=False, in_memory=False, use_env=False) -> None: if use_env: save_to_file = env.bool('MAIL_RECORDER_SAVE_TO_FILE', default=save_to_file) self.save_to_file = save_to_file self.in_memory = save_to_file or in_memory
def test_get_project__force_env_use_no_vars(self): """Test the get_project by using KECHAIN_FORCE_ENV_USE=True""" self.env.set('KECHAIN_FORCE_ENV_USE', 'True') with self.env: self.assertTrue(env.bool(KechainEnv.KECHAIN_FORCE_ENV_USE)) with self.assertRaisesRegex( ClientError, "should be provided as environment variable"): # KECHAIN_SCOPE or KECHAIN_SCOPE_ID should be provided as environment variable get_project()
def test_get_project__force_env_use__other_things_provided(self): self.env.update( dict(KECHAIN_URL=TEST_URL, KECHAIN_TOKEN=TEST_TOKEN, KECHAIN_SCOPE_ID=TEST_SCOPE_ID, KECHAIN_FORCE_ENV_USE='True')) with self.env: self.assertTrue(env.bool(KechainEnv.KECHAIN_FORCE_ENV_USE)) self.assertEqual( get_project(url='http://whatever', token=PSEUDO_TOKEN).name, TEST_SCOPE_NAME)
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')
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)
from envparse import env env.read_envfile() # DEBUG variable DEBUG = env.bool('BADGEYAY_DEBUG', default=True) # Environment for working, can be LOCAL/PROD ENV = env.str('BADGEYAY_ENV', default='PROD') # Sample config for PostgreSQL Database POSTGRES = { 'user': env.str('BADGEYAY_DATABASE_OWNER', default='postgres'), 'pw': env.str('BADGEYAY_DATABASE_PASSWORD', default='postgres'), 'host': 'localhost', 'port': '5432', 'db': env.str('BADGEYAY_DATABASE', default='badgeyay'), 'secret': 'thisisaverysupersecretkeyforfossasiabadgeyay' } # Posts per page to be shown POSTS_PER_PAGE = 10 admins = ['*****@*****.**']
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) # Server variables SERVER_IP = env.str("MC_SERVER_IP") RCON_SECRET = env.str("RCON_PASSWORD") # Telegram ID's MAIN_GROUP_ID = env.int("MAIN_GROUP_ID") ADMINS = [84001357]
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')
"""Django project settings.""" import os import datetime from envparse import env BASE_DIR = env.str('BASE_DIR') SECRET_KEY = env.str('SECRET_KEY') DEBUG = env.bool('DEBUG') DJANGO_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', ] THIRD_PARTY_APPS = [ 'rest_framework', ] PROJECT_APPS = [ 'apps.user', 'apps.tos', ] INSTALLED_APPS = DJANGO_APPS + THIRD_PARTY_APPS + PROJECT_APPS MIDDLEWARE = [ 'django.middleware.security.SecurityMiddleware', 'django.contrib.sessions.middleware.SessionMiddleware',
import os from django.core.exceptions import ImproperlyConfigured from envparse import 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__))) SECRET_KEY = env('DCL_SECRET_KEY') DEBUG = env.bool('DCL_DEBUG', default=True) DO_INDEX_REDIRECT = env.bool('DCL_DO_INDEX_REDIRECT', default=not DEBUG) # update it to your domain if you want ALLOWED_HOSTS = ['*'] # 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', 'dcl_server', 'dcl_server.ui', 'dcl_server.accreditations', 'dcl_server.dcl_audit', 'djangooidc', # authorize from OIDC providers
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")
logging.basicConfig() logger = logging.getLogger(__name__) logger.setLevel(logging.DEBUG) from imapclient import IMAPClient env.read_envfile() if __name__ == '__main__': logger.info('start IMAP') server = IMAPClient(env('HOST'), port=env('PORT', default=None), use_uid=True, ssl=env.bool('SSL', default=True)) logger.info(' [+] LOGIN') server.login(env('USERNAME'), env('PASSWORD')) select_info = server.select_folder('INBOX') print('%d messages in INBOX' % select_info['EXISTS']) messages = server.search(['NOT', 'DELETED']) print("%d messages that aren't deleted" % len(messages)) print() print("Messages:") # https://tools.ietf.org/html/rfc3501.html#section-6.4.5 response = server.fetch(messages, ['FLAGS', 'ENVELOPE', ]) for msgid, data in response.iteritems():
from os.path import isfile from envparse import env if isfile('environments.env'): env.read_envfile('environments.env') DEBUG = env.bool('DEBUG', default=True) SITE_HOST = env.str('HOST') SITE_PORT = env.int('PORT') MASTER_KEY = env.str('MASTER_KEY') COOKIE_SECRET = env.str('COOKIE_SECRET') STATIC_PATH = env.str('STATIC_PATH') STATIC_URL = env.str('STATIC_URL') TEMPLATE_PATH = env.str('TEMPLATE_PATH') SESSION_EXPIRE = 3600 * 24 * 15 # 3600 * 24 * 30 HASH_EXPIRE = 3600 * 2 # 3600 * 24 * 30 COOKIE_EXPIRE = 3600 * 24 PROJECT_PREFIX = "ldoe_support" USERS = { "admin": { "pwd": "123", "uid": "123" }, "user": { "pwd": "1 ", "uid": "1"
import signal import datetime import pytz import time import logging from envparse import env from kubernetes import client, config import urllib3.request import boto3 import pprint import gzip import json import re DEBUG = env("DEBUG", cast=str, default="DEBUG") NOOP = env.bool("NOOP",default=False) if DEBUG == "DEBUG": LOGLEVEL = logging.DEBUG elif DEBUG == "INFO": LOGLEVEL = logging.INFO else: LOGLEVEL = logging.WARNING logging.basicConfig(stream=sys.stderr, level=LOGLEVEL, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') logger = logging.getLogger() pp = pprint.PrettyPrinter(indent=4) KUBE_ENDPOINT = env( 'KUBE_ENDPOINT', cast=str, default="Required: KUBE_ENDPOINT must be equal to the Kube API scaling endpoint for the deployment, such as: 'apis/apps/v1beta1/namespaces/default/deployments/<MyAppName>/scale") KUBE_MIN_REPLICAS = env( 'KUBE_MIN_REPLICAS', cast=int, default=1)
from envparse import env env.read_envfile() SQLALCHEMY_ECHO = env.bool("SQLALCHEMY_ECHO", default=False) SQLALCHEMY_DATABASE_URI = env.str("SQLALCHEMY_DATABASE_URI", default="postgresql:///postgres:postgres@postgres:5432/results") SQLALCHEMY_TRACK_MODIFICATIONS = env.bool("SQLALCHEMY_TRACK_MODIFICATIONS", default=False)
def run(drill): logging.basicConfig( format='%(asctime)s - %(levelname)s - %(message)s', datefmt='%d/%m/%Y %H:%M:%S', stream=sys.stdout ) logging.getLogger().setLevel(logging.INFO) Env.read_envfile('.env') survivors = env('SURVIVORS', cast=list, subcast=str) smtp_login = env('SMTP_LOGIN') smtp_password = env('SMTP_PASSWORD') smtp_host = env('SMTP_HOST') smtp_port = env('SMTP_PORT') smtp_tls = env.bool('SMTP_TLS', default=False) if drill: debug('[Drill mode]') try: sank_file = env('SIREN')+'.sank' if os.path.exists(sank_file): raise Exception('Titanic already sank, aborting') debug('Getting Titanic\'s status...') titanic = get_titanic(drill) debug('Checking Titanic\'s status...') if titanic['radie']: since = arrow.get(titanic['last_legal_update']).format('MMM, D YYYY') debug('Titanic sunk! {} isn\'t no more since {}!'.format(titanic['names']['best'], since)) debug('There\'s {} survivors to contact.'.format(len(survivors))) debug('Sending telegrams to the survivors...') envelope = Envelope( from_addr=(smtp_login, 'The Titanic'), to_addr=survivors, subject='Titanic sunk!', html_body="""<h1>Ohmy, Titanic sunk!</h1> <p>There it is. {company} isn\'t, officially since <b>{since}</b>.</p> <p style="text-align: center"><img src="https://media.giphy.com/media/hmxZRW8mhs4ak/giphy.gif"></p> <p>Thank you all.</p> <hr> <p><small>This email was automatically sent by the <a href="https://github.com/EpocDotFr/titanic">Titanic</a>. Please don\'t reply.</small></p>""".format(company=titanic['names']['best'], since=since) ) envelope.send(smtp_host, login=smtp_login, password=smtp_password, port=smtp_port, tls=smtp_tls) debug('Telegrams sent successfully!') open(sank_file, 'a').close() else: debug('Titanic still floating') except Exception as e: debug(' > {}'.format(e), err=True)
def test_bool(): assert_type_value(bool, True, env.bool('BOOL_TRUE')) assert_type_value(bool, False, env.bool('BOOL_FALSE'))
import sys import datetime from envparse import env BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) def get_secret_key(secret_key): if not secret_key: return "".join([random.choice("abcdefghijklmnopqrstuvwxyz0123456789!@#$^&*(-_=+)") for i in range(50)]) return secret_key SECRET_KEY = env('SECRET_KEY', preprocessor=get_secret_key, default=None) DEBUG = env.bool('DJANGO_DEBUG', default=False) ALLOWED_HOSTS = env('ALLOWED_HOSTS', cast=list, default=['localhost', '127.0.0.1', '.lesspass.com']) ADMIN = [('Guillaume Vincent', '*****@*****.**'), ] INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'rest_framework', 'corsheaders', 'djoser',
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") POSTGRES_URI = f"postgres://{POSTGRES_USER}:{POSTGRES_PASSWORD}@{POSTGRES_HOST}:{POSTGRES_PORT}/{POSTGRES_DB}"
import os from envparse import 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__))) FRONTEND_DIR = os.path.join(BASE_DIR, "..", "frontend") SECRET_KEY = env.str( "DJANGO_SECRET_KEY", default="wlk9!mepu*mp$^yj-bo2on4)4fj60#(zbzw+@te54xu((b(dfp") DEBUG = env.bool("DJANGO_DEBUG", default=False) ALLOWED_HOSTS = env.list("DJANGO_ALLOWED_HOSTS", default=[]) INSTALLED_APPS = [ "django.contrib.admin", "django.contrib.auth", "django.contrib.contenttypes", "django.contrib.sessions", "django.contrib.messages", "django.contrib.staticfiles", # third party "social_django", "django_rq", "rest_framework", "webpack_loader", "django_filters", "django_extensions", # internal "feedzero.users", "feedzero.feeds",
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'
import asyncio import logging import pathlib import random import sys import aiofiles from envparse import env from bouquets_generator.structs import BouquetDesign, Bouquet, Flower env.read_envfile(pathlib.Path(__file__).parents[1] / ".env") logging.basicConfig( stream=sys.stdout, level=logging.DEBUG if env.bool("DEBUG", default=False) else logging.INFO, format=">> %(message)s", ) logger = logging.getLogger(__name__) async def bouquet_designs_consumer( bouquet_designs_queue: asyncio.Queue, flowers_queue: asyncio.Queue, bouquets_queue: asyncio.Queue, ): """Taking care on bouquets and their state.""" worker_id = int(random.random() * 1000) bd_str = await bouquet_designs_queue.get() bd = BouquetDesign.from_str(bd_str)
'DIRS': [], 'APP_DIRS': True, 'OPTIONS': { 'context_processors': [ 'django.template.context_processors.debug', 'django.template.context_processors.request', 'django.contrib.auth.context_processors.auth', 'django.contrib.messages.context_processors.messages', ], }, }, ] WSGI_APPLICATION = 'ufcavalan.wsgi.application' banco = env.bool('DEBUG', default=False) # banco = False # Database # https://docs.djangoproject.com/en/1.8/ref/settings/#databases if banco: DATABASES = {'default': dj_database_url.config(default=os.getenv('DATABASE_URL', None))} else: DATABASES = { 'default': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': os.path.join(BASE_DIR, 'db.sqlite3'), } }