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