Пример #1
0
def read_env():
    # Liest evironment variables von .django_env/.SITE_NAME_env 

    DJANGO_ROOT = dirname(dirname(abspath(__file__)))
    SITE_NAME = basename(DJANGO_ROOT)

    path = string.replace(DJANGO_ROOT, SITE_NAME, '')
    path = string.rstrip(path, '/')
    path = ('%s/.django_env/.%s_env' % (path, SITE_NAME))
    
    try:
        with open(path) as f:
            content = f.read()
    except IOError:
        content = ''
        exit('Datei .django_env/.%s_env nicht gefunden.' % SITE_NAME)
  

    for line in content.splitlines():
        m1 = match(r'\A([A-Za-z_0-9]+)=(.*)\Z', line)
        if m1:
            key, val = m1.group(1), m1.group(2)
            m2 = match(r"\A'(.*)'\Z", val)
            if m2:
                val = m2.group(1)
            m3 = match(r'\A"(.*)"\Z', val)
            if m3:
                val = sub(r'\\(.)', r'\1', m3.group(1))

            environ.setdefault(key, val)
Пример #2
0
def unpackONOS( destDir='/tmp', run=quietRun ):
    "Unpack ONOS and return its location"
    global ONOS_TAR
    environ.setdefault( 'ONOS_TAR', join( ONOS_ROOT, tarDefaultPath ) )
    ONOS_TAR = environ[ 'ONOS_TAR' ]
    tarPath = ONOS_TAR
    if not isfile( tarPath ):
        raise Exception( 'Missing ONOS tarball %s - run buck build onos?'
                         % tarPath )
    info( '(unpacking %s)' % destDir)
    success = '*** SUCCESS ***'
    cmds = ( 'mkdir -p "%s" && cd "%s" && tar xzf "%s" && echo "%s"'
             % ( destDir, destDir, tarPath, success ) )
    result = run( cmds, shell=True, verbose=True )
    if success not in result:
        raise Exception( 'Failed to unpack ONOS archive %s in %s:\n%s\n' %
                         ( tarPath, destDir, result ) )
    # We can use quietRun for this usually
    tarOutput = quietRun( 'tar tzf "%s" | head -1' % tarPath, shell=True)
    tarOutput = tarOutput.split()[ 0 ].strip()
    assert '/' in tarOutput
    onosDir = join( destDir, dirname( tarOutput ) )
    # Add symlink to log file
    run( 'cd %s; ln -s onos*/apache* karaf;'
         'ln -s karaf/data/log/karaf.log log' % destDir,
         shell=True )
    return onosDir
Пример #3
0
    def test_load_keystone(self):
        """test_load_keystone check that we could build a map from keystone resources using Direct_objects directive."""
        environ.setdefault('KEYSTONE_ADMIN_ENDPOINT', self.OS_AUTH_URL)

        openstackmap = OpenStackMap(auto_load=False, objects_strategy=OpenStackMap.DIRECT_OBJECTS)
        openstackmap.load_keystone()
        self.assertIsNotNone(openstackmap)
Пример #4
0
def main(*args, **kwargs):
    """
    Entry point for the 'bw' command line utility.

    The args and path parameters are used for integration tests.
    """
    if not args:
        args = argv[1:]
    path = kwargs.get('path', getcwd())

    text_args = [force_text(arg) for arg in args]

    parser_bw = build_parser_bw()
    pargs = parser_bw.parse_args(args)

    io.activate_as_parent(debug=pargs.debug)

    environ.setdefault('BWADDHOSTKEYS', "1" if pargs.add_ssh_host_keys else "0")

    if len(text_args) >= 1 and (
        text_args[0] == "--version" or
        (len(text_args) >= 2 and text_args[0] == "repo" and text_args[1] == "create") or
        text_args[0] == "zen" or
        "-h" in text_args or
        "--help" in text_args
    ):
        # 'bw repo create' is a special case that only takes a path
        repo = path
    else:
        try:
            repo = Repository(path)
        except NoSuchRepository:
            io.stderr(_(
                "{x} The current working directory "
                "is not a BundleWrap repository.\n".format(x=red("!"))
            ))
            exit(1)
            return  # used during texting when exit() is mocked

    # convert all string args into text
    text_pargs = {key: force_text(value) for key, value in vars(pargs).items()}

    try:
        output = pargs.func(repo, text_pargs)
        if output is None:
            output = ()

        return_code = 0

        for line in output:
            if isinstance(line, int):
                return_code = line
                break
            else:
                io.stdout(line)
    finally:
        io.shutdown()

    if return_code != 0:  # not raising SystemExit every time to ease testing
        exit(return_code)
Пример #5
0
    def test_implement_openstackmap_with_keystone_admin_endpoint(self, mock_exists, mock_os):
        """test_implement_openstackmap_with_keystone_admin_endpoint check that we could build an empty map from the
         resources providing a keystone admin endpoint environment variable."""

        environ.setdefault('KEYSTONE_ADMIN_ENDPOINT', self.OS_AUTH_URL)

        mock_exists.return_value = False
        mock_os.return_value = True
        openstackmap = OpenStackMap(auto_load=False)
        self.assertTrue(mock_os.called)
        self.assertIsNotNone(openstackmap)
Пример #6
0
    def test_load_nova(self, mock_exists, mock_os):
        """test_load_nova check that we could build an empty map from nova resources."""

        environ.setdefault('KEYSTONE_ADMIN_ENDPOINT', self.OS_AUTH_URL)

        mock_exists.return_value = False
        mock_os.return_value = True
        openstackmap = OpenStackMap(auto_load=False, objects_strategy=OpenStackMap.NO_CACHE_OBJECTS)

        openstackmap.load_nova()
        self.assertTrue(mock_os.called)
        self.assertIsNotNone(openstackmap)
Пример #7
0
def update():
    from os import environ
    from devops.models import Environment

    environ.setdefault("DJANGO_SETTINGS_MODULE", "devops.settings")

    with open("hosts.pp", "w") as pp:
        for e in Environment.list_all():
            ip = e.nodes().admin.get_ip_address_by_network_name(e.admin_net)
            pp.write("host {{ '{}': ip => '{}' }}\n".format(e.name, ip))

    local("sudo puppet apply hosts.pp")
Пример #8
0
def get_env_variable(varname, default=None):
    """ Get environment variable or return exception. 
        If the default argument is provided, set it as the value and return that.
    """
    try:
        return environ[varname]
    except KeyError:
        if default:
            environ.setdefault(varname, default)
            return environ[varname]
        else:
            msg = 'Set the {} environment variable.'.format(varname)
            raise ImproperlyConfigured(msg)
Пример #9
0
def activate():
    environ.setdefault('DJANGO_SETTINGS_MODULE', 'cyder.settings')

    activator = cy_path('.env/bin/activate_this.py')
    try:
        execfile(activator, {'__file__': activator})
    except:
        pass

    cy_addsitedir(cy_path('vendor'))  # global (upstream) vendor library
    cy_addsitedir(cy_path('vendor-local'))  # local (project) vendor library

    import cyder.signal_handlers  # register the handlers
Пример #10
0
def upgrade(pargs):
    environ['DJANGO_SETTINGS_MODULE'] = 'teamvault.settings'
    environ.setdefault("TEAMVAULT_CONFIG_FILE", "/etc/teamvault.cfg")

    print("\n### Running migrations...\n")
    execute_from_command_line(["", "migrate", "--noinput", "-v", "3", "--traceback"])

    print("\n### Gathering static files...\n")
    from django.conf import settings
    try:
        rmtree(settings.STATIC_ROOT)
    except FileNotFoundError:
        pass
    mkdir(settings.STATIC_ROOT)
    execute_from_command_line(["", "collectstatic", "--noinput"])
Пример #11
0
    def set_arguments(self):
        """
        Get the parameters and make the adjusts necessary
        """
        # Setting the paths
        run_path = getcwd()
        project_path = dirname(run_path)
        project_name = basename(run_path)

        # Suspect the user will run in root of program test
        path_list = [run_path, project_path]
        paths = self.kwdict.pop("paths")
        if paths: path_list.extend(paths.split(","))
        for item in path_list:
            if item not in path: path.append(item)

        # Django
        self.is_django = self.kwdict.pop("django")
        module = self.kwdict.pop("module")
        if self.is_django:
            from os import environ
            # Set enviroment to run
            set_environ = "%s.settings" % project_name if module is None \
                            else module
            environ.setdefault("DJANGO_SETTINGS_MODULE", set_environ)
        verbosity = 0 if self.kwdict.pop("quiet") else 2 if \
                    self.kwdict.pop("verbose") else 1

        # Extensions
        self.extension = {
                          "requested" : self.kwdict.pop("is_extension"),
                          "module" : self.kwdict.pop("extension"),
                          "ext_type" : self.kwdict.pop("ext_type"),
                          "ext_file" : self.kwdict.pop("ext_file"),
                          }

        # Unit test
        self.unit_test = {
                          "failfast" : self.kwdict.pop("failfast"),
                          "catchbreak" : self.kwdict.pop("catch"),
                          "verbosity" : verbosity,
                          "buffer" : False
                          }

        # Additional information that was input and not parsed
        self.args = self.kwdict.pop("args")
def populate_db():
    environ.setdefault("DJANGO_SETTINGS_MODULE", "newrelic_python_kata.settings")
    from employees.models import Employee, BioData, Payroll
    with open('names.txt') as f: 
        es = []
        bs = []
        ps = []
        for idx, line in enumerate(f):
            name, sex, salary = line.rstrip('\r\n').split(',')
            e = Employee(name=name, employee_id=idx)
            b = BioData(employee=e, age=randint(18, 40), sex=sex)
            p = Payroll(employee=e, salary=salary)
            es.append(e)
            bs.append(b)
            ps.append(p)

    Employee.objects.bulk_create(es)
    BioData.objects.bulk_create(bs)
    Payroll.objects.bulk_create(ps)
Пример #13
0
def test_ConfigFile():
    initialJson = '{ \
        "iCloud" : { \
            "login"          : "None", \
            "password"       : "None", \
            "url"            : "http://www.icloud.com" \
        },\
        "Google" : { \
            "username"       : "None", \
            "password"       : "None", \
            "url"            : "http://calendar.google.com" \
        },\
        "sample" : "forTest"\
    }'
    environ.setdefault("garbage", "")
    Env(initialJson, "garbage", "garbage")
    assert Env().get("sample") == "forTest"
    assert Env().get("iCloud", "login") == "None"
    assert Env().get("garbage") == ''
    Env().envConfigFileNameOverride("envConfigFileNameOverride") 
    Env().load()
Пример #14
0
#!/usr/bin/env python
#    Copyright 2013 - 2014 Mirantis, Inc.
#
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
#    not use this file except in compliance with the License. You may obtain
#    a copy of the License at
#
#         http://www.apache.org/licenses/LICENSE-2.0
#
#    Unless required by applicable law or agreed to in writing, software
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
#    License for the specific language governing permissions and limitations
#    under the License.

from os import environ

if __name__ == "__main__":
    environ.setdefault("DJANGO_SETTINGS_MODULE", "devops.settings")
    from devops.shell import main

    main()
Пример #15
0
from django.core.wsgi import get_wsgi_application
from os import environ as env

env.setdefault('DJANGO_SETTINGS_MODULE', 'MangAdventure.settings')

application = get_wsgi_application()

To change settings file:
`DJANGO_ENV=production python manage.py runserver`
"""

from os import environ

import django_stubs_ext
from split_settings.tools import include, optional

# Monkeypatching Django, so stubs will work for all generics,
# see: https://github.com/typeddjango/django-stubs
django_stubs_ext.monkeypatch()

# Managing environment via `DJANGO_ENV` variable:
environ.setdefault('DJANGO_ENV', 'development')
_ENV = environ['DJANGO_ENV']

_base_settings = (
    'components/common.py',
    'components/logging.py',
    'components/csp.py',
    'components/caches.py',

    # Select the right env:
    'environments/{0}.py'.format(_ENV),

    # Optionally override some settings:
    optional('environments/local.py'),
)
Пример #17
0
 def run(self):
     environ.setdefault('DJANGO_SETTINGS_MODULE',
                        '{}.settings'.format(self.__name))
     print('webapp:', self.__name)
     maincmd.run()
Пример #18
0
import telebot
from telebot.types import InlineKeyboardButton, InlineKeyboardMarkup

import config
import messages
import logging

from os import environ
import django

environ.setdefault("DJANGO_SETTINGS_MODULE", "telegram_bot.settings")
django.setup()

from Question.models import Question
from django.core.exceptions import ObjectDoesNotExist


def bot_start():
    bot = telebot.TeleBot(config.token)
    new_question = Question()

    logger = logging.getLogger("information")
    logger.setLevel(logging.INFO)

    fh = logging.FileHandler("information.log")
    fh.setFormatter(
        logging.Formatter(
            "%(asctime)s - %(name)s - %(levelname)s - %(message)s"))
    logger.addHandler(fh)

    def get_question_from_user(message):
Пример #19
0
from src.api.query import get_cls_gpa, get_usr_sections, find_hour, get_instructor, get_instructor_cls_gpa, \
    get_default_term, get_rmp_gpa
from os import environ

environ.setdefault("DEFAULT_TERM", str(get_default_term()[0]))
environ.setdefault("DEFAULT_TERM_NAME", str(get_default_term()[1]))

# purposed algo sum((1 + int(cls_num/100)*weight)*(4 - avg_gpa)*(sentiment/5)*hrs) * (total_hrs/semester hr cap)

# pre-defined
weight = 0.15
# cap is 9 for summer
cap = 9


# wrapper
def calculate_difficulty(email, term=environ.get("DEFAULT_TERM")):
    status, response = fetch_grades(email, term)
    if status == 1:
        return status, response
    class_id, subject_id, credit, crn, gpa, sentiment = response
    print(class_id, subject_id, credit, crn, gpa, sentiment)
    return 0, sum([
        (1 + int(cls_num / 100) * weight) * (4 - grade) * (s / 5.0) * c
        for cls_num, grade, c, s in zip(class_id, gpa, credit, sentiment)
    ]) * (sum(credit) / cap)


# this output should reflect difficulty in some degree
# but probably need some normalization using data
# also weight and sentiment need to be implemented&&refined
Пример #20
0
File: ceesdbwrapper.py
Author: Fernando Crespo Gravalos ([email protected])
Date: 2014/06/05
"""
"""
This script wraps queries to data model (CEES database).
This keeps the view handling requests and responses.
"""
import constants as c
###################################################################
# set-up to run a model query from ceesdbwrapper. 
###################################################################
from os import path as os_path, environ
from sys import path as sys_path
sys_path.append(os_path.abspath(os_path.join(os_path.dirname(__file__), os_path.pardir)))
environ.setdefault(c.DJANGO_SETTINGS, c.CEES_SETTINGS)
####################################################################
import uuid
from datetime import datetime
from django.db import Error
from cees.models import ShopAssistants, Tokens, Devices, Stores, SaRegistrations, CheckIns, Clients, Customers, RfidCards, ClientArrivals, Licenses
from ceesloggers import getDbLogger 
from cees.serializers import ClientSerializer

dblogger = getDbLogger()
DB_ERRORS = { 0 : c.SUCC_QUERY, 1 : c.OBJECT_NOT_FOUND, 2 : c.DB_ERROR}

#################
# Authorization #
#################
Пример #21
0
from os import environ

environ.setdefault("DJANGO_SETTINGS_MODULE", "TwitterFriends.settings")
import django

django.setup()
import tweepy
from findfriends.models import TwitterUser


# function to save frienship on database
def create_frienship(api, userid):
    user = TwitterUser.objects.get(user_id=userid)
    if len(user.friends.all()) == 0:
        friends = api.friends_ids(user_id=userid)
        print("Saving ", user.screen_name, "'s friends")
        for friend in friends:
            if TwitterUser.objects.filter(user_id=friend).exists():
                u = TwitterUser.objects.get(user_id=friend)
                print(u.screen_name, " is friend of ", user.screen_name)
                user.friends.add(u)
    else:
        print(user.screen_name, "'s friends are already saved")


auth = tweepy.OAuthHandler(environ["TWITTER_CONSUMER_KEY"],
                           environ["TWITTER_CONSUMER_SECRET"])
auth.set_access_token(environ["TWITTER_ACCESS_TOKEN"],
                      environ["TWITTER_ACCESS_TOKEN_SECRET"])
api = tweepy.API(auth_handler=auth,
                 wait_on_rate_limit_notify=True,
Пример #22
0
        'NAME': 'plivo',                      # Or path to database file if using sqlite3.
        'USER': '******',                      # Not used with sqlite3.
        'PASSWORD': '******',                  # Not used with sqlite3.
        'HOST': 'localhost',                      # Set to empty string for localhost. Not used with sqlite3.
        'PORT': '3306',                      # Set to empty string for default. Not used with sqlite3.
    }
}

# Local time zone for this installation. Choices can be found here:
# http://en.wikipedia.org/wiki/List_of_tz_zones_by_name
# although not all choices may be available on all operating systems.
# On Unix systems, a value of None will cause Django to use the same
# timezone as the operating system.
# If running in a Windows environment this must be set to the same as your
# system time zone.
environ.setdefault('DJANGO_DATABASE_ENGINE', 'django.db.backends.mysql')
environ.setdefault('DJANGO_DATABASE_NAME', 'plivo')
environ.setdefault('DJANGO_DATABASE_USER', 'root')
environ.setdefault('DJANGO_DATABASE_PASSWORD', 'abc123')
environ.setdefault('DJANGO_DATABASE_HOST', 'localhost')
environ.setdefault('DJANGO_DATABASE_PORT', '3306')


TIME_ZONE = 'America/Chicago'

# Language code for this installation. All choices can be found here:
# http://www.i18nguy.com/unicode/language-identifiers.html
LANGUAGE_CODE = 'en-us'

SITE_ID = 1
Пример #23
0
    opt = variant.get('optimize')
if opt is not None:
    CONFIGURE_ARGS += (" --enable-optimize" if opt else " --disable-optimize")

opt = args.debug
if opt is None and args.platform:
    # Override variant['debug'].
    opt = ('-debug' in args.platform)
if opt is None:
    opt = variant.get('debug')
if opt is not None:
    CONFIGURE_ARGS += (" --enable-debug" if opt else " --disable-debug")

# Any jobs that wish to produce additional output can save them into the upload
# directory if there is such a thing, falling back to OBJDIR.
env.setdefault('MOZ_UPLOAD_DIR', OBJDIR)
ensure_dir_exists(env['MOZ_UPLOAD_DIR'], clobber=False)

# Some of the variants request a particular word size (eg ARM simulators).
word_bits = variant.get('bits')

# On Linux and Windows, we build 32- and 64-bit versions on a 64 bit
# host, so the caller has to specify what is desired.
if word_bits is None and args.platform:
    platform_arch = args.platform.split('-')[0]
    if platform_arch in ('win32', 'linux'):
        word_bits = 32
    elif platform_arch in ('win64', 'linux64'):
        word_bits = 64

# Fall back to the word size of the host.
Пример #24
0
#!/usr/bin/env python

from os import environ, path, chdir
import sys
import shutil

# change to manage.py's folder
abspath = path.abspath(__file__)
dname = path.dirname(abspath)
chdir(dname)

if __name__ == "__main__":

    from bptbx import b_iotools

    environ.setdefault("DJANGO_SETTINGS_MODULE", "pyntrest_project.settings")

    import_success, failed_modules = b_iotools.import_modules_with_check(
                                                 [ 'PIL', 'django.http',
                                                 'markdown2', 'bs4' ])
    if not import_success:
        print ('Sorry, but there are some packages missing: '
               + '{0}\nPlease refer to README.md to find out what '
               + 'you\'ve missed or, assuming you have \'pip\' installed,\n'
               + 'run \'pip install -r requirements.txt\''
               ).format(failed_modules)
        exit(1)

    # this needs to be done here because why want to check for missing
    # packages first
    from django.core.management import execute_from_command_line
Пример #25
0
        'PORT': '',                      # Set to empty string for default. Not used with sqlite3.
    }
}"""
"""
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': os.environ['RDS_DB_NAME'],
        'USER': os.environ['RDS_USERNAME'],
        'PASSWORD': os.environ['RDS_PASSWORD'],
        'HOST': os.environ['RDS_HOSTNAME'],
        'PORT': os.environ['RDS_PORT'],
    }
}
"""
environ.setdefault('DJANGO_MEDIA_ROOT', join(INSTALL_DIR, 'media/'))
environ.setdefault('DJANGO_MEDIA_URL', '/media/')

# Local time zone for this installation. Choices can be found here:
# http://en.wikipedia.org/wiki/List_of_tz_zones_by_name
# although not all choices may be available on all operating systems.
# On Unix systems, a value of None will cause Django to use the same
# timezone as the operating system.
# If running in a Windows environment this must be set to the same as your
# system time zone.
TIME_ZONE = 'America/Chicago'

# Language code for this installation. All choices can be found here:
# http://www.i18nguy.com/unicode/language-identifiers.html
LANGUAGE_CODE = 'en-us'
Пример #26
0
def main(*args, **kwargs):
    """
    Entry point for the 'bw' command line utility.

    The args and path parameters are used for integration tests.
    """
    if not args:
        args = argv[1:]
    path = kwargs.get('path', getcwd())

    text_args = [force_text(arg) for arg in args]

    parser_bw = build_parser_bw()
    pargs = parser_bw.parse_args(args)
    if not hasattr(pargs, 'func'):
        parser_bw.print_help()
        exit(2)

    io.debug_mode = pargs.debug
    io.activate()

    if 'BWADDHOSTKEYS' in environ:  # TODO remove in 3.0.0
        environ.setdefault('BW_ADD_HOST_KEYS', environ['BWADDHOSTKEYS'])
    if 'BWCOLORS' in environ:  # TODO remove in 3.0.0
        environ.setdefault('BW_COLORS', environ['BWCOLORS'])
    if 'BWITEMWORKERS' in environ:  # TODO remove in 3.0.0
        environ.setdefault('BW_ITEM_WORKERS', environ['BWITEMWORKERS'])
    if 'BWNODEWORKERS' in environ:  # TODO remove in 3.0.0
        environ.setdefault('BW_NODE_WORKERS', environ['BWNODEWORKERS'])

    environ.setdefault('BW_ADD_HOST_KEYS', "1" if pargs.add_ssh_host_keys else "0")

    if len(text_args) >= 1 and (
        text_args[0] == "--version" or
        (len(text_args) >= 2 and text_args[0] == "repo" and text_args[1] == "create") or
        text_args[0] == "zen" or
        "-h" in text_args or
        "--help" in text_args
    ):
        # 'bw repo create' is a special case that only takes a path
        repo = path
    else:
        try:
            repo = Repository(path)
        except MissingRepoDependency as exc:
            io.stderr(str(exc))
            exit(1)
        except NoSuchRepository:
            io.stderr(_(
                "{x} The current working directory "
                "is not a BundleWrap repository."
            ).format(x=red("!")))
            exit(1)

    # convert all string args into text
    text_pargs = {key: force_text(value) for key, value in vars(pargs).items()}

    output = pargs.func(repo, text_pargs)
    if output is None:
        output = ()

    return_code = 0

    for line in output:
        if isinstance(line, int):
            return_code = line
            break
        else:
            io.stdout(line)

    if return_code != 0:  # not raising SystemExit every time to ease testing
        exit(return_code)
Пример #27
0
from os import environ as env
import sys

if not 'DJANGO_SETTINGS_MODULE' in env:
    from recms import settings
    env.setdefault('DJANGO_SETTINGS_MODULE', settings.__name__)

import django
django.setup()


def read_forward_zone(forward_zone_conf_file):
    """reads forward zone conf file to a dict consist of some lists"""

    import re

    forward_zone_conf = {'forward-zone': []}
    d = {}
    lines = open(forward_zone_conf_file).read().split('\n')
    lines.reverse()
    for line in lines:

        if re.search(r'forward-first', line):
            d['forward-first']='yes'
            continue

        match_addr = re.match(r'\s+forward-addr:\s+(.+)', line)
        if match_addr:
            if 'forward-addr' in d:
                d['forward-addr'].append(match_addr.group(1))
            else:
Пример #28
0
    def setUp(self):
        """define environment"""
        self.OS_AUTH_URL = 'http://cloud.lab.fi-ware.org:4731/v2.0'
        self.OS_USERNAME = '******'
        self.OS_PASSWORD = '******'
        self.OS_TENANT_NAME = 'user cloud'
        self.OS_TENANT_ID = '00000000000000000000000000000001'
        self.OS_REGION_NAME = 'Spain2'
        self.OS_TRUST_ID = ''

        environ.setdefault('OS_AUTH_URL', self.OS_AUTH_URL)
        environ.setdefault('OS_USERNAME', self.OS_USERNAME)
        environ.setdefault('OS_PASSWORD', self.OS_PASSWORD)
        environ.setdefault('OS_TENANT_NAME', self.OS_TENANT_NAME)
        environ.setdefault('OS_TENANT_ID', self.OS_TENANT_ID)
        environ.setdefault('OS_REGION_NAME', self.OS_REGION_NAME)
        environ.setdefault('OS_TRUST_ID', self.OS_TRUST_ID)
Пример #29
0
    pdb.set_trace()

    with open(filepath, 'r', encoding='utf-8') as file:
        data = json.load(file)

        serializer = DogSerializer(data=data, many=True)
        if serializer.is_valid():
            serializer.save()
        else:
            print(serializer.errors)

    print('load_data done.')


if __name__ == '__main__':
    sys.path.append(PROJ_DIR)
    environ.setdefault("DJANGO_SETTINGS_MODULE", "backend.settings")
    django.setup()

    # Assuming your serializer is named DogSerializer
    # has to be imported after django.setup()
    try:

        from pugorugh.serializers import DogSerializer
    except ImportError:
        raise ImportError(
            'serializers.py must contain a properly '
            'implemented DogSerializer class for this import to work.')

    load_data()
Пример #30
0
# -*- coding: utf-8 -*-
"""
Created on Mon May  8 10:59:08 2017

@author: rstreet
"""

from os import getcwd, path, remove, environ
from sys import path as systempath, argv
cwd = getcwd()
systempath.append(path.join(cwd, '..'))
from local_conf import get_conf
app_config = get_conf('mulens_tom')
systempath.append(app_config)
environ.setdefault('DJANGO_SETTINGS_MODULE', 'mulens_tom.settings')
from django.core import management
from django.conf import settings
from django.utils import timezone
from django import setup
from datetime import datetime, timedelta
import pytz
setup()
import ingest, observing_strategy
from tom.models import Target
import lco_interface, observing_strategy, log_utilities, ingest


def get_test_obs(simulate=False):
    """Function to return an example of an ObsRequest with default
    parameters for testing purposes"""
Пример #31
0
from fabric.api import env
from fabric.api import get
from fabric.api import local
from fabric.api import prefix
from fabric.api import prompt
from fabric.api import put
from fabric.api import run
from fabric.api import task
from fabric.colors import green
from fabric.colors import red
from fabric.context_managers import settings


# add django settings module to the import search path
sys.path.append(dirname(dirname(__file__)))
environ.setdefault("DJANGO_SETTINGS_MODULE", "project.settings")


@task
def get_db_data(root_dir=None, setting=''):
    """ Returns the name of the default database """
    if not root_dir:
        root_dir = env.server_root_dir
    with cd(root_dir):
        with prefix('. .env/bin/activate'):
            return run('python -Wi manage.py printdatabasedata {}'.format(
                setting))


@task
def migrate():
Пример #32
0
from os import environ, path, unlink

# cleanup build/dist files
for fn in ('_version.py', '_version_build.py'):
    fn = path.join('rosshm', fn)
    if path.isfile(fn):
        unlink(fn)

# set testing os environ
_osenv = {
    'ROSSHM_CONFIG': '',
    'ROSSHM_HOME': path.join(path.sep, 'opt', 'rosshm'),
}
for k, v in _osenv.items():
    environ.setdefault(k, v)
    environ[k] = v

# export fixtures

__all__ = [
    'testing_cmd',
    'testing_config',
    'testing_db',
    'testing_log',
    'testing_wapp',
    'testing_wapp_plugin',
]

from testing.cmd_ctx import cmd_ctx
Пример #33
0
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# harlib
# Copyright (c) 2014-2017, Andrew Robbins, All rights reserved.
#
# This library ("it") is free software; it is distributed in the hope that it
# will be useful, but WITHOUT ANY WARRANTY; you can redistribute it and/or
# modify it under the terms of LGPLv3 <https://www.gnu.org/licenses/lgpl.html>.
from __future__ import absolute_import
from django.core.wsgi import get_wsgi_application
from os import environ
'''
harlib - HTTP Archive (HAR) format library
'''
'''
WSGI config for harlib_viewer.server project.

It exposes the WSGI callable as a module-level variable named ``application``.

For more information on this file, see
https://docs.djangoproject.com/en/1.6/howto/deployment/wsgi/
'''

environ.setdefault('DJANGO_SETTINGS_MODULE', 'harlib_viewer.server.settings')
application = get_wsgi_application()
Пример #34
0
opt = args.debug
if opt is None and args.platform:
    # Override variant['debug'].
    opt = ('-debug' in args.platform)
if opt is None:
    opt = variant.get('debug')
if opt is not None:
    CONFIGURE_ARGS += (" --enable-debug" if opt else " --disable-debug")

opt = args.jemalloc
if opt is not None:
    CONFIGURE_ARGS += (" --enable-jemalloc" if opt else " --disable-jemalloc")

# Any jobs that wish to produce additional output can save them into the upload
# directory if there is such a thing, falling back to OBJDIR.
env.setdefault('MOZ_UPLOAD_DIR', OBJDIR)
ensure_dir_exists(env['MOZ_UPLOAD_DIR'], clobber=False)

# Some of the variants request a particular word size (eg ARM simulators).
word_bits = variant.get('bits')

# On Linux and Windows, we build 32- and 64-bit versions on a 64 bit
# host, so the caller has to specify what is desired.
if word_bits is None and args.platform:
    platform_arch = args.platform.split('-')[0]
    if platform_arch in ('win32', 'linux'):
        word_bits = 32
    elif platform_arch in ('win64', 'linux64'):
        word_bits = 64

# Fall back to the word size of the host.
Пример #35
0
#!/usr/bin/env python
from os import environ
import sys
from os.path import dirname, join

if __name__ == "__main__":
    environ.setdefault("DJANGO_SETTINGS_MODULE", "qprob.settings")
    try:
        from django.core.management import execute_from_command_line
    except ImportError:
        # The above import may fail for some other reason. Ensure that the
        # issue is really that Django is missing to avoid masking other
        # exceptions on Python 2.
        try:
            import django
        except ImportError:
            raise ImportError(
                "Couldn't import Django. Are you sure it's installed and "
                "available on your PYTHONPATH environment variable? Did you "
                "forget to activate a virtual environment?")
        raise
    execute_from_command_line(sys.argv)
Пример #36
0
# serve to show the default.

from collections import OrderedDict
from datetime import datetime
import os
from os import environ
from subprocess import (
    CalledProcessError,
    check_output,
)
import sys

from pytz import UTC

# Configure MAAS's settings.
environ.setdefault("DJANGO_SETTINGS_MODULE",
                   "maasserver.djangosettings.settings")

# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.

# Include '.' in the path so that our custom extension, 'versions', can
# be found.
sys.path.insert(0, os.path.abspath('.'))

# -- Multiple documentation options.

# Add a widget to switch between different versions of the documentation to
# each generated page.
add_version_switcher = False
Пример #37
0
from os import environ
environ.setdefault("NAVYCUT_SETTINGS_MODULE",
                   "project_name___boiler_var.settings")

# Asynchronus server gateway interface
# use uvicorn asgi server to run this app

from navycut.utils.server import create_asgi_app

application = create_asgi_app()
Пример #38
0
    opt = variant.get('optimize')
if opt is not None:
    CONFIGURE_ARGS += (" --enable-optimize" if opt else " --disable-optimize")

opt = args.debug
if opt is None and args.platform:
    # Override variant['debug'].
    opt = ('-debug' in args.platform)
if opt is None:
    opt = variant.get('debug')
if opt is not None:
    CONFIGURE_ARGS += (" --enable-debug" if opt else " --disable-debug")

# Any jobs that wish to produce additional output can save them into the upload
# directory if there is such a thing, falling back to OBJDIR.
env.setdefault('MOZ_UPLOAD_DIR', OBJDIR)
ensure_dir_exists(env['MOZ_UPLOAD_DIR'], clobber=False)

# Some of the variants request a particular word size (eg ARM simulators).
word_bits = variant.get('bits')

# On Linux and Windows, we build 32- and 64-bit versions on a 64 bit
# host, so the caller has to specify what is desired.
if word_bits is None and args.platform:
    platform_arch = args.platform.split('-')[0]
    if platform_arch in ('win32', 'linux'):
        word_bits = 32
    elif platform_arch in ('win64', 'linux64'):
        word_bits = 64

# Fall back to the word size of the host.
Пример #39
0
from behave import *
from hamcrest import assert_that, equal_to, is_not
from sys import path as py_path
py_path.append('/Users/admin/SERVER3/aprinto')
from os import environ as os_environ
os_environ.setdefault("DJANGO_SETTINGS_MODULE", "aprinto.settings")

from uuid import uuid4 as get_guid
from urllib2 import urlopen,Request
import requests
from api.serializers import Initial_PDF_serializer
import pandas as pd
from sqlalchemy import create_engine

test_url = '192.168.3.52'
BASE_URL = 'http://'+test_url+':8088'

engine_url = 'postgresql://*****:*****@'+test_url+':8800/aprinto'
engine = create_engine(engine_url,encoding='utf-8',echo=False)

@given('data for posting to Aporo')
def step_impl(context):
    headers             =   {'Content-type' :   'application/json'}
    context.data        =   {'json':[{
                                  'pdf_id'              : str(get_guid()),
                                  'printer_id'          : 'printer_id1',
                                  'machine_id'          : 'vendor1',
                                  'application_name'    : 'application_name1',
                                  'doc_name'            : 'test_unit_1'
                                    }],
                             'headers'      :   headers}
Пример #40
0
import logging
from os import environ
from os.path import abspath, dirname, isfile
import sys

import django

current_path = dirname(abspath(__file__))
fleio_path = dirname(dirname(dirname(current_path)))

sys.path.append(fleio_path)
environ.setdefault("DJANGO_SETTINGS_MODULE", "fleio.settings")
django.setup()

LOG = logging.getLogger('incoming_mail')

from plugins.tickets.common.email_processor import EmailProcessor  # noqa
from plugins.tickets.common.tickets_utils import TicketUtils  # noqa


def run():
    mail_contents = None
    if len(sys.argv) > 1:
        input_file = sys.argv[1]
        if isfile(input_file):
            mail_contents = open(sys.argv[1]).read()
    else:
        mail_contents = sys.stdin.read()

    if mail_contents:
        received_message = EmailProcessor.parse_email_message(
Пример #41
0
    compiler = variant['compiler']
elif platform.system() == 'Darwin':
    compiler = 'clang'
elif platform.system() == 'Windows':
    compiler = 'cl'
else:
    compiler = 'gcc'

info("using compiler '{}'".format(compiler))

cxx = {'clang': 'clang++', 'gcc': 'g++', 'cl': 'cl'}.get(compiler)

compiler_dir = env.get('GCCDIR', os.path.join(DIR.fetches, compiler))
info("looking for compiler under {}/".format(compiler_dir))
if os.path.exists(os.path.join(compiler_dir, 'bin', compiler)):
    env.setdefault('CC', os.path.join(compiler_dir, 'bin', compiler))
    env.setdefault('CXX', os.path.join(compiler_dir, 'bin', cxx))
    if compiler == 'clang':
        platlib = 'lib'
    else:
        platlib = 'lib64' if word_bits == 64 else 'lib'
    env.setdefault('LD_LIBRARY_PATH', os.path.join(compiler_dir, platlib))
else:
    env.setdefault('CC', compiler)
    env.setdefault('CXX', cxx)

bindir = os.path.join(OBJDIR, 'dist', 'bin')
env['LD_LIBRARY_PATH'] = ':'.join(
    p for p in (bindir, env.get('LD_LIBRARY_PATH')) if p)

for v in ('CC', 'CXX', 'LD_LIBRARY_PATH'):
Пример #42
0
from __future__ import (absolute_import, unicode_literals)

from datetime import datetime
from os import environ

from celery import Celery
from django.utils.timezone import localtime

environ.setdefault('DJANGO_SETTINGS_MODULE', 'core.settings')


class MyCelery(Celery):
    def now(self) -> datetime:
        return localtime()


celery_app = MyCelery('core')
celery_app.config_from_object(obj='django.conf:settings', namespace='CELERY')
celery_app.autodiscover_tasks()
Пример #43
0
# serve to show the default.

import sys
import os
import shlex

from os import path, environ

sys.path.insert(0, path.dirname(path.dirname(path.abspath(__file__))))
# print('\n'.join([k for k in sys.path]))
sys.path.insert(0, os.path.abspath('../..'))
sys.path.insert(0, os.path.abspath('../../..'))
sys.path.insert(0, os.path.abspath('../../../..'))
sys.path.insert(0, os.path.abspath('../'))

environ.setdefault("DJANGO_SETTINGS_MODULE", "siteconfig.settings")
import django
from django.utils import timezone
django.setup()

# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
#sys.path.insert(0, os.path.abspath('.'))


# -- General configuration ------------------------------------------------

# If your documentation needs a minimal Sphinx version, state it here.
#needs_sphinx = '1.0'
Пример #44
0
"""
Sphinx documentation generator configuration.

More information on the configuration options is available at:

    http://www.sphinx-doc.org/en/master/usage/configuration.html
"""

from os import environ
from pkg_resources import get_distribution

import django
import sphinx_rtd_theme

environ.setdefault('DJANGO_SETTINGS_MODULE', 'axes.tests.settings')
django.setup()

# -- Extra custom configuration  ------------------------------------------

title = 'django-axes documentation'
description = 'Keep track of failed login attempts in Django-powered sites.',

# -- General configuration ------------------------------------------------

# Add any Sphinx extension module names here, as strings.
# They can be extensions coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
extensions = ['sphinx.ext.autodoc']

# Add any paths that contain templates here, relative to this directory.
templates_path = [
    '_templates',
Пример #45
0
def configure_django(settings):
    import django
    environ.setdefault("DJANGO_SETTINGS_MODULE", settings['DJANGO_SETTINGS'])
    django.setup()
from os import environ

environ.setdefault('DJANGO_SETTINGS_MODULE', 'DjangoSandBox.settings')

import django

django.setup()

from ..populations.PopulatePersonBase import PopulatePersonBase
from ..models import Person


class PopulatePersonByGetOrCreate(PopulatePersonBase):
    def save_person(self, name, height, date_of_birth, sex):
        Person.objects.get_or_create(name=name, sex=sex, height=height, date_of_birth=date_of_birth)


if __name__ == '__main__':
    a_populator = PopulatePersonByGetOrCreate()
    a_populator.populate()
    a_populator.display_people()
Пример #47
0
    def setUp(self):
        """define environment"""
        self.OS_AUTH_URL = environ.get('OS_AUTH_URL')
        if self.OS_AUTH_URL is None:
            self.OS_AUTH_URL = 'http://cloud.lab.fi-ware.org:4731/v2.0'
            environ.setdefault('OS_AUTH_URL', self.OS_AUTH_URL)

        self.OS_USERNAME = environ.get('OS_USERNAME')
        if self.OS_USERNAME is None:
            self.OS_USERNAME = '******'
            environ.setdefault('OS_USERNAME', self.OS_USERNAME)

        self.OS_PASSWORD = environ.get('OS_PASSWORD')
        if self.OS_PASSWORD is None:
            self.OS_PASSWORD = '******'
            environ.setdefault('OS_PASSWORD', self.OS_PASSWORD)

        self.OS_TENANT_NAME = environ.get('OS_TENANT_NAME')
        if self.OS_TENANT_NAME is None:
            self.OS_TENANT_NAME = 'tenant_name'
            environ.setdefault('OS_TENANT_NAME', self.OS_TENANT_NAME)

        self.OS_TENANT_ID = environ.get('OS_TENANT_ID')
        if self.OS_TENANT_ID is None:
            self.OS_TENANT_ID = 'tenant_id'
            environ.setdefault('OS_TENANT_ID', self.OS_TENANT_ID)

        self.OS_REGION_NAME = environ.get('OS_REGION_NAME')
        if self.OS_REGION_NAME is None:
            self.OS_REGION_NAME = 'Spain2'
            environ.setdefault('OS_REGION_NAME', self.OS_REGION_NAME)

        self.OS_TRUST_ID = environ.get('OS_TRUST_ID')
        if self.OS_TRUST_ID is None:
            self.OS_TRUST_ID = ''
            environ.setdefault('OS_TRUST_ID', self.OS_TRUST_ID)
Пример #48
0
def jenkins_autoset():
    if 'JENKINS_URL' not in environ:
        return

    environ.setdefault('TARGET_URL', environ.get('BUILD_URL'))
Пример #49
0
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/1.8/howto/deployment/wsgi/

Use this file wsgi_sample.py to create a new file wsgi.py in the same directory. 
And replace the 2 strings below with their actual paths:
	<path_to_virtual_python_installation>
	<path_to_hsnmailenbeheer>
"""

from os import environ
from sys import path, version


# setup the virtual environment
activate_this = "<path_to_virtual_python_installation>/python2710/bin/activate_this.py"

execfile( activate_this, dict( __file__ = activate_this ) )
print( version )

# additions to used python; prepend to path
path.insert( 0, "<path_to_hsnmailenbeheer>/hsnmailenbeheer/server" )			# project parent dir
path.insert( 0, "<path_to_hsnmailenbeheer>/hsnmailenbeheer/server/hsnmailenbeheer" )	# project root dir, containing settings.py

environ.setdefault( "DJANGO_SETTINGS_MODULE", "hsnmailenbeheer.settings" )

from django.core.wsgi import get_wsgi_application
application = get_wsgi_application()

# [eof]
Пример #50
0
#!/usr/bin/env python
from os import environ, listdir
from os.path import join, dirname, abspath, exists
import sys

if __name__ == "__main__":

    # Try to discover project name and set the default settings module
    # based on it. If discovery fails, DJANGO_SETTINGS_MODULE environment
    # variable must be set.

    root = dirname(abspath(__file__))
    sys.path.append(root)
    sys.path.append(join(root, '..'))
    settings_module = None
    for name in listdir(root):
        full_name = join(root, name)
        if exists(join(full_name, 'settings', '__init__.py')):
                settings_module = name + '.settings'
                break

    if settings_module is not None:
        environ.setdefault("DJANGO_SETTINGS_MODULE", settings_module)

    from django.core.management import execute_from_command_line
    execute_from_command_line(sys.argv)
Пример #51
0
#!/usr/bin/env python

from os import environ as env
import sys

if __name__ == "__main__":
    env.setdefault("DJANGO_SETTINGS_MODULE", "mysite.settings.dev")

    from django.core.management import execute_from_command_line
    from django.conf import settings

    if settings.DEBUG and \
            (env.get('RUN_MAIN') or env.get('WERKZEUG_RUN_MAIN')):
        import ptvsd
        ptvsd.enable_attach(address=('0.0.0.0', 5678))
        print("Attached remote debugger")
    execute_from_command_line(sys.argv)
Пример #52
0
#!/usr/bin/env python3
# coding: utf-8
from os import (
    environ,
    path,
)
from sys import (
    path as py_path,
    stderr,
)

ROOT = path.dirname(__file__)

environ.setdefault(
    'BERNARD_SETTINGS_FILE',
    path.join(ROOT, 'src/rocket_launcher/settings.py'),
)

if __name__ == '__main__':
    try:
        py_path.append(path.join(ROOT, 'src'))
        from bernard.misc.main import main
        main()
    except ImportError:
        print(
            'Could not import BERNARD. Is your environment correctly '
            'configured?',
            file=stderr,
        )
        exit(1)
Пример #53
0
"""
Helpful Resources:

	1. https://docs.djangoproject.com/en/3.1/howto/deployment/wsgi/
"""
from django.core.wsgi import get_wsgi_application
from os import environ


# Register our web application with any WSGI-compliant web server
environ.setdefault('DJANGO_SETTINGS_MODULE', 'programmingpals.settings')
application = get_wsgi_application()
Пример #54
0
 def sd(var, val):
     "Set default value for environment variable"
     env[var] = environ.setdefault(var, val)
     return env[var]
Пример #55
0
from configparser import SafeConfigParser

# import djcelery


# # Project Configuration
# ----------------------------------------------------------------------------
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
APPS_DIR = os.path.abspath(os.path.join(BASE_DIR, os.pardir, 'ingxoxo'))
PROJ_DIR = os.path.abspath(os.path.join(BASE_DIR, os.pardir))
LOG_DIR = os.path.abspath(os.path.join(PROJ_DIR, 'log'))


# # Config File
# ----------------------------------------------------------------------------
environ.setdefault('INGXOXO_CONFIG', join(PROJ_DIR, "config.cfg"))
config = SafeConfigParser()
config.read(environ['INGXOXO_CONFIG'])


# # Allow Hosts Configuration
# ----------------------------------------------------------------------------
ALLOWED_HOSTS = ['*']


# # Manager Configuration
# ----------------------------------------------------------------------------
ADMINS = (
    ('Djordje Ilic', '*****@*****.**'),
)
MANAGERS = ADMINS
Пример #56
0
#!/usr/bin/env python

from __future__ import absolute_import

from django.core.management import execute_from_command_line
from os import environ
from sys import argv

if len(argv) > 1 and argv[1] == 'test':
    environ['ENV'] = 'test'

if __name__ == '__main__':
    environ.setdefault('DJANGO_SETTINGS_MODULE', 'www.settings')

    execute_from_command_line(argv)
Пример #57
0
#!/usr/bin/env python
# -*- coding: utf-8 -*-

from sys import platform

if platform == "win32":
    from os import environ

    environ.setdefault("FORKED_BY_MULTIPROCESSING", "1")

__doc__ = """https://docs.celeryproject.org/en/latest/

https://zhuanlan.zhihu.com/p/22304455

issues:
    https://github.com/celery/celery/issues/4081
"""