Example #1
0
def send_html_mail(you, subject, food_page):

    #me = os.environ['food_email']
    me = env('FOOD_EMAIL')
    me_pass = env('FOOD_EMAIL_PASS')
    msg = MIMEMultipart('alternative')
    msg['Subject'] = subject
    msg['From'] = me
    msg['To'] = you

    with open(food_page, 'r')as f:
        html_file = f.read()
        a = MIMEBase('application', 'octet-stream')
        a.set_payload(html_file)
        # encoders.encode_base64(a)
        a.add_header('Content-Disposition','attachment',filename=food_page)
        msg.attach(a)

    html = html_file
    # text = "HOLA"
    # part1 = MIMEText(text, 'plain')
    part2 = MIMEText(html, 'html')

    # msg.attach(part1)
    msg.attach(part2)


    s = smtplib.SMTP("smtp.zoho.com",587)
    s.ehlo()
    s.starttls()
    s.login(me, me_pass)

    s.sendmail(me, you, msg.as_string())
    s.close()
Example #2
0
def upload_option_precendence(path, version, token):
    final_path = path
    final_version = version
    final_token = token

    if path is None:
        final_path = env('RSDOC_PATH', default=None)

    if version is None:
        final_version = env('RSDOC_VERSION', default=None)

    if token is None:
        final_token = env('RSDOC_TOKEN', default=None)

    # Handle missing environment variables or command line options
    # to let the user know what they are doing wrong.
    errors = []
    if final_path is None:
        errors.append('  RSDOC_PATH or --path needed')
    if final_version is None:
        errors.append('  RSDOC_VERSION or --version needed')
    if final_token is None:
        errors.append('  RSDOC_TOKEN or --token needed')

    if errors:
        click.secho('rsdoc usage errors:', fg='red')
        click.secho("\n".join(errors), fg='red')
        raise click.Abort()

    return final_path, final_version, final_token
Example #3
0
def redis_connect(privileged=False, decode_responses=True, **kwargs):
    """Connect to the Redis DB with the right credentials
    """
    redis_host = os.getenv('REDIS_ADDRESS', '127.0.0.1:6379').split(':', 1)[0]
    redis_port = os.getenv('REDIS_ADDRESS', '127.0.0.1:6379').split(':', 1)[1]
    if privileged:
        redis_username = os.getenv('REDIS_USER', os.getenv('AGENT_ID'))
        if not redis_username:
            print(
                "redis_connect: REDIS_USER and AGENT_ID are not set in the environment!",
                file=sys.stderr)
            # Try to parse the node agent environment as fallback:
            env.read_envfile('/var/lib/nethserver/node/state/agent.env')
            redis_username = env('AGENT_ID', default='default')
            redis_password = env('REDIS_PASSWORD', default='nopass')
        else:
            redis_password = os.environ['REDIS_PASSWORD']  # Fatal if missing!
    else:
        redis_username = '******'
        redis_password = '******'

    return redis.Redis(
        host=redis_host,
        port=redis_port,
        db=0,
        username=redis_username,
        password=redis_password,
        decode_responses=decode_responses,
        #  we assume Redis keys and value strings are encoded UTF-8. Enabling this
        #  option implicitly converts to UTF-8 strings instead of binary strings
        #  (e.g. {b'key': b'value'} != {'key':'value'})
        **kwargs)
Example #4
0
def track_amplitude(chat_id: int,
                    event: str,
                    event_properties=None,
                    timestamp=None):
    if env('AMPLITUDE_API_KEY', default=None) is not None:
        amplitude = AmplitudeLogger(env('AMPLITUDE_API_KEY'))
        user = user_get_by_chat_id(chat_id=chat_id)
        amplitude.log(
            user_id=chat_id,
            event=event,
            user_properties={
                'Telegram chat ID':
                user.chat_id,
                'Name':
                user.full_name,
                'Telegram user name':
                user.user_name,
                'Daily catalog request limit':
                user.daily_catalog_requests_limit,
                'Subscribed to WB categories updates':
                user.subscribe_to_wb_categories_updates,
            },
            event_properties=event_properties,
            timestamp=timestamp,
        )
Example #5
0
def vad_task(**kwargs):
    ti = kwargs['ti']
    parent_data = ti.xcom_pull(task_ids='resample_%s' %
                               kwargs['params']['mic_name'])

    resample_dir = parent_data['output_dir']
    output_dir = parent_data['file_dir'] + '/1_clean_vad'
    create_dir_if_not_exists(output_dir)

    env.read_envfile()
    vad_dir = env("VAD_DIR")
    vad_script = env("VAD_SCRIPT")

    my_env = os.environ.copy()
    my_env[
        "PATH"] = "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"

    intm_id = kwargs['ts_nodash'] + 'session' + str(
        kwargs['params']['session_num']) + kwargs['params']['mic_name']
    vad_command = ["bash", vad_script, resample_dir, output_dir, intm_id]

    subprocess.check_call(vad_command, env=my_env, cwd=vad_dir)

    return {
        'task_type': 'vad',
        'output_dir': output_dir,
        'file_id': parent_data['file_id']
    }
Example #6
0
class Config(object):
    """
    The base configuration option. Contains the defaults.
    """

    DEBUG = False

    DEVELOPMENT = False
    STAGING = False
    PRODUCTION = False
    TESTING = False
    ETAG = True
    CSRF_ENABLED = True
    SERVER_URL = env('SERVER_URL', default=None)
    SQLALCHEMY_DATABASE_URI = env('DATABASE_URL', default=None)
    DATABASE_QUERY_TIMEOUT = 0.1
    SQLALCHEMY_TRACK_MODIFICATIONS = False

    # API configs

    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 FORCE_SSL:
        PREFERRED_URL_SCHEME = 'https'
Example #7
0
class TestingConfig(Config):
    """
    The configuration for a test suit
    """
    TESTING = True
    SQLALCHEMY_RECORD_QUERIES = True
    SERVER_URL = env('TEST_SERVER_URL', default=None)
    SQLALCHEMY_DATABASE_URI = env('TEST_DATABASE_URL', default=None)
Example #8
0
    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'))
Example #9
0
def load_conf():
    config = {}
    config['clickhouse'] = dict(host=env("CH_URL"),
                                user=env("CH_USER"),
                                password=env("CH_PASS"),
                                database=env("CH_DB"),
                                port=9440)
    return config
Example #10
0
def create_task(title, description=None, color_id=None):
    return Request('createTask',
                   title=title,
                   description=description,
                   color_id=color_id,
                   project_id=env('KANBOARD_PROJECT_ID'),
                   column_id=env('KANBOARD_COLUMN_ID', default=None),
                   swimlane_id=env('KANBOARD_SWIMLANE_ID', default=None))
Example #11
0
def test_dict():
    dict_str = dict(key1='val1', key2='val2')
    assert_type_value(dict, dict_str, env.dict('DICT_STR'))
    assert_type_value(dict, dict_str, env('DICT_STR', cast=dict))
    dict_int = dict(key1=1, key2=2)
    assert_type_value(dict, dict_int, env('DICT_INT', cast=dict, subcast=int))
    assert_type_value(dict, dict_int, env.dict('DICT_INT', subcast=int))
    assert_type_value(dict, {}, env.dict('BLANK'))
class Config(object):
    """
    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)
    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')

    # 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'
Example #13
0
class Config:

    DEBUG: bool = env('DEBUG', cast=bool, default=False)

    SQLALCHEMY_URL = env('SQLALCHEMY_URL')

    TIMEZONE: tzinfo = env('TIMEZONE',
                           default='America/New_York',
                           postprocessor=lambda val: pytz.timezone(val))
Example #14
0
def do_something():
    username = env("PYDUCK_USER", default="")
    password = env("PYDUCK_PASSWORD", default="")
    is_valid = auth.is_user_valid(username, password)
    if not is_valid:
        print("You are NOT authorized to use this library")
        return

    print("Welcome to the library")
Example #15
0
def getpickles(env_key):
    "Helper to unpickle from file at env_key, returns empty list on errors"
    try:
        return pickle.load(open(env(env_key), 'rb'))
    except FileNotFoundError:
        app.logger.warning(
            'Could not load cached values from "{}"->{!r}'.format(
                env_key, env(env_key)))
        return []
Example #16
0
    def read_settings_async():
        from envparse import env
        env.read_envfile()

        config = dict()
        config["connection_string"] = env("MONGODB_CONNECTION_STRING")
        config["db"] = env("MONGODB_DB")

        return config
Example #17
0
def test_dict():
    dict_str = dict(key1='val1', key2='val2')
    assert_type_value(dict, dict_str, env.dict('DICT_STR'))
    assert_type_value(dict, dict_str, env('DICT_STR', cast=dict))
    dict_int = dict(key1=1, key2=2)
    assert_type_value(dict, dict_int, env('DICT_INT', cast=dict,
                      subcast=int))
    assert_type_value(dict, dict_int, env.dict('DICT_INT', subcast=int))
    assert_type_value(dict, {}, env.dict('BLANK'))
class Props:

    RESOLVER_HOSTNAME = env('RESOLVER_HOSTNAME', "cloudflare-dns.com")
    RESOLVER_IP = env('RESOLVER_IP', "1.1.1.1")
    RESOLVER_PORT = int(env('RESOLVER_PORT', 853))

    APP_BIND_HOST = env('APP_BIND_HOST', "0.0.0.0")
    APP_BIND_PORT = int(env('APP_BIND_PORT', 53))

    THREAD_TIMEOUT = 1
Example #19
0
    def read_settings_async():
        from envparse import env
        env.read_envfile()

        config = dict()
        config["url"] = env("CH_URL")
        config["user"] = env("CH_USER")
        config["password"] = env("CH_PASS")

        return config
def detect_mp_by_job_id(job_id: str):
    spider = re.findall(r'\d+\/(\d+)\/\d+', job_id)[0]

    if spider == env('SH_WB_SPIDER'):
        return 'WB', 'Wildberries', wb_transformer()

    if spider == env('SH_OZON_SPIDER'):
        return 'Ozon', 'Ozon', ozon_transformer()

    return None, None, None
Example #21
0
def say_hi():
    username = env("PYDUCK_USER", default="")
    password = env("PYDUCK_PASSWORD", default="")
    is_valid = auth.is_user_valid(username, password)
    if not is_valid:
        print(
            "I do not quack with strangers! (you are NOT authorized to use this library)"
        )
        return

    print("Quack-quack!")
Example #22
0
def test_list():
    list_str = ['foo', 'bar']
    assert_type_value(list, list_str, env('LIST_STR', cast=list))
    assert_type_value(list, list_str, env.list('LIST_STR'))
    assert_type_value(list, list_str, env.list('LIST_STR_WITH_SPACES'))
    list_int = [1, 2, 3]
    assert_type_value(list, list_int, env('LIST_INT', cast=list, subcast=int))
    assert_type_value(list, list_int, env.list('LIST_INT', subcast=int))
    assert_type_value(list, list_int,
                      env.list('LIST_INT_WITH_SPACES', subcast=int))
    assert_type_value(list, [], env.list('BLANK', subcast=int))
Example #23
0
class Config:

    DEBUG: bool = env("DEBUG", cast=bool, default=False)

    SQLALCHEMY_URL = env("SQLALCHEMY_URL")

    TIMEZONE: tzinfo = env(
        "TIMEZONE",
        default="America/New_York",
        postprocessor=lambda val: pytz.timezone(val),
    )
Example #24
0
def test_list():
    list_str = ['foo', 'bar']
    assert_type_value(list, list_str, env('LIST_STR', cast=list))
    assert_type_value(list, list_str, env.list('LIST_STR'))
    assert_type_value(list, list_str, env.list('LIST_STR_WITH_SPACES'))
    list_int = [1, 2, 3]
    assert_type_value(list, list_int, env('LIST_INT', cast=list,
                      subcast=int))
    assert_type_value(list, list_int, env.list('LIST_INT', subcast=int))
    assert_type_value(list, list_int, env.list('LIST_INT_WITH_SPACES',
                      subcast=int))
    assert_type_value(list, [], env.list('BLANK', subcast=int))
Example #25
0
def start_chatting():
    username = env("PYDUCK_USER", default="")
    password = env("PYDUCK_PASSWORD", default="")
    auth_functions.configure()
    is_valid = auth_functions.is_user_valid(username, password)
    if not is_valid:
        print(
            "I do not quaching with strangers! (you are NOT authorized to use this library)"
        )
        return

    print("Quach-quach!")
Example #26
0
    def output(self):
        """
        We are marking the import as completed in our Postgres DB
        """

        return PostgresTarget(
            host=env('PGSQL_HOST_AND_PORT'),
            database=env('PGSQL_DATABASE'),
            user=env('PGSQL_USER'),
            password=env('PGSQL_PASSWORD'),
            table=self.table,
            update_id=self.update_id
        )
Example #27
0
    def output(self):
        """
        We are marking the cleanup as completed in our Postgres DB
        because the MySQL DB will be destroyed
        """

        return PostgresTarget(
            host=env('PGSQL_HOST_AND_PORT'),
            database=env('PGSQL_DATABASE'),
            user=env('PGSQL_USER'),
            password=env('PGSQL_PASSWORD'),
            table='_removed_whole_database_',
            update_id=self.task_id
        )
Example #28
0
    def __init__(
            self,
            endpoint=env("CALUMA_ENDPOINT",
                         default="http://caluma:8000/graphql"),
            oidc_client_id=env("OIDC_CLIENT_ID", default=None),
            oidc_client_secret=env("OIDC_CLIENT_SECRET", default=None),
            oidc_token_uri=env("OIDC_TOKEN_URI", default=None),
    ):
        self.endpoint = endpoint
        self.oidc_client_id = oidc_client_id
        self.oidc_client_secret = oidc_client_secret
        self.oidc_token_uri = oidc_token_uri

        self._token = None
Example #29
0
    def run(self):
        debug('Running')

        while True:
            try:
                debug('Getting builds')

                builds = self.gitlab.project_builds.list(
                    project_id=self.project_id)
            except Exception as e:
                debug(e, err=True)
                return

            debug('Analyzing builds')

            filter_username = env('FILTER_USERNAME', default=None)
            filter_stage = env('FILTER_STAGE', default=None)

            for build in builds:
                if filter_username and build.user.username != filter_username:  # Build wasn't started by the specified user
                    debug('  > Build #{} not started by user {}'.format(
                        build.id, env('FILTER_USERNAME')))
                    continue

                if filter_stage and build.stage != filter_stage:
                    debug('  > Build #{} not in stage {}'.format(
                        build.id, env('filter_stage')))
                    continue

                if build.id not in self.builds_list:  # Build isn't in the internal list
                    debug('  > Build #{} not in the internal list'.format(
                        build.id))

                    self.builds_list[build.id] = build.status
                    self.notify(build)
                else:  # Build is in the internal list
                    if self.builds_list[
                            build.id] != build.status:  # Build status changed
                        debug('  > Build #{} status changed'.format(build.id))

                        self.builds_list[build.id] = build.status
                        self.notify(build)
                    else:  # Build status unchanged: next build
                        debug('  > Build #{} status unchanged'.format(
                            build.id))

                        continue

            time.sleep(env('POLL_INTERVAL', cast=int))
Example #30
0
    def output(self):
        """
        We are marking the completion of the transform step as
        completed in our Postgres DB because the MariaDB is not present
        at the moment of checking completeness of the task
        """

        return PostgresTarget(
            host=env('PGSQL_HOST_AND_PORT'),
            database=env('PGSQL_DATABASE'),
            user=env('PGSQL_USER'),
            password=env('PGSQL_PASSWORD'),
            table=self.table,
            update_id=self.update_id
        )
Example #31
0
def send_mail(to, subject, text, attachment=None, attachment_name=''):
    message = pystmark.Message(
        sender=env('MAIL_FROM'),
        to=to,
        subject=subject,
        text=text,
    )

    if attachment is not None:
        message.attach_binary(attachment.read(), attachment_name)

    result = pystmark.send(message, api_key=env('POSTMARK_API_KEY'))
    result.raise_for_status()

    return result
Example #32
0
    def _telegram_update():
        telegram_json = telegram_json_message_without_surname()

        bot = Bot(env('TELEGRAM_API_TOKEN'))
        update = Update.de_json(json.loads(telegram_json), bot)

        return update
Example #33
0
    def _parse(self, schema=None):
        """parse the schema and set django settings"""
        if schema is not None:
            self._schema.update(schema)

        schema = schema or self._schema

        for var, spec in schema.iteritems():
            value = None
            override = None
            ignore_none = None

            if type(spec) is dict:
                passed, value = self._process_spec(var, spec)
                override = spec.get('override')
                ignore_none = spec.get('ignore_none')
            elif type(spec) is list or type(spec) is tuple:
                for spec_item in spec:
                    passed, value = self._process_spec(var, spec_item)
                    if passed:
                        override = spec_item.get('override')
                        ignore_none = spec_item.get('ignore_none')
                        break
            else:  # simple cast
                value = env(var, cast=spec)

            kwargs = {}
            if override is not None:
                kwargs['override'] = override
            if ignore_none is not None:
                kwargs['ignore_none'] = ignore_none

            setting_value(var, value, **kwargs)
Example #34
0
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'))
Example #35
0
def get_titanic(drill=False):
    titanic_status_response = requests.get(ENDPOINT+'companies/'+env('SIREN'))
    
    titanic_status_response_json = titanic_status_response.json()
    
    if 'status' not in titanic_status_response_json:
        raise Exception('Illegal Firmapi response')
    
    if titanic_status_response_json['status'] != 'success':
        raise Exception(titanic_status_response_json['message'])

    if drill:
        titanic_status_response_json['company']['radie'] = bool(random.getrandbits(1))

    return titanic_status_response_json['company']
Example #36
0
def set_env():
    """Set, Override settings values"""
    env_vars.add(
        # project
        PROJECT_NAME=dict(default='Project'),
        # sites
        SITE_DOMAIN=dict(default=None, ignore_none=True),
        SITE_NAME=dict(default=None, ignore_none=True),
        # emails
        DEFAULT_FROM_EMAIL=dict(default=None, ignore_none=True),
        EMAIL_SUBJECT_PREFIX=dict(default=None, ignore_none=True),
        EMAIL_BACKEND=dict(default=None, ignore_none=True),
        SERVER_EMAIL=dict(default=None, ignore_none=True),
        EMAIL_HOST=dict(default=None, ignore_none=True),
        EMAIL_PORT=dict(default=None, ignore_none=True),
        EMAIL_HOST_USER=dict(default=None, ignore_none=True),
        EMAIL_HOST_PASSWORD=dict(default=None, ignore_none=True),
        EMAIL_USE_TLS=dict(cast=cast_bool, default=None, ignore_none=True),
        EMAIL_USE_SSL=dict(cast=cast_bool, default=None, ignore_none=True),
        EMAIL_SSL_KEYFILE=dict(default=None, ignore_none=True),
        EMAIL_SSL_CERTFILE=dict(default=None, ignore_none=True),
        EMAIL_TIMEOUT=dict(default=None, ignore_none=True),
        # admins, managers
        ADMINS=dict(cast=cast_eval, default=None, ignore_none=True),
        MANAGERS=dict(cast=cast_eval, default=None, ignore_none=True),
        # Sentry
        SENTRY_DSN=dict(default=None),
        # Exceptional
        EXCEPTIONAL_API_KEY=dict(default=None),
        # GoogleFed
        GOOGLE_DOMAIN=dict(default=None),
        # Celery w/ RabbitMQ or Celery w/ RedisCloud
        BROKER_URL=[dict(name='CLOUDAMQP_URL', only_if='CLOUDAMQP_URL'),
                    dict(name='RABBITMQ_URL', only_if='RABBITMQ_URL'),
                    dict(name='REDISCLOUD_URL', only_if='REDISCLOUD_URL')],
        BROKER_TRANSPORT=dict(name='BROKER_TRANSPORT', only_if='BROKER_TRANSPORT')
    )

    # DATABASE_URL
    setting_value('DATABASES', {'default': dj_database_url.config()})

    # Mailgun
    if 'MAILGUN_SMTP_SERVER' in environ:
        setting_value('MAILGUN_API_KEY', env('MAILGUN_API_KEY'))
        setting_value('MAILGUN_DOMAIN', env('MAILGUN_DOMAIN'))
        setting_value('MAILGUN_PUBLIC_KEY', env('MAILGUN_PUBLIC_KEY'))
        setting_value('MAILGUN_SMTP_LOGIN', env('MAILGUN_SMTP_LOGIN'))
        setting_value('MAILGUN_SMTP_PASSWORD', env('MAILGUN_SMTP_PASSWORD'))
        setting_value('MAILGUN_SMTP_PORT', env('MAILGUN_SMTP_PORT', cast=int))
        setting_value('MAILGUN_SMTP_SERVER', env('MAILGUN_SMTP_SERVER'))

        use_mail_gun_api = env('MAILGUN_USE_API', cast=cast_bool, default=True)
        use_mail_gun_smtp = env('MAILGUN_USE_SMTP', cast=cast_bool, default=True)

        # for use api
        if use_mail_gun_api:
            # django-mailgun:
            setting_value('MAILGUN_ACCESS_KEY', settings.MAILGUN_API_KEY)
            setting_value('MAILGUN_SERVER_NAME', settings.MAILGUN_DOMAIN)

        if use_mail_gun_smtp:
            # for django smtp server: use smtp
            setting_value('EMAIL_HOST', settings.MAILGUN_SMTP_SERVER)
            setting_value('EMAIL_PORT', settings.MAILGUN_SMTP_PORT)
            setting_value('EMAIL_HOST_USER', settings.MAILGUN_SMTP_LOGIN)
            setting_value('EMAIL_HOST_PASSWORD', settings.MAILGUN_SMTP_PASSWORD)
            setting_value('MAIL_USE_TLS', env('MAIL_USE_TLS', cast=cast_bool, default=True))

    # SendGrid
    if 'SENDGRID_USERNAME' in environ:
        # this is enough to use https://github.com/elbuo8/sendgrid-django
        # don't forget to set EMAIL_BACKEND
        setting_value('SENDGRID_USERNAME', env('SENDGRID_USERNAME'))
        setting_value('SENDGRID_PASSWORD', env('SENDGRID_PASSWORD'))
        setting_value('SENDGRID_API_KEY', env('SENDGRID_API_KEY', default=None))

        setting_value('SENDGRID_SMTP_LOGIN', env('SENDGRID_SMTP_LOGIN',
                                                 default=settings.SENDGRID_USERNAME))
        setting_value('SENDGRID_SMTP_PASSWORD', env('SENDGRID_SMTP_PASSWORD',
                                                    default=settings.SENDGRID_PASSWORD))
        setting_value('SENDGRID_SMTP_PORT', env('MAILGUN_SMTP_PORT', cast=int,
                                                default=587), )
        setting_value('SENDGRID_SMTP_SERVER', env('SENDGRID_SMTP_SERVER',
                                                  default='smtp.sendgrid.net'))

        send_grid_use_smtp = env('SENDGRID_USE_SMTP', cast=cast_bool, default=True)

        if send_grid_use_smtp:
            setting_value('EMAIL_HOST', settings.SENDGRID_SMTP_SERVER)
            setting_value('EMAIL_PORT', settings.SENDGRID_SMTP_PORT)
            setting_value('EMAIL_HOST_USER', settings.SENDGRID_SMTP_LOGIN)
            setting_value('EMAIL_HOST_PASSWORD', settings.SENDGRID_SMTP_PASSWORD)
            setting_value('MAIL_USE_TLS', env('MAIL_USE_TLS', cast=cast_bool, default=True))

    # Postmark
    # if 'POSTMARK_SMTP_SERVER' in environ:
    #     setting_value('SMTP_SERVER', 'POSTMARK_SMTP_SERVER')
    #     setting_value('SMTP_LOGIN', environ.get('POSTMARK_API_KEY'))
    #     setting_value('SMTP_PASSWORD', environ.get('POSTMARK_API_KEY'))
    #     setting_value('MAIL_SERVER', 'POSTMARK_SMTP_SERVER')
    #     setting_value('MAIL_USERNAME', environ.get('POSTMARK_API_KEY'))
    #     setting_value('MAIL_PASSWORD', environ.get('POSTMARK_API_KEY'))
    #     setting_value('MAIL_USE_TLS', True)

    # Redis To Go
    redis_url = environ.get('REDISTOGO_URL')
    if redis_url:
        url = urlparse(redis_url)
        setting_value('REDIS_HOST', url.hostname)
        setting_value('REDIS_PORT', url.port)
        setting_value('REDIS_PASSWORD', url.password)

    # Mongolab
    mongolab_uri = environ.get('MONGOLAB_URI')
    if mongolab_uri:
        url = urlparse(mongolab_uri)
        setting_value('MONGO_URI', mongolab_uri)
        setting_value('MONGODB_USER', url.username)
        setting_value('MONGODB_USERNAME', url.username)
        setting_value('MONGODB_PASSWORD', url.password)
        setting_value('MONGODB_HOST', url.hostname)
        setting_value('MONGODB_PORT', url.port)
        setting_value('MONGODB_DB', url.path[1:])

    # MongoHQ
    mongohq_uri = environ.get('MONGOHQ_URL')
    if mongohq_uri:
        url = urlparse(mongohq_uri)
        setting_value('MONGO_URI', mongohq_uri)
        setting_value('MONGODB_USER', url.username)
        setting_value('MONGODB_PASSWORD', url.password)
        setting_value('MONGODB_HOST', url.hostname)
        setting_value('MONGODB_PORT', url.port)
        setting_value('MONGODB_DB', url.path[1:])

    # Cloudant
    cloudant_uri = environ.get('CLOUDANT_URL')
    if cloudant_uri:
        setting_value('COUCHDB_SERVER', cloudant_uri)

    # Memcachier
    setting_value('CACHE_MEMCACHED_SERVERS', env('MEMCACHIER_SERVERS', default=None))
    setting_value('CACHE_MEMCACHED_USERNAME', env('MEMCACHIER_USERNAME', default=None))
    setting_value('CACHE_MEMCACHED_PASSWORD', env('MEMCACHIER_PASSWORD', default=None))
Example #37
0
from envparse import env

STEPIK_BASE_URL = env('STEPIK_BASE_URL')
STEPIK_CLIENT_ID = env('STEPIK_CLIENT_ID')
STEPIK_CLIENT_SECRET = env('STEPIK_CLIENT_SECRET')

WIKI_LOGIN = env('WIKI_LOGIN')
WIKI_PASSWORD = env('WIKI_PASSWORD')
WIKI_BASE_URL = env('WIKI_BASE_URL')
WIKI_API_PATH = env('WIKI_API_PATH', default='/api.php')

UPLOAD_CARE_PUB_KEY = env('UPLOAD_CARE_PUB_KEY')
YANDEX_SPEECH_KIT_KEY = env('YANDEX_SPEECH_KIT_KEY')
Example #38
0
import os
import random
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',
Example #39
0
For the full list of settings and their values, see
https://docs.djangoproject.com/en/1.9/ref/settings/
"""

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.dirname(os.path.abspath(__file__))))

# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/1.9/howto/deployment/checklist/

# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = env('SECRET_KEY', default='9t!sc1+#0zh@%c+xyiq&dlg_ri-_*7jfl!tg!lt#c0+1s9e6%p')
HASHID_FIELD_SALT = env('HASHID_FIELD_SALT', default='6^y3*fv!fq4z@n2-i!hy-hgi0x*+3qmf@ylqtkv&x932(-8wi+')

HASHID_FIELD_ALLOW_INT = False


DEBUG = False

INTERNAL_IPS = [
    '127.0.0.1',
]

ALLOWED_HOSTS = [
    'localhost',
    'maxisushi.kz',
    'www.maxisushi.kz',
Example #40
0
def index():
	return render_template(
		'index.html',
		ANALYTICS=env('ANALYTICS', default='UA-XXXXXX-1'),
		MAPS_API=env('MAPS_API', default='123456789')
	)
Example #41
0
 def __init__(self):
     self._KEY = env('DSHIELD')
Example #42
0
def test_default_none():
    assert_type_value(type(None), None, env('NOT_PRESENT', default=None))
Example #43
0
def test_str():
    expected = str(env_vars['STR'])
    assert_type_value(str, expected, env('STR'))
    assert_type_value(str, expected, env.str('STR'))
def create_settings():
    get_or_create(Setting, app_name='Open Event')

    if current_app.config['DEVELOPMENT']:
        # get the stripe keys from the env file and save it in the settings.
        env.read_envfile()
        stripe_secret_key = env('STRIPE_SECRET_KEY', default=None)
        stripe_publishable_key = env('STRIPE_PUBLISHABLE_KEY', default=None)
        stripe_client_id = env('STRIPE_CLIENT_ID', default=None)
        paypal_sandbox_client = env('PAYPAL_SANDBOX_CLIENT', default=None)
        paypal_sandbox_secret = env('PAYPAL_SANDBOX_SECRET', default=None)
        fb_client_id = env('FACEBOOK_CLIENT_ID', default=None)
        fb_client_secret = env('FACEBOOK_CLIENT_SECRET', default=None)
        google_client_id = env('GOOGLE_CLIENT_ID', default=None)
        google_client_secret = env('GOOGLE_CLIENT_SECRET', default=None)
        tw_consumer_key = env('TWITTER_CONSUMER_KEY', default=None)
        tw_consumer_secret = env('TWITTER_CONSUMER_SECRET', default=None)
        in_client_id = env('INSTAGRAM_CLIENT_ID', default=None)
        in_client_secret = env('INSTAGRAM_CLIENT_SECRET', default=None)

        setting, _ = get_or_create(Setting, app_name='Open Event')
        setting.stripe_client_id = stripe_client_id
        setting.stripe_publishable_key = stripe_publishable_key
        setting.stripe_secret_key = stripe_secret_key
        setting.paypal_sandbox_client = paypal_sandbox_client
        setting.paypal_sandbox_secret = paypal_sandbox_secret
        setting.fb_client_id = fb_client_id
        setting.fb_client_secret = fb_client_secret
        setting.google_client_id = google_client_id
        setting.google_client_secret = google_client_secret
        setting.tw_consumer_key = tw_consumer_key
        setting.tw_consumer_secret = tw_consumer_secret
        setting.in_client_id = in_client_id
        setting.in_client_secret = in_client_secret
        db.session.add(setting)
        db.session.commit()
Example #45
0
   envparse.env used to create default values that are overriden by
   environment variables (where present). This is how settings are
   managed in Docker containers, http://12factor.net style.

"""
import os
import os.path
from envparse import env
import sys
from datetime import timedelta

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

SECRET_KEY = env(
    'SECRET_KEY',
    default='this_is_not_a_real_secret_key_234db#1k2l#GfnGqn')
DEBUG = env('DEBUG', default=False)
ALLOWED_HOSTS = [
    '127.0.0.1', 'localhost',
    env('DJANGO_ALLOWED_HOST', default='presidentbusiness.com')]

INSTALLED_APPS = (
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'djcelery',
    'celery',
Example #46
0
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():
Example #47
0
def test_preprocessor():
    assert_type_value(str, 'FOO', env('STR', preprocessor=lambda
                                      v: v.upper()))
Example #48
0
def proxied_value():
    assert_type_value(str, 'bar', env('PROXIED'))
Example #49
0
from envparse import env

env.read_envfile()  # Read .env

ENV = env.str('NODE_ENV', default='production')
DEBUG = ENV != 'production'

CACHE = {
    'STRATEGY': 'redis',
    'PARAMS': {
        'host': env('REDIS_HOST', default='localhost'),
        'port': env.int('REDIS_PORT', default=6379),
    }
}

ROUTES = {
    'URL_PREFIX': '/v1/'
}

GITHUB = {
    'CLIENT_ID': env('SIR_GITHUB_CLIENT_ID'),
    'CLIENT_SECRET': env('SIR_GITHUB_CLIENT_SECRET'),
}
Example #50
0
import re
from string import Template
import random
import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.mime.base import MIMEBase
import os
import sys
import getopt
import argparse
from envparse import env

env.read_envfile()

user_agent = env('USER_AGENT')
client_id = env('CLIENT_ID')
client_secret = env('CLIENT_SECRET')
r = praw.Reddit(
        client_id=client_id,
        client_secret=client_secret,
        user_agent=user_agent)


def get_urls(subreddit):
    """
    Returns a list of urls depending on what subreddit
    """
    submissions = r.subreddit(subreddit).hot(limit=100)

    links = [x for x in submissions]
Example #51
0
def test_var_not_present():
    with pytest.raises(ConfigurationError):
        env('NOT_PRESENT')
Example #52
0
import sunazymuth

from flask import Flask
from flask import request
from flask import render_template
from flask import redirect
app = Flask(__name__)


###
# APP ENVIRONMENT SETUP
###

# Check if we are on local development machine (default is prod)
FLASK_ENV = env('FLASK_ENV', default='production')

sha = env('GIT_COMMIT_SHA1', default='')

SENTRY_DSN = env('SENTRY_DSN', default='')
sentry_sdk.init(
	dsn=SENTRY_DSN,
	environment=FLASK_ENV,
	release=sha,
	integrations=[FlaskIntegration()]
)

# Redirect herokuapp to custom domain
@app.before_request
def redirect_domain():
	urlparts = urlparse(request.url)
Example #53
0
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)
Example #54
0
import os
import socket
import sys

from envparse import env

DEBUG = env("DEBUG", cast=bool, default=False)
LOG_LEVEL = env("LOG_LEVEL", default="INFO")
APP_NAME = env("APP_NAME", default="flags")
ADMIN_MODE = env("ADMIN_MODE", cast=bool, default=False)
PRODUCTION_MODE = env("PRODUCTION_MODE", cast=bool, default=True)
# If DEFAULT_VALUE is True, then features are Enabled unless stated otherwise
# If DEFAULT_VALUE is False, then features are Disabled unless state otherwise
DEFAULT_VALUE = env("DEFAULT_VALUE", cast=bool, default=True)

ZK_HOSTS = env("ZK_HOSTS", default="localhost:2181")
# Time in seconds to wait for zookeeper connection to succeed.
ZK_CONNECTION_TIMEOUT = 5

HOST = "localhost"
PORT = 9595

PREFIX = env("PREFIX", default="flags")
VERSION = env("VERSION", default="v1")
FEATURES_KEY = env("FEATURES_KEY", default="features")
SEGMENTS_KEY = env("SEGMENTS_KEY", default="segments")

RESPONSE_MODE_BASIC = "basic"
RESPONSE_MODE_ADVANCED = "advanced"

ROOT_PATH = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
Example #55
0
def create_app():
    BlueprintsManager.register(app)
    Migrate(app, db)

    app.config.from_object(env('APP_CONFIG', default='config.ProductionConfig'))
    db.init_app(app)
    _manager = Manager(app)
    _manager.add_command('db', MigrateCommand)

    if app.config['CACHING']:
        cache.init_app(app, config={'CACHE_TYPE': 'simple'})
    else:
        cache.init_app(app, config={'CACHE_TYPE': 'null'})

    stripe.api_key = 'SomeStripeKey'
    app.secret_key = 'super secret key'
    app.config['JSONIFY_PRETTYPRINT_REGULAR'] = False
    app.config['FILE_SYSTEM_STORAGE_FILE_VIEW'] = 'static'

    app.logger.addHandler(logging.StreamHandler(sys.stdout))
    app.logger.setLevel(logging.ERROR)

    # set up jwt
    app.config['JWT_AUTH_USERNAME_KEY'] = 'email'
    app.config['JWT_EXPIRATION_DELTA'] = timedelta(seconds=24 * 60 * 60)
    app.config['JWT_AUTH_URL_RULE'] = '/auth/session'
    _jwt = JWT(app, jwt_authenticate, jwt_identity)

    # setup celery
    app.config['CELERY_BROKER_URL'] = app.config['REDIS_URL']
    app.config['CELERY_RESULT_BACKEND'] = app.config['CELERY_BROKER_URL']

    CORS(app, resources={r"/*": {"origins": "*"}})
    AuthManager.init_login(app)

    if app.config['TESTING'] and app.config['PROFILE']:
        # Profiling
        app.wsgi_app = ProfilerMiddleware(app.wsgi_app, restrictions=[30])

    # nextgen api
    with app.app_context():
        from app.api.bootstrap import api_v1
        from app.api.uploads import upload_routes
        from app.api.exports import export_routes
        from app.api.imports import import_routes
        from app.api.celery_tasks import celery_routes
        from app.api.auth import auth_routes
        from app.api.event_copy import event_copy

        app.register_blueprint(api_v1)
        app.register_blueprint(event_copy)
        app.register_blueprint(upload_routes)
        app.register_blueprint(export_routes)
        app.register_blueprint(import_routes)
        app.register_blueprint(celery_routes)
        app.register_blueprint(auth_routes)

    sa.orm.configure_mappers()

    if app.config['SERVE_STATIC']:
        app.add_url_rule('/static/<path:filename>',
                         endpoint='static',
                         view_func=app.send_static_file)

    # sentry
    if 'SENTRY_DSN' in app.config:
        sentry.init_app(app, dsn=app.config['SENTRY_DSN'])

    # redis
    redis_store.init_app(app)

    # elasticsearch
    if app.config['ENABLE_ELASTICSEARCH']:
        es.init_app(app)
        with app.app_context():
            try:
                cron_rebuild_events_elasticsearch.delay()
            except Exception:
                pass

    return app, _manager, db, _jwt
Example #56
0
def test_var_not_present_with_default():
    default_val = 'default val'
    assert default_val, env('NOT_PRESENT', default=default_val)
Example #57
0
def test_int():
    expected = int(env_vars['INT'])
    assert_type_value(int, expected, env('INT', cast=int))
    assert_type_value(int, expected, env.int('INT'))