def DeleteService(serviceName):
"""
Base for DeleteService function , callable from other django application
"""
try:
settings=file(base_path+'/settings.py','r')
settingFile=settings.read()
settings.close()
if settingFile.find(',\n \'masterinterface.'+serviceName)>0:
if os.path.exists(base_path+'/'+serviceName):
shutil.rmtree(base_path+'/'+serviceName)
newsettingFile=settingFile.replace(',\n \'masterinterface.'+serviceName+'\'','')
settingFile=file(base_path+'/settings.py','w')
settingFile.write(newsettingFile)
settingFile.close()
UrlFile=file(base_path+'/urls.py','r')
newUrlFile=UrlFile.read().replace(',\n url(r\'^'+serviceName+'/\', include(\'masterinterface.'+serviceName+'.urls\'))','')
UrlFile.close()
UrlFile=file(base_path+'/urls.py','w')
UrlFile.write(newUrlFile)
UrlFile.close()
else:
return 0, "Service doesn't exist"
sys.argv.append('syncdb')
execute_manager(masterInterfaceSettings)
return 1, "Delete done"
except Exception, e:
return 0, "Error on Delete"
def run(settings):
if not os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'third-party') in sys.path:
sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'third-party'))
if not os.path.dirname(os.path.dirname(os.path.abspath(__file__))) in sys.path:
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from django.core.management import execute_manager
execute_manager(settings)
def manage(*args):
settings = utils.get_settings(apps=('django_extensions',))
del settings.DEBUG
config = utils.get_config_file()
app = loadapp('config:%s' % config) # NOQA
from django.core import management
management.setup_environ = lambda *args: os.getcwd
loadapp('config:%s' % config)
from django.conf import settings as sets # NOQA
args = args or sys.argv[1:]
if not args:
return sys.exit(management.execute_manager(settings))
cmd = args[0]
config = ConfigParser()
config.read(os.path.expanduser('~/.djangodevkitrc'))
try:
alias = config.get('aliases', cmd)
except:
cmds = [args]
else:
sargs = ' '.join(args[1:])
cmds = [a.replace('[]', sargs) for a in alias.split('\n') if a.strip()]
cmds = [a.split() for a in cmds]
for cmd in cmds:
sys.argv[1:] = cmd
management.execute_manager(settings)
def init(reset):
# first time setup (or re-setup)
print "Initializing settings..."
user_dir = os.path.expanduser("~/.openmdao/gui/") # TODO: could put in a prefs file
ensure_dir(user_dir)
settings_file = "settings.py"
database_file = user_dir+"mdaoproj.db"
media_storage = user_dir+"media"
if os.path.exists(settings_file):
os.remove(settings_file)
o = open(settings_file,"a") #open for append
for line in open("settings.tmp"):
line = line.replace("'NAME': 'mdaoproj.db'","'NAME': '"+database_file+"'")
line = line.replace("MEDIA_ROOT = ''","MEDIA_ROOT = '"+media_storage+"'")
o.write(line)
o.close()
import settings
print "MEDIA_ROOT=",settings.MEDIA_ROOT
print "DATABASE=",settings.DATABASES['default']['NAME']
print "Resetting project database..."
if reset and os.path.exists(database_file):
print "Deleting existing project database..."
os.remove(database_file)
from django.core.management import execute_manager
execute_manager(settings,argv=[__file__,'syncdb'])
def main(settings):
if dirname(settings.__file__) == os.getcwd():
sys.stderr.write("manage.py should not be run from within the "
"'reviewboard' Python package directory.\n")
sys.stderr.write("Make sure to run this from the top of the "
"Review Board source tree.\n")
sys.exit(1)
if len(sys.argv) > 1 and \
(sys.argv[1] == 'runserver' or sys.argv[1] == 'test'):
if settings.DEBUG:
# If DJANGO_SETTINGS_MODULE is in our environment, we're in
# execute_manager's sub-process. It doesn't make sense to do this
# check twice, so just return.
if 'DJANGO_SETTINGS_MODULE' not in os.environ:
sys.stderr.write('Running dependency checks (set DEBUG=False '
'to turn this off)...\n')
check_dependencies(settings)
else:
# Some of our checks require access to django.conf.settings, so
# tell Django about our settings.
#
# This must go before the imports.
setup_environ(settings)
# Initialize Review Board, so we're in a state ready to load
# extensions and run management commands.
from reviewboard import initialize
initialize()
include_enabled_extensions(settings)
execute_manager(settings)
def _start_server(self, host, port, threadnum):
tmp_dir = kivy.kivy_home_dir
pid_file = os.path.join(tmp_dir, 'wsgiserver.pid')
import __main__
project_dir = os.path.dirname(os.path.abspath(
pj(__main__.__file__, '..')))
sys.path.insert(1, pj(project_dir, 'ka-lite/kalite'))
sys.path.insert(1, pj(project_dir, 'ka-lite'))
sys.path.insert(1, pj(project_dir, 'ka-lite/python-packages'))
os.chdir(pj(project_dir, 'ka-lite', 'kalite'))
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'kalite.settings')
self.setup_chronograph()
import settings
from django.core.management import execute_manager
execute_manager(settings, [
'manage.py', 'runcherrypyserver',
"host={}".format(host),
"port={}".format(port),
# "pidfile={}".format(pid_file),
# 'daemonize=True',
'daemonize=False',
threadnum])
def _start_server(self, host, port):
import __main__
project_dir = os.path.dirname(os.path.abspath(pj(__main__.__file__, "..")))
sys.path.insert(1, pj(project_dir, "ka-lite/kalite"))
sys.path.insert(1, pj(project_dir, "ka-lite/python-packages"))
os.chdir(pj(project_dir, "ka-lite", "kalite"))
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "settings")
self.setup_chronograph()
import settings
from django.core.management import execute_manager
execute_manager(
settings,
[
"manage.py",
"runcherrypyserver",
"host={}".format(host),
"port={}".format(port),
"daemonize=False",
"threads=3",
],
)
def runNginxServer(self):
from django.core.servers.fastcgi import runfastcgi
from django.core.management import setup_environ
from mysite import settings
os.chdir("%s/nginx"%self.p)
fname="conf/site.conf"
f=file(fname, "w+")
confStr=nginxConf%{"PORT":self.port, "FCGI_PORT":self.fcgiPort}
f.write(confStr)
f.close()
if os.name=='posix':
os.system("""./nginx""")
else: #'nt', windows
os.system("""nginx.exe -s stop""")
os.system("""start nginx.exe""")
os.chdir(self.p)
#print "startup fcgi module ..."
if os.name=='posix':
setup_environ(settings)
runfastcgi(method="threaded", maxrequests=500, protocol="fcgi", host="localhost", port=self.fcgiPort)
else: #runfcgi method=threaded host=localhost port=10026
from django.core.management import execute_manager
sys.argv.append("runfcgi")
sys.argv.append("method=thread")
sys.argv.append("host=localhost")
sys.argv.append("port=%s"%self.fcgiPort)
execute_manager(settings)
def main():
try:
management.execute_manager(settings)
except KeyboardInterrupt:
print ""
print "Exiting script."
sys.exit(0)
def main():
if len(sys.argv) < 2 and not in_armstrong_project():
usage()
sys.exit(0)
if len(sys.argv) >= 2:
subcommand = sys.argv[1]
if subcommand in ARMSTRONG_COMMANDS:
sys.exit(ARMSTRONG_COMMANDS[subcommand]())
# are we in an armstrong project?
if in_armstrong_project():
# Make sure the current working dir is always in the path as the first
# element. Initial tests on a Homebrew Python installation result in
# this not being the case.
if CWD not in sys.path:
sys.path.insert(0, CWD)
settings_module = "config.development"
if "--production" in sys.argv:
settings_module = "config.production"
del sys.argv[sys.argv["--production"]]
try:
__import__(settings_module, globals(), locals())
settings = sys.modules[settings_module]
except ImportError, e:
sys.stderr.write("Unable to import %s: %s" % (settings_module, e))
sys.exit(1)
from django.core.management import execute_manager
execute_manager(settings)
def start (args):
# if a specific conf has been provided (which it
# will be), if we're inside the django reloaded
if "RAPIDSMS_INI" in os.environ:
ini = os.environ["RAPIDSMS_INI"]
# use a local ini (for development)
# if one exists, to avoid everyone
# having their own rapidsms.ini
elif os.path.isfile("local.ini"):
ini = "local.ini"
# otherwise, fall back
else: ini = "rapidsms.ini"
# add the ini path to the environment, so we can
# access it globally, including any subprocesses
# spawned by django
os.environ["RAPIDSMS_INI"] = ini
# read the config, which is shared
# between the back and frontend
conf = Config(ini)
# import the webui settings, which builds the django
# config from rapidsms.config, in a round-about way.
# can't do it until env[RAPIDSMS_INI] is defined
from rapidsms.webui import settings
# whatever we're doing, we'll need to call
# django's setup_environ, to configure the ORM
os.environ["DJANGO_SETTINGS_MODULE"] = "rapidsms.webui.settings"
from django.core.management import setup_environ, execute_manager
setup_environ(settings)
# if one or more arguments were passed, we're
# starting up django -- copied from manage.py
if len(args) > 1:
execute_manager(settings)
# no arguments passed, so perform
# the default action: START RAPIDSMS
else:
router = Router()
router.set_logger(conf["log"]["level"], conf["log"]["file"])
router.info("RapidSMS Server started up")
# add each application from conf
for app_conf in conf["rapidsms"]["apps"]:
router.add_app(app_conf)
# add each backend from conf
for backend_conf in conf["rapidsms"]["backends"]:
router.add_backend(backend_conf)
# wait for incoming messages
router.start()
def run(self):
os.chdir(self.testproj_dir)
sys.path.append(self.testproj_dir)
os.environ['DJANGO_SETTINGS_MODULE'] = 'settings'
settings_file = os.environ['DJANGO_SETTINGS_MODULE']
settings_mod = __import__(settings_file, {}, {}, [''])
from django.core.management import execute_manager
execute_manager(settings_mod, argv=[__file__, "test"])
def main(): HERE = os.path.abspath(__file__) HERE = os.path.join(os.path.dirname(HERE), '..') HERE = os.path.normpath(HERE) sys.path = [HERE] + sys.path execute_manager(settings)
def assist_the_regional_manager(args):
if not os.path.exists(args.settings_file):
sys.stderr.write(ERRORS['nofile'] % args.settings_file)
sys.exit(1)
from django.core.management import execute_manager
settings = load_settings_file(args.settings_file)
mgmt_argv = [str(__file__),] + args.MGMT_CMD + args.MGMT_ARGS
execute_manager(settings, argv=mgmt_argv)
def manage(config):
"""django's manage wrapper to take care of the configuration"""
from pytheon.utils import Config
config = Config.from_file(config)
config = dict(config['app:main'].items())
settings = django_settings(config)
from django.core.management import execute_manager
execute_manager(settings)
def runSimpleServer(self):
'''
Django 内置服务器运行
'''
# print "runSimpleServer"
from django.core.management import execute_manager
from mysite import settings
execute_manager(settings, [self.p+'/mysite/manage.py', 'runserver', self.address])
def rule_with_an_iron_fist(args):
settings_file = load_with_label(args.LABEL)
if not os.path.exists(settings_file):
sys.stderr.write(ERRORS['nofile'] % settings_file)
sys.exit(1)
settings = load_settings_file(settings_file)
from django.core.management import execute_manager
mgmt_argv = [str(__file__),] + args.MGMT_CMD + args.MGMT_ARGS
execute_manager(settings, argv=mgmt_argv)
def main():
# Import test settings
from django_banking import test_settings as settings
setup_environ(settings)
# Use Django's Execute manager to run the tests
sys.argv = [sys.argv[0],'test', 'django_banking']
execute_manager(settings)
def manage_15orless():
from django.core.management import execute_manager
try:
import settings # Assumed to be in the same directory.
except ImportError:
sys.stderr.write("Error: Can't find the file 'settings.py' in the directory containing %r. It appears you've customized things.\nYou'll have to run django-admin.py, passing it your settings module.\n(If the file settings.py does indeed exist, it's causing an ImportError somehow.)\n" % __file__)
sys.exit(1)
execute_manager(settings)
def start(args):
# if a specific conf has been provided (which it
# will be), if we're inside the django reloaded
if "RAPIDSMS_INI" in os.environ:
ini = os.environ["RAPIDSMS_INI"]
# use a local ini (for development)
# if one exists, to avoid everyone
# having their own rapidsms.ini
elif os.path.isfile("local.ini"):
ini = "local.ini"
# otherwise, fall back
else:
ini = "rapidsms.ini"
# add the ini path to the environment, so we can
# access it globally, including any subprocesses
# spawned by django
os.environ["RAPIDSMS_INI"] = ini
# read the config, which is shared
# between the back and frontend
conf = Config(ini)
# if we found a config ini, try to configure Django
if conf.sources:
# import the webui settings, which builds the django
# config from rapidsms.config, in a round-about way.
# can't do it until env[RAPIDSMS_INI] is defined
from rapidsms.webui import settings
import_local_settings(settings, ini)
# whatever we're doing, we'll need to call
# django's setup_environ, to configure the ORM
os.environ["DJANGO_SETTINGS_MODULE"] = "rapidsms.webui.settings"
from django.core.management import setup_environ, execute_manager
setup_environ(settings)
else:
settings = None
# if one or more arguments were passed, we're
# starting up django -- copied from manage.py
if len(args) < 2:
print "Commands: route, startproject <name>, startapp <name>"
sys.exit(1)
if hasattr(Manager, args[1]):
handler = getattr(Manager(), args[1])
handler(conf, *args[2:])
elif settings:
# none of the commands were recognized,
# so hand off to Django
execute_manager(settings)
def manage_global():
try:
from qualitio import settings
except:
sys.stderr.write(import_error_message)
from django.core.management import execute_manager
execute_manager(settings)
def SvcDoRun(self):
self.ReportServiceStatus(win32service.SERVICE_START_PENDING)
try:
self.ReportServiceStatus(win32service.SERVICE_RUNNING)
from django.core.management import execute_manager
execute_manager(settings)
win32event.WaitForSingleObject(self.stop_event, win32event.INFINITE)
except Exception, ex:
self.log('Exception: %s' % ex)
self.SvcStop()
def main():
# Sync db
#execute_manager(settings, argv="syncdb")
execute_manager(settings, argv=[__file__, "syncdb"])
# Populate initial branch
for name, path in (("trunk","trunk/l10n-kde4"), ("stable", "branches/stable/l10n-kde4")):
Branch.objects.get_or_create(name=name, path=path)
print
print "Now, you can synchronise your database with 'py10n -sg' for GUI and 'py10n -sd' for docs"
def run(self):
this_dir = os.getcwd()
testproj_dir = os.path.join(this_dir, "test_project")
os.chdir(testproj_dir)
sys.path.append(testproj_dir)
from django.core.management import execute_manager
os.environ["DJANGO_SETTINGS_MODULE"] = 'test_project.settings'
settings_file = os.environ["DJANGO_SETTINGS_MODULE"]
settings_mod = __import__(settings_file, {}, {}, [''])
execute_manager(settings_mod, argv=[
__file__, "test", "eav_forms"])
os.chdir(this_dir)
def manage(*args):
settings = utils.get_settings(apps=('django_extensions',))
del settings.DEBUG
config = utils.get_config_file()
app = loadapp('config:%s' % config)
from django.core import management
management.setup_environ = lambda *args: os.getcwd
loadapp('config:%s' % config)
from django.core.management import execute_manager
from django.conf import settings as sets
sys.argv[1:1] = args
management.execute_manager(settings)
def main():
if django.VERSION[0] >= 1 and django.VERSION[1] >= 5:
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "appomatic.settings")
from django.core.management import execute_from_command_line
execute_from_command_line(sys.argv)
else:
from django.core.management import execute_manager
execute_manager(settings)
def run(self):
this_dir = os.getcwd()
testproj_dir = os.path.join(this_dir, "testproj")
os.chdir(testproj_dir)
sys.path.insert(0, testproj_dir)
from django.core.management import execute_manager
os.environ["DJANGO_SETTINGS_MODULE"] = os.environ.get(
"DJANGO_SETTINGS_MODULE", "settings")
settings_file = os.environ["DJANGO_SETTINGS_MODULE"]
settings_mod = __import__(settings_file, {}, {}, [''])
execute_manager(settings_mod, argv=[__file__, "test"])
os.chdir(this_dir)
def run(self):
this_dir = os.getcwd()
testproj_dir = os.path.join(this_dir, 'risiko')
os.chdir(testproj_dir)
sys.path.append(testproj_dir)
from django.core.management import execute_manager
os.environ['DJANGO_SETTINGS_MODULE'] = os.environ.get(
'DJANGO_SETTINGS_MODULE', 'settings')
settings_file = os.environ['DJANGO_SETTINGS_MODULE']
settings_mod = __import__(settings_file, {}, {}, [''])
execute_manager(settings_mod, argv=[
__file__, 'test'])
os.chdir(this_dir)
def main():
parser = Bcfg2.Options.get_parser()
parser.add_options([
Bcfg2.Options.PositionalArgument('django_command', nargs='*')])
parser.parse()
if django.VERSION[0] == 1 and django.VERSION[1] >= 6:
from django.core.management import execute_from_command_line
execute_from_command_line(
sys.argv[:1] + Bcfg2.Options.setup.django_command)
else:
from django.core.management import execute_manager
execute_manager(Bcfg2.DBSettings.settings)
def django_run_server (project, logger):
django_module = project.get_mandatory_property("django_module")
logger.info("Running Django development server for %s", django_module)
module = "%s.settings" % django_module
sys.path.append(project.expand_path("$dir_source_main_python"))
try:
__import__(module)
except ImportError as e:
raise PythonbuilderException("Missing settings module: " + str(e))
execute_manager(sys.modules[module], ["", "runserver"])
#!/usr/bin/env python
import sys, os
current_dir = os.path.dirname(os.path.abspath(__file__))
sys.path.extend([
os.path.join(current_dir, 'packages'),
])
from django.core.management import execute_manager
import imp
try:
import config.local # Assumed to be in the config directory.
except ImportError:
sys.stderr.write(
"Error: Can't find the file 'config/local.py' in the directory containing %r. It appears you've customized things.\nYou'll have to run django-admin.py, passing it your settings module.\n"
% __file__)
sys.exit(1)
import config.local
if __name__ == "__main__":
execute_manager(config.local)
#!/usr/bin/env python
from django.core.management import execute_manager
try:
import albatross.ms.settings
except ImportError:
import sys
sys.stderr.write(
"Error: Can't find the file 'settings.py' in the directory containing %r. It appears you've customized things.\nYou'll have to run django-admin.py, passing it your settings module.\n(If the file settings.py does indeed exist, it's causing an ImportError somehow.)\n"
% __file__)
sys.exit(1)
if __name__ == "__main__":
execute_manager(albatross.ms.settings)
#!/usr/bin/env python
from django.core.management import execute_manager
import imp, os
try:
imp.find_module('settings') # Assumed to be in the same directory.
except ImportError:
import sys
sys.stderr.write(
"Error: Can't find the file 'settings.py' in the directory containing %r. It appears you've customized things.\nYou'll have to run django-admin.py, passing it your settings module.\n"
% __file__)
sys.exit(1)
import settings.development
if __name__ == "__main__":
execute_manager(settings.development)
def legacy_main():
find_sources()
settings_module = "lava_server.settings.development"
settings = __import__(settings_module, fromlist=[''])
from django.core.management import execute_manager
execute_manager(settings)
#!/usr/bin/env python
from django.core.management import execute_manager
try:
import admin_settings # Assumed to be in the same directory.
except ImportError:
import sys
sys.stderr.write("Error: Can't find the file 'settings.py' in the directory containing %r. It appears you've customized things.\nYou'll have to run django-admin.py, passing it your settings module.\n(If the file settings.py does indeed exist, it's causing an ImportError somehow.)\n" % __file__)
sys.exit(1)
if __name__ == "__main__":
execute_manager(admin_settings)
setup_environ(settings_mod)
prev_sys_path = list(sys.path)
# define paths to work on
BASE_PATH = abspath(join(abspath(dirname(__file__)), '..'))
LIB_PATH = join(BASE_PATH, 'env', 'lib', 'python2.6')
SITE_PACKAGES_PATH = join(LIB_PATH, 'site-packages')
# add libs and pluggables to our python path
for d in (LIB_PATH, SITE_PACKAGES_PATH):
path = addsitedir(d, set())
if path:
sys.path = list(path) + sys.path
# Reorder sys.path so new directories at the front.
new_sys_path = []
for item in list(sys.path):
if item not in prev_sys_path:
new_sys_path.append(item)
sys.path.remove(item)
sys.path[:0] = new_sys_path
# make sure that project's manage.py command creates new apps inside the right directory
cmds = get_commands()
cmds['startapp'] = ProjectCommand(settings.PATH)
if __name__ == '__main__':
#execute_from_command_line()
execute_manager(settings_mod)
def runSimpleServer(self):
# print "runSimpleServer"
from django.core.management import execute_manager
from mysite import settings
execute_manager(settings, [self.p+'/mysite/manage.py', 'runserver', self.address])
)
SQLITE_DB_ENGINE = "sqlite3"
if __name__ == "__main__":
if settings.DATABASE_ENGINE == SQLITE_DB_ENGINE and os.path.exists(
settings.DATABASE_NAME):
print "Removing " + settings.DATABASE_NAME
os.remove(settings.DATABASE_NAME)
else:
from django.db import connection
cursor = connection.cursor()
cursor.execute("drop database if exists %s; create database %s;" %
(settings.DATABASE_NAME, settings.DATABASE_NAME))
execute_manager(settings, ["", "syncdb"])
print "Creating categories"
for category_name in CATEGORIES:
category = Category(name=category_name)
category.save()
print Category.objects.all()
print "Creating ratings"
for rating_value in RATINGS:
rating = Rating(value=rating_value)
rating.save()
print Rating.objects.all()
print "Creating labels"
for label_name in LABELS:
label = Label(name=label_name)
#!/usr/bin/env python
from django.core.management import execute_manager
try:
import settings.local # Assumed to be in the same directory.
except ImportError:
import sys
sys.stderr.write(
"Error: Can't find the file 'settings.py' in the directory containing %r. It appears you've customized things.\nYou'll have to run django-admin.py, passing it your settings module.\n(If the file settings.py does indeed exist, it's causing an ImportError somehow.)\n"
% __file__)
sys.exit(1)
if __name__ == "__main__":
execute_manager(settings.local)
#!/usr/bin/env python
import os
import sys
import django
import Bcfg2.Options
import Bcfg2.DBSettings
try:
import Bcfg2.Server.models
except ImportError:
pass
parser = Bcfg2.Options.get_parser()
parser.add_options([Bcfg2.Options.PositionalArgument('django_command', nargs='*')])
parser.parse()
if __name__ == "__main__":
if django.VERSION[0] == 1 and django.VERSION[1] >= 6:
from django.core.management import execute_from_command_line
execute_from_command_line(sys.argv[:1] + Bcfg2.Options.setup.django_command)
else:
from django.core.management import execute_manager
execute_manager(Bcfg2.DBSettings.settings)
#!/usr/bin/env python2.6
# -*- coding: utf-8 -*-
from os import path
import shutil, sys, subprocess
PROJECT_ROOT = path.dirname(path.abspath(path.dirname(__file__)))
sys.path.insert(0, PROJECT_ROOT)
# run django
from django.core.management import execute_manager
try:
import tests.settings
except ImportError:
import sys
sys.stderr.write(
"Error: Can't find the file 'settings.py' in the directory")
sys.exit(1)
if __name__ == "__main__":
if len(sys.argv) == 1:
sys.argv += ['test'] + list(tests.settings.PROJECT_APPS)
execute_manager(tests.settings)
#!/usr/bin/env python
from django.core.management import execute_manager
try:
import settings # Assumed to be in the same directory.
except ImportError:
import sys
sys.stderr.write(
"Error: Can't find the file 'settings.py' in the directory containing %r. "
"It appears you've customized things.\nYou'll have to run django-admin.py,"
" passing it your settings module.\n" % __file__)
sys.exit(1)
if __name__ == "__main__":
execute_manager(settings, argv=["manage.py", "runserver", "9000"])
#!/usr/bin/env python
import os, sys
os.environ['DJANGO_SETTINGS_MODULE'] = 'test_settings'
current_dirname = os.path.dirname(__file__)
sys.path.insert(0, os.path.join(current_dirname, '..'))
sys.path.insert(0, os.path.join(current_dirname, '../..'))
from django.core.management import execute_manager
try:
import test_settings # Assumed to be in the same directory.
except ImportError:
import sys
sys.stderr.write(
"Error: Can't find the file 'settings.py' in the directory containing %r. It appears you've customized things.\nYou'll have to run django-admin.py, passing it your settings module.\n(If the file settings.py does indeed exist, it's causing an ImportError somehow.)\n"
% __file__)
sys.exit(1)
if __name__ == "__main__":
execute_manager(test_settings)
def main():
execute_manager(settings)
#!/usr/bin/env /opt/python2.7/bin/python
from django.core.management import execute_manager
import imp
try:
imp.find_module(
'settings_production') # Assumed to be in the same directory.
except ImportError:
import sys
sys.stderr.write(
"Error: Can't find the file 'settings.py' in the directory containing %r. It appears you've customized things.\nYou'll have to run django-admin.py, passing it your settings module.\n"
% __file__)
sys.exit(1)
import settings_production
if __name__ == "__main__":
execute_manager(settings_production)
#!/usr/bin/python
import os, sys
os.environ['DJANGO_SETTINGS_MODULE'] = "levels.settings"
import django
from django.core.management import execute_manager
import levels.settings # Assumed to be in the same directory.
if __name__ == "__main__":
execute_manager(levels.settings)
def start_server(run_browser, interface=None):
pid_path = os.path.join(settings.STATE_ROOT, "server.pid")
if os.path.exists(pid_path):
server_pid = int(open(pid_path).read())
pid_found = False
try:
os.kill(server_pid, 0)
pid_found = True
except OSError:
pid_found = False
if pid_found:
sys.stderr.write("The server is already running.\n")
sys.exit(1)
else:
os.unlink(pid_path)
if settings.USERDIR_ROOT:
setup_userdir()
childpid = os.fork()
if childpid == 0:
os.setsid()
log_fn = os.path.join(settings.STATE_ROOT, "server.log")
try:
log_fd = os.open(log_fn, os.O_WRONLY | os.O_APPEND | os.O_CREAT)
except OSError:
log_fd = -1
if log_fd < 0:
sys.stderr.write("Could not open log file; logging to stdout.\n")
else:
os.dup2(log_fd, 1)
os.dup2(log_fd, 2)
os.close(0)
manager_args = ["janitor", "runserver", "--noreload"]
if interface:
manager_args.append(interface)
execute_manager(settings, manager_args)
else:
time.sleep(1)
pid_file = open(pid_path, "w")
pid_file.write(str(childpid))
pid_file.close()
if run_browser:
if interface:
if interface.find(":") != -1:
(ipaddr, port) = interface.split(":")
if ipaddr == "0.0.0.0":
interface = "127.0.0.1:" + port
app_url = "http://%s/" % interface
else:
app_url = "http://127.0.0.1:8000/"
sys.stdout.write("Waiting for the server to start...\n")
time.sleep(10)
sys.stdout.write("Starting a web browser.\n")
os.execlp("xdg-open", "xdg-open", app_url)
else:
sys.exit(0)
#!/usr/bin/env python
import sys
import os.path as op
def apath(x):
import os
return os.path.abspath(os.path.join(os.path.dirname(__file__),x))
sys.path.insert(0,apath('..'))
sys.path.insert(0,apath('../../'))
from django.core.management import execute_manager
import imp
try:
imp.find_module('settings') # Assumed to be in the same directory.
except ImportError:
import sys
sys.stderr.write("Error: Can't find the file 'settings.py' in the directory containing %r. It appears you've customized things.\nYou'll have to run django-admin.py, passing it your settings module.\n" % __file__)
sys.exit(1)
import webscanner.settings
if __name__ == "__main__":
execute_manager(webscanner.settings)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import common.startup
from django.core.management import execute_manager
from web import settings
from common.terminal import welcomes
# Imports Django settings, displays a welcome message, and launches the development server.
if __name__ == '__main__':
welcomes.web()
execute_manager(settings)
#!/usr/bin/python2
import sys
from tupa.dia2django import luoMallienRungot
from django.core.management import execute_manager
#try:
import settings #
import legacySettings # Legacy settings for exporting an legacy db
#except ImportError:
#import sys
# sys.stderr.write("Error: Can't find the file 'settings.py' in the directory containing %r. It appears you've customized things.\nYou'll have to run django-admin.py, passing it your settings module.\n(If the file settings.py does indeed exist, it's causing an ImportError somehow.)\n" % __file__)
# sys.exit(1)
if __name__ == "__main__":
set = settings
if len(sys.argv):
if sys.argv[1] == 'dumpdata':
set = legacySettings
execute_manager(set)
def main():
"""Main entry point"""
(options, args) = parseOptions()
# What do we want to do ?
if options.shell:
Shell().loop()
if options.web:
execute_manager(settings, argv=[__file__, "runserver"])
exit(0)
if options.doc and options.gui:
print "You must choose doc *or* gui, but not both ! (see --help)"
exit(1)
if options.doc:
type = "doc"
elif options.gui:
type = "gui"
else:
print "You must choose either doc (-d) or gui (-g)"
exit(1)
if options.filename and not options.type:
print "Type must be defined for page generation (see --help)"
exit(1)
elif not options.filename and options.type:
print "Filename must be defined for page generation (see --help)"
exit(1)
elif options.filename and options.type:
# Check file
if not checkFile(options.filename):
exit(1)
# Choose correct type
if options.type == "po":
print "Creating PO page"
file(options.filename,
"w").write(bookingPage(type).encode("UTF-8"))
elif options.type == "translator":
print "Creating Translator page"
file(options.filename,
"w").write(translatorsPage(type).encode("UTF-8"))
file(options.filename[:-3] + "csv", "w").write(
translatorsPage(type, format="csv").encode("UTF-8"))
elif options.type == "stat":
print "Creating statistics page"
file(options.filename, "w").write(statsPage(type).encode("UTF-8"))
else:
print "Ouha. Something goes wrong, type should have be correctly defined here !!!"
exit(1)
elif options.update:
print "Update from SVN is not yet implemented"
elif options.sync:
sync(type=type)
elif options.poStat:
if options.pologyXml:
poStat(readPologyXmlStat(options.pologyXml), type=type)
else:
print "pology XML path must be defined for this action"
exit(1)
elif options.errorsStat:
if options.pologyXml:
for sieve in SIEVES.keys():
createPologyXMLStat(options.pologyXml, sieve=sieve, type=type)
else:
print "pology XML path must be defined for this action"
exit(1)
elif options.move:
path = abspath(options.move)
if not isdir(path):
print "%s is not a directory" % options.move
exit(1)
movePos(path, type=type)
else:
print "Use --help for help"
exit(1)
from django.core.management import execute_manager
import imp
try:
imp.find_module('live_settings')
except ImportError:
import sys
sys.stderr.write(
"Error: Can't find the file 'live_settings.py' in the directory containing %r. It appears you've customized things.\nYou'll have to run django-admin.py, passing it your settings module.\n"
% __file__)
sys.exit(1)
import live_settings
if __name__ == "__main__":
execute_manager(live_settings)
import os
import sys
SETTINGSMODULE = os.environ.get('DJANGO_SETTINGS_MODULE', None) or 'settings'
sys.path.append(
os.path.abspath(
os.path.join(os.path.realpath(os.path.dirname(__file__)),
os.path.pardir)))
mpaths = SETTINGSMODULE.rsplit('.', 1)
mpath = mpaths[0]
mfrom = [mpaths[1]] if len(mpaths) > 1 else []
modobj = None
try:
modobj = __import__(SETTINGSMODULE, fromlist=mfrom)
except ImportError, e:
import sys
sys.stderr.write(str(e))
sys.stderr.write("""
Error: Can't find the file 'settings.py' in the directory containing %r
It appears you've customized things.
You'll have to run django-admin.py, passing it your settings module.
""" % __file__)
sys.exit(1)
if __name__ == "__main__":
execute_manager(modobj)
#!/usr/bin/env python
from django.core.management import execute_manager
import settings_devel
if __name__ == "__main__":
execute_manager(settings_devel)
environ[
"DJANGO_SETTINGS_MODULE"] = "portal.plugins.gnmpagerduty.tests.django_test_settings"
environ[
"CI"] = "True" #simulate a CI environment even if we're not in one, this will stop trying to import portal-specific stuff
#which breaks the tests
from django.core.management import execute_manager
import django.test
import unittest
from mock import patch, MagicMock
import os.path
import portal.plugins.gnmpagerduty.tests.django_test_settings as django_test_settings
if os.path.exists(django_test_settings.DATABASES['default']['NAME']):
unlink(django_test_settings.DATABASES['default']['NAME'])
execute_manager(django_test_settings, ['manage.py', 'syncdb', "--noinput"])
execute_manager(django_test_settings, ['manage.py', 'migrate', "--noinput"])
class TestViews(django.test.TestCase):
class MockObject(object):
"""
fakes a .__dict__() method on something that is already a dict
"""
def __init__(self, obj):
self.obj = obj
@property
def __dict__(self):
return self.obj
#------------------------------------------------------------------------------
# main
st = L2VisionSniffer.SnifferThread()
gt = L2VisionGrapher.GrapherThread()
try:
if len(sys.argv) == 1:
port = 8000
elif len(sys.argv) == 2:
port = int(sys.argv[1])
else:
print "Usage: python L2Vision.py [portnumber]"
sys.exit(1)
print "L2 Vision %s" % L2VisionModel._version
print "Starting UDP sniffer"
st.start()
print "Starting grapher"
gt.start()
execute_manager(settings,
["django", "runserver", "--noreload",
"0.0.0.0:%d" % port])
finally:
print "Shutting down."
st.running = False
gt.running = False
#!/usr/bin/python -u
import sys, os, getpass
os.environ['DJANGO_SETTINGS_MODULE'] = 'gmail.settings'
import gmail.settings as settings
if not os.path.isdir(settings.MAIL_STORE):
print "NOTICE: creating directory for local storage at:"
print " '%s'" % settings.MAIL_STORE
os.mkdir(settings.MAIL_STORE)
if not os.path.isfile(settings.DATABASE_NAME):
print "NOTICE: creating local storage state database"
print " '%s'" % settings.DATABASE_NAME
from django.core.management import execute_manager
execute_manager(settings, [sys.argv[0], 'syncdb'])
from gmail.sync import lib
from optparse import OptionParser
usage = """
%prog [options] [email]
If you don't provide an email address and only
one account exists, it will be used; otherwise
you will be prompted to choose among the existing
or create one. If you provide an email which has
no related account information, you will be
asked to create a new one.
"""
parser = OptionParser(usage=usage)
#parser.add_option("-f", "--file", dest="filename",
#!/usr/bin/env python
from django.core.management import execute_manager
try:
import localsettings # Assumed to be in the same directory.
except ImportError:
import sys
sys.stderr.write(
"Error: Can't find the file 'localsettings.py' in the directory containing %r. It appears you've customized things.\nYou'll have to run django-admin.py, passing it your settings module.\n(If the file settings.py does indeed exist, it's causing an ImportError somehow.)\n"
% __file__)
sys.exit(1)
if __name__ == "__main__":
execute_manager(localsettings)
import os
from djangoconfig import setup_environment
try:
setup_environment(__file__)
except KeyboardInterrupt:
print ""
print "Exiting script."
sys.exit(0)
import settings
from django.core import management
if __name__ == "__main__":
management.execute_manager(settings)
########NEW FILE########
__FILENAME__ = models
from django.db import models
class FlyingCircus(models.Model):
name = models.CharField(max_length=100)
description = models.TextField()
def __unicode__(self):
return self.name
########NEW FILE########
def main():
"""Command-line interface"""
if len(sys.argv) == 2 and sys.argv[1] == 'runserver':
sys.argv.append(settings.DEV_SERVER_ADDR)
execute_manager(settings)