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'))
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'),
}
}
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',
