def __init__(self, project_id): Env.read_envfile('.env') debug('Initializing') self.project_id = project_id self.gitlab = gitlab.Gitlab(env('GITLAB_ENDPOINT'), env('GITLAB_TOKEN'))
def cli(): """Point TCL Slack bot""" logging.basicConfig(format='%(asctime)s - %(levelname)s - %(message)s', datefmt='%d/%m/%Y %H:%M:%S', stream=sys.stdout) logging.getLogger().setLevel(logging.INFO) logging.info('Initializing') Env.read_envfile('.env')
def __init__(self): config = Env( DATABASE_URL=dict(default='sqlite:///:memory:'), FEEDFIN_DEV=dict(cast=bool, default=False), FEEDFIN_SECRET=dict(default=token_urlsafe()), FEEDFIN_LOGFILE=dict(default=None), FEEDFIN_LOGBYTES=dict(cast=int, default=1000000), FEEDFIN_LOGLEVEL=dict(default=None), ) self.database_uri = config('DATABASE_URL') self.dev_mode = config('FEEDFIN_DEV') self.secret_key = config('FEEDFIN_SECRET') self.log_file = config('FEEDFIN_LOGFILE') self.log_bytes = config('FEEDFIN_LOGBYTES') self.log_level = LOG_MAP.get(config('FEEDFIN_LOGLEVEL')) if self.log_level is None: self.log_level = logging.INFO if self.dev_mode else logging.ERROR # non-configurable self.algorithm = 'HS512' self.duration = timedelta(1) self.log_format = ('%(color)s[%(asctime)s] [feedfin: %(levelname)s]' '%(end_color)s %(message)s') self.log_date = '%Y-%m-%d %H:%M:%S'
class DevelopmentConfig: env = Env() HOST = env.str("HOST", default="0.0.0.0") PORT = env.int("PORT", default="7777") LOG_LEVEL = env("LOG_LEVEL", default="INFO") FB_ACCESS_TOKEN = env("FB_ACCESS_TOKEN", default="") STATIC_ROOT = "app/static"
class DevelopmentConfig: env = Env() HOST = env.str('HOST', default='0.0.0.0') PORT = env.int('PORT', default='9293') LOG_LEVEL = env('LOG_LEVEL', default='INFO') EXT_LOG_LEVEL = env('EXT_LOG_LEVEL', default='WARN') DOMAIN_URL_PROTOCOL = 'http://' DOMAIN_URL = env.str('DOMAIN_URL', default='localhost:9293') FSDR_SERVICE_URL = env.str('FSDR_SERVICE_URL', default='http://localhost:5678') FSDR_SERVICE_PASS = env.str('FSDR_SERVICE_PASSWORD', default='pass') FSDR_SERVICE_USER = env.str('FSDR_SERVICE_USERNAME', default='user') REDIS_SERVER = env('REDIS_SERVER', default='localhost') REDIS_PORT = env('REDIS_PORT', default='6379') SESSION_AGE = env('SESSION_AGE', default='300') # 5 minutes URL_PATH_PREFIX = env('URL_PATH_PREFIX', default='') SECRET_KEY = 'examplesecretkey' SSO_CONFIG_FOLDER = env('SSO_CONFIG_FOLDER', default=str( Path(__file__).resolve().parent.parent / 'local-sso-config'))
class BaseConfig: env = Env() PORT = env.int('PORT', default='9293') LOG_LEVEL = env('LOG_LEVEL', default='INFO') EXT_LOG_LEVEL = env('EXT_LOG_LEVEL', default='WARN') DOMAIN_URL_PROTOCOL = env('DOMAIN_URL_PROTOCOL', default='https://') DOMAIN_URL = env('DOMAIN_URL', default='localhost:6263') FSDR_SERVICE_URL = env('FSDR_SERVICE_URL', default='localhost:5678') FSDR_SERVICE_USER = env('FSDR_SERVICE_USER', default='user') FSDR_SERVICE_PASS = env('FSDR_SERVICE_PASS', default='pass') FSDR_SERVICE_URL_AUTH = (env('FSDR_SERVICE_USER', default='user'), env('FSDR_SERVICE_PASS', default='pass')) REDIS_SERVER = env('REDIS_SERVER', default='localhost') REDIS_PORT = env('REDIS_PORT', default='6379') SESSION_AGE = env('SESSION_AGE', default='6000') URL_PATH_PREFIX = env('URL_PATH_PREFIX', default='') # FN_AUTH_REDIRECT_URI = env("http://localhost:9293/auth") # FN_BASE_URI = env("http://localhost:9293") # FN_CLIENT_ID = env('705755761858-n1vinsandkq3n7borr3bdplkj6cghv2b.apps.googleusercontent.com') # FN_CLIENT_SECRET = env('mej--fVERcHXiOeezGkBz13p') SECRET_KEY = 'examplesecretkey' SSO_CONFIG_FOLDER = env('SSO_CONFIG_FOLDER', default='')
def main(): """Run smashctl""" env = Env( # Redis DB to contact SMASHCTL_REDIS=dict(cast=str, default='redis://localhost:6379/0'), SMASHCTL_BASEURL=dict( cast=str, default='https://antismash/secondarymetabolites.org/'), ) parser = argparse.ArgumentParser(prog='smashctl') parser.add_argument( '--db', default=env('SMASHCTL_REDIS'), help="Redis database to contact (default: %(default)s)") parser.add_argument('-V', '--version', action='version', version=__version__) subparsers = parser.add_subparsers(title='subcommands') control.register(subparsers) job.register(subparsers) args = parser.parse_args() store = get_storage(args.db) run_command(args.func, args, store)
def main(): env = Env(HOSTS=dict(cast=list, subcast=str), TASKS=dict(cast=list, subcast=str), KEY=str) host_list = ','.join([str(x) for x in env('HOSTS')]) task_list = env('TASKS') private_key = env('KEY') with open('/key.pem', 'w') as f: f.write(private_key) f.close() command = ['fab', '--identity', '/key.pem', '--hosts', host_list ] + task_list p = Popen(command, stdout=PIPE, stderr=PIPE) stdout, stderr = p.communicate() if stdout: print('-------STARTING FABFILE-------') print(stdout) print('-------- END FABFILE --------') if stderr: raise Exception(stderr)
class DevelopmentConfig: env = Env() HOST = env.str('HOST', default='0.0.0.0') PORT = env.int('PORT', default='9092') LOG_LEVEL = env('LOG_LEVEL', default='INFO') EXT_LOG_LEVEL = env('EXT_LOG_LEVEL', default='WARN') DOMAIN_URL_PROTOCOL = 'http://' DOMAIN_URL_EN = env.str('DOMAIN_URL_EN', default='localhost:9092') DOMAIN_URL_CY = env.str('DOMAIN_URL_CY', default='localhost:9092') ACCOUNT_SERVICE_URL = env.str('ACCOUNT_SERVICE_URL', default='http://localhost:9092') EQ_URL = env.str('EQ_URL', default='http://localhost:5000') JSON_SECRET_KEYS = env.str( 'JSON_SECRET_KEYS', default=None) or open('./tests/test_data/test_keys.json').read() RHSVC_URL = env.str('RHSVC_URL', default='http://localhost:8071') RHSVC_AUTH = (env.str('RHSVC_USERNAME', default='admin'), env.str('RHSVC_PASSWORD', default='secret')) URL_PATH_PREFIX = env('URL_PATH_PREFIX', default='') GTM_CONTAINER_ID = env.str('GTM_CONTAINER_ID', default='GTM-MRQGCXS') GTM_AUTH = env.str('GTM_AUTH', default='SMijm6Rii1nctiBFRb1Rdw') REDIS_SERVER = env('REDIS_SERVER', default='localhost') REDIS_PORT = env('REDIS_PORT', default='7379') REDIS_POOL_MIN = env('REDIS_POOL_MIN', default='50') REDIS_POOL_MAX = env('REDIS_POOL_MAX', default='500') SESSION_AGE = env('SESSION_AGE', default='2700') # 45 minutes WEBCHAT_SVC_URL = env.str( 'WEBCHAT_SVC_URL', default='https://www.timeforstorm.com/IM/endpoint/client/5441/ONSWebchat/ce033298af0c07067a77b7940c011ec8ef670d66b7fe15c5776a16e205478221' ) # yapf: disable ADDRESS_INDEX_SVC_URL = env.str('ADDRESS_INDEX_SVC_URL', default='http://localhost:9000') ADDRESS_INDEX_SVC_AUTH = (env.str('ADDRESS_INDEX_SVC_USERNAME', default='admin'), env.str('ADDRESS_INDEX_SVC_PASSWORD', default='secret')) ADDRESS_INDEX_EPOCH = env.str('ADDRESS_INDEX_EPOCH', default='') AD_LOOK_UP_SVC_URL = env.str('AD_LOOK_UP_SVC_URL', default='http://localhost:8071/v1') AD_LOOK_UP_SVC_AUTH = (env.str('AD_LOOK_UP_SVC_USERNAME', default='admin'), env.str('AD_LOOK_UP_SVC_PASSWORD', default='secret')) AD_LOOK_UP_SVC_APIKEY = env.str('AD_LOOK_UP_SVC_APIKEY', default='apikey') AD_LOOK_UP_SVC_APPID = env.str('AD_LOOK_UP_SVC_APPID', default='appid') EQ_SALT = env('EQ_SALT', default='s3cr3tS4lt')
class BaseConfig: env = Env() env = partial(env, default=None) HOST = env("HOST") PORT = env("PORT") LOG_LEVEL = env("LOG_LEVEL") STATIC_ROOT = "app/static" FB_ACCESS_TOKEN = env("FB_ACCESS_TOKEN")
def __init__(self): config = Env(FEEDFIN_DEBUG=dict(cast=bool, default=False), FEEDFIN_TESTING=dict(cast=bool, default=False), FEEDFIN_SECRET_KEY=dict(default=token_urlsafe()), DATABASE_URL=dict(default='sqlite:///:memory:')) # pylint: disable=invalid-name self.DEBUG = config('FEEDFIN_DEBUG') self.TESTING = config('FEEDFIN_TESTING') self.SECRET_KEY = config('FEEDFIN_SECRET_KEY') self.SQLALCHEMY_DATABASE_URI = config('DATABASE_URL') self.SQLALCHEMY_TRACK_MODIFICATIONS = False
class DevelopmentConfig: env = Env() HOST = env.str("HOST", default="0.0.0.0") PORT = env.int("PORT", default="9092") LOG_LEVEL = env("LOG_LEVEL", default="INFO") ACCOUNT_SERVICE_URL = env.str("ACCOUNT_SERVICE_URL", default="http://localhost:9092") EQ_URL = env.str("EQ_URL", default="http://localhost:5000") JSON_SECRET_KEYS = env.str( "JSON_SECRET_KEYS", default=None) or open("./tests/test_data/test_keys.json").read() COLLECTION_EXERCISE_URL = env.str("COLLECTION_EXERCISE_URL", default="http://localhost:8145") COLLECTION_EXERCISE_AUTH = (env.str("COLLECTION_EXERCISE_USERNAME", default="admin"), env.str("COLLECTION_EXERCISE_PASSWORD", default="secret")) COLLECTION_INSTRUMENT_URL = env.str("COLLECTION_INSTRUMENT_URL", default="http://localhost:8002") COLLECTION_INSTRUMENT_AUTH = (env.str("COLLECTION_INSTRUMENT_USERNAME", default="admin"), env.str("COLLECTION_INSTRUMENT_PASSWORD", default="secret")) CASE_URL = env.str("CASE_URL", default="http://localhost:8171") CASE_AUTH = (env.str("CASE_USERNAME", default="admin"), env.str("CASE_PASSWORD", default="secret")) IAC_URL = env.str("IAC_URL", default="http://localhost:8121") IAC_AUTH = (env.str("IAC_USERNAME", default="admin"), env.str("IAC_PASSWORD", default="secret")) SAMPLE_URL = env("SAMPLE_URL", default="http://localhost:8125") SAMPLE_AUTH = (env("SAMPLE_USERNAME", default="admin"), env("SAMPLE_PASSWORD", default="secret")) SURVEY_URL = env("SURVEY_URL", default="http://localhost:8080") SURVEY_AUTH = (env("SURVEY_USERNAME", default="admin"), env("SURVEY_PASSWORD", default="secret")) REDIS_HOST = env.str("REDIS_HOST", default="localhost") REDIS_PORT = env.int("REDIS_PORT", default=6379) REDIS_MAINTENANCE_KEY = env.str("REDIS_MAINTENANCE_KEY", default="respondent-home-ui:maintenance") SECRET_KEY = env.str("SECRET_KEY", default=None) or generate_new_key() URL_PATH_PREFIX = env("URL_PATH_PREFIX", default="") ANALYTICS_UA_ID = env("ANALYTICS_UA_ID", default="")
def test_schema(): env = Env(STR=str, STR_DEFAULT=dict(cast=str, default='default'), INT=int, LIST_STR=list, LIST_INT=dict(cast=list, subcast=int)) assert_type_value(str, 'foo', env('STR')) assert_type_value(str, 'default', env('STR_DEFAULT')) assert_type_value(int, 42, env('INT')) assert_type_value(list, ['foo', 'bar'], env('LIST_STR')) assert_type_value(list, [1, 2, 3], env('LIST_INT')) # Overrides assert_type_value(str, '42', env('INT', cast=str)) assert_type_value(str, 'manual_default', env('STR_DEFAULT', default='manual_default'))
def test_upload_non_interactive(self): pkgname = 'new_pkg' env = Env.read_envfile() self.assertTrue( os.environ.get('KECHAIN_URL'), "KECHAIN_URL is not set in environment, cannot perform this test") with temp_chdir() as d: runner = CliRunner() result = runner.invoke(kecpkg, ['new', pkgname, '--no-venv']) package_dir = get_package_dir(pkgname) self.assertTrue(os.path.exists(package_dir)) os.chdir(package_dir) result = runner.invoke(kecpkg, ['build', pkgname]) self.assertEqual(result.exit_code, 0) self.assertExists(os.path.join(package_dir, 'dist')) pkgpath = os.path.join(package_dir, 'dist', '{}-0.0.1-py3.5.kecpkg'.format(pkgname)) self.assertExists(pkgpath) result = runner.invoke( kecpkg, [ 'upload', pkgname, '--url', os.environ.get('KECHAIN_URL'), '--token', os.environ.get('KECHAIN_TOKEN'), '--scope-id', os.environ.get('KECHAIN_SCOPE_ID'), '--kecpkg', pkgpath, '--store' # store the service_id in the settings (for teardown) ]) self.assertEqual(result.exit_code, 0) # teardown the just uploaded service from kecpkg.settings import load_settings settings = load_settings(package_dir=get_package_dir(pkgname)) from pykechain import get_project scope = get_project(url=os.environ.get('KECHAIN_URL'), token=os.environ.get('KECHAIN_TOKEN'), scope_id=os.environ.get('KECHAIN_SCOPE_ID')) service = scope.service(pk=settings.get('service_id')) service.delete()
def main(): env = Env( # Port to expose the metrics on METRIX_PORT=dict(cast=int, default=8000), # URI of the Redis database to read metrics from METRIX_REDIS_URI=dict(cast=str, default="redis://localhost:6379/0"), # Refresh interval in seconds METRIX_REFRESH_INTERVAL=dict(cast=float, default=5.0), ) parser = argparse.ArgumentParser( description="Metrics for the antiSMASH backend", epilog=_EPILOG) parser.add_argument('-V', '--version', action='version', version=__version__) parser.add_argument( '-p', '--port', type=int, default=env('METRIX_PORT'), help="Port to expose the metrics on (default: %(default)s)") parser.add_argument( '-r', '--redis-uri', default=env('METRIX_REDIS_URI'), help= "URI of the Redis database to read metrics from (default: %(default)s)" ) parser.add_argument( '-i', '--interval', type=float, default=env('METRIX_REFRESH_INTERVAL'), help="Refresh interval in seconds (default: %(default)s)") args = parser.parse_args() start_http_server(args.port) # TODO: This works for real Redis, but not for mockredis # db_conn = Redis.from_url(args.redis_uri, charset="utf-8", decode_responses=True) db_conn = Redis.from_url(args.redis_uri) gauges = build_gauges() while True: gather_metrics(db_conn, gauges) time.sleep(args.interval)
class BaseConfig: env = Env() env = partial(env, default=None) HOST = env('HOST') PORT = env('PORT') LOG_LEVEL = env('LOG_LEVEL') EXT_LOG_LEVEL = env('EXT_LOG_LEVEL') DOMAIN_URL_PROTOCOL = env('DOMAIN_URL_PROTOCOL', default='https://') DOMAIN_URL_EN = env('DOMAIN_URL_EN') DOMAIN_URL_CY = env('DOMAIN_URL_CY') ACCOUNT_SERVICE_URL = env('ACCOUNT_SERVICE_URL') EQ_URL = env('EQ_URL') JSON_SECRET_KEYS = env('JSON_SECRET_KEYS') RHSVC_URL = env('RHSVC_URL') RHSVC_AUTH = (env('RHSVC_USERNAME'), env('RHSVC_PASSWORD')) URL_PATH_PREFIX = env('URL_PATH_PREFIX', default='') GTM_CONTAINER_ID = env('GTM_CONTAINER_ID', default='') GTM_AUTH = env('GTM_AUTH', default='') REDIS_SERVER = env('REDIS_SERVER', default='localhost') REDIS_PORT = env('REDIS_PORT', default='7379') REDIS_POOL_MIN = env('REDIS_POOL_MIN', default='50') REDIS_POOL_MAX = env('REDIS_POOL_MAX', default='500') SESSION_AGE = env('SESSION_AGE', default='2700') # 45 minutes WEBCHAT_SVC_URL = env('WEBCHAT_SVC_URL') ADDRESS_INDEX_SVC_URL = env('ADDRESS_INDEX_SVC_URL') ADDRESS_INDEX_SVC_AUTH = (env('ADDRESS_INDEX_SVC_USERNAME'), env('ADDRESS_INDEX_SVC_PASSWORD')) ADDRESS_INDEX_EPOCH = env('ADDRESS_INDEX_EPOCH', default='') AD_LOOK_UP_SVC_URL = env('AD_LOOK_UP_SVC_URL') AD_LOOK_UP_SVC_AUTH = (env('AD_LOOK_UP_SVC_USERNAME'), env('AD_LOOK_UP_SVC_PASSWORD')) AD_LOOK_UP_SVC_APIKEY = env('AD_LOOK_UP_SVC_APIKEY') AD_LOOK_UP_SVC_APPID = env('AD_LOOK_UP_SVC_APPID') EQ_SALT = env('EQ_SALT', default='s3cr3tS4lt')
class DevelopmentConfig: env = Env() HOST = env.str('HOST', default='0.0.0.0') PORT = env.int('PORT', default='9092') LOG_LEVEL = env('LOG_LEVEL', default='INFO') EXT_LOG_LEVEL = env('EXT_LOG_LEVEL', default='INFO') DOMAIN_URL_PROTOCOL = 'http://' DOMAIN_URL_EN = env.str('DOMAIN_URL_EN', default='localhost:9092') DOMAIN_URL_CY = env.str('DOMAIN_URL_CY', default='localhost:9092') ACCOUNT_SERVICE_URL = env.str('ACCOUNT_SERVICE_URL', default='http://localhost:9092') EQ_URL = env.str('EQ_URL', default='http://localhost:5000') RHSVC_URL = env.str('RHSVC_URL', default='http://localhost:8071') RHSVC_AUTH = (env.str('RHSVC_USERNAME', default='admin'), env.str('RHSVC_PASSWORD', default='secret')) URL_PATH_PREFIX = env('URL_PATH_PREFIX', default='') GTM_CONTAINER_ID = env.str('GTM_CONTAINER_ID', default='GTM-MRQGCXS') GTM_AUTH = env.str('GTM_AUTH', default='SMijm6Rii1nctiBFRb1Rdw') REDIS_SERVER = env('REDIS_SERVER', default='localhost') REDIS_PORT = env('REDIS_PORT', default='6379') REDIS_POOL_MIN = env('REDIS_POOL_MIN', default='50') REDIS_POOL_MAX = env('REDIS_POOL_MAX', default='500') SESSION_AGE = env('SESSION_AGE', default='2700') # 45 minutes ADDRESS_INDEX_SVC_URL = env.str('ADDRESS_INDEX_SVC_URL', default='http://localhost:9000') ADDRESS_INDEX_EPOCH = env.str('ADDRESS_INDEX_EPOCH', default='') ADDRESS_INDEX_SVC_EXTERNAL_URL = env('ADDRESS_INDEX_SVC_EXTERNAL_URL', default='http://localhost:9000') ADDRESS_INDEX_SVC_KEY = env( 'ADDRESS_INDEX_SVC_KEY', default='c2VjcmV0PT0=') # secret== base64 encoded # Value must be base64 encoded, and multiple of 4 characters long unencoded EQ_SALT = env('EQ_SALT', default='s3cr3tS4lt') SITE_NAME_EN = env('SITE_NAME_EN', default='ONS Surveys') SITE_NAME_CY = env('SITE_NAME_CY', default='ONS Surveys')
class BaseConfig: env = Env() env = partial(env, default=None) HOST = env("HOST") PORT = env("PORT") LOG_LEVEL = env("LOG_LEVEL") ACCOUNT_SERVICE_URL = env("ACCOUNT_SERVICE_URL") EQ_URL = env("EQ_URL") JSON_SECRET_KEYS = env("JSON_SECRET_KEYS") CASE_URL = env("CASE_URL") CASE_AUTH = (env("CASE_USERNAME"), env("CASE_PASSWORD")) COLLECTION_EXERCISE_URL = env("COLLECTION_EXERCISE_URL") COLLECTION_EXERCISE_AUTH = (env("COLLECTION_EXERCISE_USERNAME"), env("COLLECTION_EXERCISE_PASSWORD")) COLLECTION_INSTRUMENT_URL = env("COLLECTION_INSTRUMENT_URL") COLLECTION_INSTRUMENT_AUTH = (env("COLLECTION_INSTRUMENT_USERNAME"), env("COLLECTION_INSTRUMENT_PASSWORD")) IAC_URL = env("IAC_URL") IAC_AUTH = (env("IAC_USERNAME"), env("IAC_PASSWORD")) SAMPLE_URL = env("SAMPLE_URL") SAMPLE_AUTH = (env("SAMPLE_USERNAME"), env("SAMPLE_PASSWORD")) SURVEY_URL = env("SURVEY_URL") SURVEY_AUTH = (env("SURVEY_USERNAME"), env("SURVEY_PASSWORD")) REDIS_SERVICE = env( "REDIS_SERVICE") # required to populate host and port with cf values REDIS_HOST = env("REDIS_HOST", default="") # populated by cf after setup REDIS_PORT = env("REDIS_PORT", default=0) # populated by cf after setup REDIS_MAINTENANCE_KEY = env("REDIS_MAINTENANCE_KEY", default="respondent-home-ui:maintenance") SECRET_KEY = env("SECRET_KEY") URL_PATH_PREFIX = env("URL_PATH_PREFIX", default="") ANALYTICS_UA_ID = env("ANALYTICS_UA_ID", default="")
def load_extra_settings(settings): from envparse import Env env = Env( DJANGO_PRODUCTION=dict(cast=bool, default=False), DJANGO_DATABASES=dict(cast=dict, subcast=db_from_url), ) if env('DJANGO_PRODUCTION'): settings['DEBUG'] = False settings['SECRET_KEY'] = env('DJANGO_SECRET_KEY') settings['DATABASES'].update(env('DJANGO_DATABASES')) else: special_cases = ('DATABASES', ) for k, v in settings.items(): if k.isupper() and k not in special_cases: settings[k] = env('DJANGO_' + k, cast=type(v), default=v) settings['DATABASES'].update(env('DJANGO_DATABASES', default=()))
from downloader.RioClientDownloader import RioClientDownloader from downloader.RioZipTuner import RioZipTuner from downloader.LoadProtection import LoadProtection from downloader.PersonalRecommendation import PersonalRecommendation from downloader.FileAccessor import FileAccessor from datetime import datetime import logging import sys import os import schedule import time import threading app = Flask(__name__) env = Env(HOST=dict(cast=str, default='0.0.0.0'), HTTP_PORT=dict(cast=int, default='5000'), DATA_DIR=dict(cast=str, default='data'), DOWNLOADS_PER_DAY=dict(cast=int, default='10')) env.read_envfile() logger = logging.getLogger() logger.setLevel(logging.DEBUG) handler = logging.StreamHandler(sys.stdout) handler.setLevel(logging.DEBUG) formatter = logging.Formatter( '%(asctime)s-%(name)s-%(levelname)s: %(message)s') handler.setFormatter(formatter) logger.addHandler(handler) raw_file_accessor = FileAccessor(env.str('DATA_DIR'), 'raw', 'zip') patched_file_accessor = FileAccessor(env.str('DATA_DIR'), 'patched', 'zip')
from envparse import Env env = Env(HOST=dict(cast=str, default='0.0.0.0'), HTTP_PORT=dict(cast=int, default='5000'), DATA_DIR=dict(cast=int, default='data')) env.read_envfile() if __name__ == '__main__': print("null")
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)
import argparse import getpass import os import time import elasticsearch.helpers import yaml from auth import Auth from elasticsearch import RequestsHttpConnection from elasticsearch.client import Elasticsearch from elasticsearch.client import IndicesClient from elasticsearch.exceptions import NotFoundError from envparse import Env env = Env(ES_USE_SSL=bool) def main(): parser = argparse.ArgumentParser() parser.add_argument('--host', default=os.environ.get('ES_HOST', None), help='Elasticsearch host') parser.add_argument('--port', default=os.environ.get('ES_PORT', None), type=int, help='Elasticsearch port') parser.add_argument('--username', default=os.environ.get('ES_USERNAME', None), help='Elasticsearch username') parser.add_argument('--password', default=os.environ.get('ES_PASSWORD', None), help='Elasticsearch password') parser.add_argument('--url-prefix', help='Elasticsearch URL prefix') parser.add_argument('--no-auth', action='store_const', const=True, help='Suppress prompt for basic auth') parser.add_argument('--ssl', action='store_true', default=env('ES_USE_SSL', None), help='Use TLS') parser.add_argument('--no-ssl', dest='ssl', action='store_false', help='Do not use TLS') parser.add_argument('--verify-certs', action='store_true', default=None, help='Verify TLS certificates') parser.add_argument('--no-verify-certs', dest='verify_certs', action='store_false', help='Do not verify TLS certificates') parser.add_argument('--index', help='Index name to create')
Generated by 'django-admin startproject' using Django 1.10.5. For more information on this file, see https://docs.djangoproject.com/en/1.10/topics/settings/ For the full list of settings and their values, see https://docs.djangoproject.com/en/1.10/ref/settings/ """ import os from os.path import expanduser from envparse import Env env_file = expanduser("~") + os.sep + '.roller_env' env = Env() env.read_envfile(env_file) # Build paths inside the project like this: os.path.join(BASE_DIR, ...) BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) # Quick-start development settings - unsuitable for production # See https://docs.djangoproject.com/en/1.10/howto/deployment/checklist/ # SECURITY WARNING: keep the secret key used in production secret! SECRET_KEY = env('ROLLER_SECRET_KEY') DBPASSWORD = env('ROLLER_DB_PASSWORD') DBNAME = env('ROLLER_DB_NAME') # SECURITY WARNING: don't run with debug turned on in production! DEBUG = True
# This Python file uses the following encoding: utf-8 import os from envparse import Env basedir = os.path.abspath(os.path.dirname(__file__)) env = Env() env_file = os.environ.get('ENV', 'dev') + ".env" env_file_path = os.path.join(basedir, 'conf', '.env_files', env_file) env.read_envfile(env_file_path) def get_path(*parts): return os.path.join(basedir, *parts) class Config: NAME = env.str("NAME", default="hello_world") ENV = env.str("ENV", default="dev") DEBUG = env.bool("DEBUG", default=True) TESTING = env.bool("TESTING", default=False) SECRET_KEY = env.str("FLASK_SECRET_KEY", default="secret_key") # DB POSTGRES_USER = env.str("POSTGRES_USER", default="") POSTGRES_PASSWORD = env.str("POSTGRES_PASSWORD", default="") POSTGRES_DB_HOST = env.str("POSTGRES_DB_HOST", default="localhost") POSTGRES_DB_PORT = env.int("POSTGRES_DB_PORT", default=5433) POSTGRES_DB = env.str("POSTGRES_DB", default="helloworld_db")
#! /usr/bin/env python import json import sys from warnings import catch_warnings import click from envparse import Env from github.MainClass import DEFAULT_BASE_URL from .github_api import GithubAPI BASE_ENV_FILE_NAME = 'gh_chk_in_vars' with catch_warnings(record=True): Env.read_envfile(f'/etc/{BASE_ENV_FILE_NAME}') Env.read_envfile(f'~/.config/.{BASE_ENV_FILE_NAME}') Env.read_envfile(f'~/.{BASE_ENV_FILE_NAME}') Env.read_envfile(f'.{BASE_ENV_FILE_NAME}') Env.read_envfile() ENV_VAR_PREFIX = 'GH_CHK_IN_' ENV_VAR_TMPL = f'{ENV_VAR_PREFIX}{{var_name}}' @click.group() @click.option('--github-url', default=DEFAULT_BASE_URL, envvar=ENV_VAR_TMPL.format(var_name='GITHUB_URL')) @click.option('--private-key-file', prompt=True,
from envparse import Env from flask import Flask from flask_sqlalchemy import SQLAlchemy from datetime import datetime env = Env() DB_URL = env.str("DB_URL") app = Flask(__name__) app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False app.config['SQLALCHEMY_DATABASE_URI'] = DB_URL db = SQLAlchemy(app) class CustomersFromTg(db.Model): user_id = db.Column(db.Integer, primary_key=True, autoincrement=True) nickname = db.Column(db.String(100), nullable=False, unique=True) name = db.Column(db.String(100), nullable=False) surname = db.Column(db.String(100), nullable=False) chat_id = db.Column(db.Integer, nullable=False) is_subscribed = db.Column(db.Boolean, default=False) create_dt = db.Column(db.DateTime, default=datetime.utcnow()) class CustomersFromWebsite(db.Model): user_id = db.Column(db.Integer, primary_key=True, autoincrement=True) nickname = db.Column(db.String(100), nullable=False) name = db.Column(db.String(100), nullable=False) surname = db.Column(db.String(100), nullable=False) create_dt = db.Column(db.DateTime, default=datetime.utcnow())
import warnings from pathlib import Path from dotenv import find_dotenv, load_dotenv from envparse import Env # configure env schema, describe all non-str env = Env(READ_DOT_PROJENV=bool, DOT_PROJENV_OVERRIDE=bool, DEBUG=bool, SCRAPER_PAGINATION_DIVIDER=int, API_SERVER_PORT=int, API_SERVER_DEBUG=bool) # Using a flag here to check if .proj-env should be loaded. We use .proj-env # instead of .env to circumnavigate pipenv's default feature of automatically # loading .env files in your project. READ_DOT_PROJENV = env('READ_DOT_PROJENV', default=False) DOT_PROJENV_FILENAME = env('DOT_PROJENV_FILENAME', default='.proj-env') DOT_PROJENV_OVERRIDE = env('DOT_PROJENV_OVERRIDE', default=False) ROOT_DIR = Path(__file__) / '..' / '..' / '..' if READ_DOT_PROJENV: with warnings.catch_warnings(): warnings.filterwarnings('error') try: ENV_PATH = find_dotenv(filename=DOT_PROJENV_FILENAME) load_dotenv(dotenv_path=ENV_PATH, override=DOT_PROJENV_OVERRIDE, verbose=True) except Warning:
import pinboard import requests import typer from bs4 import BeautifulSoup from envparse import Env from pathlib import Path from stop_words import safe_get_stop_words from titlecase import titlecase from unidecode import unidecode from yarl import URL env = Env(GITHUB_USERNAME=str, GITHUB_TOKEN=str, PINBOARD_TOKEN=str) GITHUB_TOKEN = env.str("GITHUB_TOKEN") GITHUB_USERNAME = env.str("GITHUB_USERNAME") PINBOARD_TOKEN = env.str("PINBOARD_TOKEN") IGNORE_WORDS = set( [word.lower() for word in Path("IGNORE_WORDS.txt").read_text().split()]) STOP_WORDS = set( [word.lower() for word in Path("STOP_WORDS.txt").read_text().split()]) STOP_WORDS.update(set(safe_get_stop_words("english"))) IGNORE_TAGS = IGNORE_WORDS | STOP_WORDS def get_dev_to_info_for_url(url): try: req = requests.get(url, timeout=1.0)
import logging import tweepy from envparse import Env from bot import TwitterForwarderBot, FetchAndSendTweetsJob from basebot import JobQueue env = Env( TWITTER_CONSUMER_KEY=str, TWITTER_CONSUMER_SECRET=str, TWITTER_ACCESS_TOKEN=str, TWITTER_ACCESS_TOKEN_SECRET=str, TELEGRAM_BOT_TOKEN=str, ) if __name__ == '__main__': logging.basicConfig( format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.WARNING) logging.getLogger(TwitterForwarderBot.__name__).setLevel(logging.DEBUG) logging.getLogger(JobQueue.__name__).setLevel(logging.DEBUG) logging.getLogger(FetchAndSendTweetsJob.__name__).setLevel(logging.DEBUG) auth = tweepy.OAuthHandler(env('TWITTER_CONSUMER_KEY'), env('TWITTER_CONSUMER_SECRET')) try: auth.set_access_token(env('TWITTER_ACCESS_TOKEN'), env('TWITTER_ACCESS_TOKEN_SECRET')) except KeyError:
from envparse import Env env = Env( GITHUB_TOKEN=str, GITHUB_USERS=str, GITHUB_ORGS=str, DEBUG=dict(type=bool, default=False), ) env.read_envfile()
import logging import os from datetime import datetime from envparse import Env from algoliasearch import algoliasearch from telegram import Bot, InlineQueryResultCachedGif, ParseMode from telegram.ext import (BaseFilter, ChosenInlineResultHandler, CommandHandler, ConversationHandler, Dispatcher, Filters, InlineQueryHandler, MessageHandler, Updater) # Configuration env = Env(BOT_TOKEN=str, ALGOLIA_API_KEY=str, ALGOLIA_APP_ID=str, ALGOLIA_INDEX_NAME=str, MODERATOR_ID=dict(cast=str, default=''), LOG_LEVEL=dict( cast=lambda l: getattr(logging, l.upper(), logging.INFO), default='INFO')) env.read_envfile() BOT_TOKEN = env('BOT_TOKEN') ALGOLIA_APP_ID = env('ALGOLIA_APP_ID') ALGOLIA_API_KEY = env('ALGOLIA_API_KEY') ALGOLIA_INDEX_NAME = env('ALGOLIA_INDEX_NAME') MODERATOR_ID = env('MODERATOR_ID') # Setup logging logging.basicConfig(level=env('LOG_LEVEL'), format='%(asctime)s - %(levelname)s - %(message)s', datefmt='%d-%m-%Y %H:%M:%S')