def main(argv):
"""Runs the development application server."""
args, option_dict = ParseArguments(argv)
if len(args) != 1:
print >> sys.stderr, 'Invalid arguments'
PrintUsageExit(1)
root_path = args[0]
log_level = option_dict[ARG_LOG_LEVEL]
port = option_dict[ARG_PORT]
datastore_path = option_dict[ARG_DATASTORE_PATH]
login_url = option_dict[ARG_LOGIN_URL]
template_dir = option_dict[ARG_TEMPLATE_DIR]
serve_address = option_dict[ARG_ADDRESS]
require_indexes = option_dict[ARG_REQUIRE_INDEXES]
logging.basicConfig(
level=log_level,
format='%(levelname)-8s %(asctime)s %(filename)s] %(message)s')
config = None
try:
config, matcher = dev_appserver.LoadAppConfig(root_path, {})
except yaml_errors.EventListenerError, e:
logging.error('Fatal error when loading application configuration:\n' +
str(e))
return 1
def LoadAppengineEnvironment():
"""Loads the appengine environment.
Returns:
This function has no return value, but it sets the following parameters on
this package:
- appid: The name of the application
- have_appserver: Boolean parameter which is True if the code is being run
from within the appserver environment.
"""
global appid, have_appserver
# Detect if we are running under an appserver.
have_appserver = False
stub = apiproxy_stub_map.apiproxy.GetStub("datastore_v3")
if stub:
have_appserver = True
# Load the application identifier.
if have_appserver:
appid = os.environ.get("APPLICATION_ID", "unknown")
else:
# Running as manage.py script, read from config file.
try:
from google.appengine.tools import dev_appserver
appconfig, unused_matcher = dev_appserver.LoadAppConfig(
PARENT_DIR, {})
appid = appconfig.application
except ImportError:
# Something went wrong.
appid = "unknown"
logging.debug("Loading application '%s' %s an appserver" %
(appid, have_appserver and "with" or "without"))
def LoadAppengineEnvironment():
"""Loads the appengine environment.
Returns:
This function has no return value, but it sets the following parameters on
this package:
- appid: The name of the application.
- have_appserver: Boolean parameter which is True if the code is being run
from within the appserver environment.
"""
global appid, have_appserver
from google.appengine.api import yaml_errors
from google.appengine.api import apiproxy_stub_map
# Detect if we are running under an appserver.
have_appserver = False
stub = apiproxy_stub_map.apiproxy.GetStub("datastore_v3")
if stub:
have_appserver = True
# Load the application identifier.
if have_appserver:
appid = os.environ.get("APPLICATION_ID", "unknown")
else:
# Running as manage.py script, read from config file.
try:
from google.appengine.tools import dev_appserver
appconfig, unused_matcher = dev_appserver.LoadAppConfig(
PARENT_DIR, {})
appid = appconfig.application
except (ImportError, yaml_errors.EventListenerYAMLError), e:
logging.warn("Could not read the Application ID from app.yaml. "
"This may break things in unusual ways!")
# Something went wrong.
appid = "unknown"
def LoadAppengineEnvironment():
"""Loads the appengine environment.
Returns:
This function has no return value, but it sets the following parameters on
this package:
- appid: The name of the application as read from the config file.
- appconfig: The appserver configuration dictionary for the application, as
read from the config file.
- have_appserver: Boolean parameter which is True if the code is being run
from within the appserver environment.
"""
global appid, appconfig, have_appserver
# Load the application configuration.
try:
from google.appengine.tools import dev_appserver
appconfig, unused_matcher = dev_appserver.LoadAppConfig(".", {})
appid = appconfig.application
except ImportError:
# Running under the real appserver.
appconfig = {}
appid = "unknown"
# Detect if we are running under an appserver.
have_appserver = False
stub = apiproxy_stub_map.apiproxy.GetStub("datastore_v3")
if stub:
have_appserver = True
logging.debug("Loading application '%s' %s an appserver" %
(appid, have_appserver and "with" or "without"))
def setup_environ():
# lib
sys.path.insert(0, os.path.join(ROOT_PATH, 'lib'))
# SDK (this will be simpler if SDK is in the codebase)
sdk_path = None
for path in os.environ.get('PATH').split(os.pathsep):
if 'dev_appserver.py' in os.listdir(path):
test_path = os.path.join(path, 'dev_appserver.py')
sdk_path = os.path.dirname(
os.readlink(test_path) if os.path.islink(test_path
) else test_path)
break
if not sdk_path:
logging.critical("Can't find sdk_path")
sys.exit(1)
sys.path.insert(0, sdk_path)
# Use dev_appserver to set up the python path
from dev_appserver import fix_sys_path
fix_sys_path()
from google.appengine.tools import dev_appserver as tools_dev_appserver
from google.appengine import dist
# Parse `app.yaml`
appinfo, url_matcher, from_cache = tools_dev_appserver.LoadAppConfig(
ROOT_PATH, {}, default_partition='dev')
app_id = appinfo.application
# Useful for later scripts
os.environ['APPLICATION_ID'] = app_id
os.environ['APPLICATION_VERSION'] = appinfo.version
# Third party libraries on the path
if appinfo.libraries:
for library in appinfo.libraries:
try:
dist.use_library(library.name, library.version)
except ValueError, e:
if library.name == 'django' and library.version == '1.4':
# Work around an SDK issue
logging.warn(
'django 1.4 not recognised by dist, fixing python path'
)
sys.path.insert(
0, os.path.join(sdk_path, 'lib', 'django-1.4'))
else:
logging.warn('Unsupported library:\n%s\n' % e)
# Extra setup for django
if library.name == 'django':
try:
import settings
from django.core.management import setup_environ
setup_environ(settings, original_settings_path='settings')
except ImportError:
logging.error("Could not import django settings")
def main(argv):
"""Runs the development application server."""
args, option_dict = ParseArguments(argv)
if len(args) != 1:
print >>sys.stderr, 'Invalid arguments'
PrintUsageExit(1)
root_path = args[0]
if '_DEFAULT_ENV_AUTH_DOMAIN' in option_dict:
auth_domain = option_dict['_DEFAULT_ENV_AUTH_DOMAIN']
dev_appserver.DEFAULT_ENV['AUTH_DOMAIN'] = auth_domain
if '_ENABLE_LOGGING' in option_dict:
enable_logging = option_dict['_ENABLE_LOGGING']
dev_appserver.HardenedModulesHook.ENABLE_LOGGING = enable_logging
log_level = option_dict[ARG_LOG_LEVEL]
option_dict['root_path'] = os.path.realpath(root_path)
logging.getLogger().setLevel(log_level)
default_partition = option_dict[ARG_DEFAULT_PARTITION]
appinfo = None
try:
appinfo, _, _ = dev_appserver.LoadAppConfig(
root_path, {}, default_partition=default_partition)
except yaml_errors.EventListenerError, e:
logging.error('Fatal error when loading application configuration:\n%s', e)
return 1
def main():
p = optparse.OptionParser(usage="%prog [options]")
default = "/tmp/dev_appserver.datastore"
p.add_option(
"--datastore_path",
default=default,
help=
("Path to datastore file. This must match the value used for "
"the same option when running dev_appserver.py if you want to view the data. "
"Default: %s" % default))
default = "/tmp/dev_appserver.datastore.history"
p.add_option(
"--history_path",
default=default,
help=
("Path to datastore history file. This doesn't need to match the one you use for "
"dev_appserver.py. Default: %s" % default))
default = "/usr/local/google_appengine"
p.add_option("--google_path",
default=default,
help=("Path to google module directory. Default: %s" %
default))
(options, args) = p.parse_args()
if not os.path.exists(options.google_path):
p.error(
"Could not find google module path at %s. You'll need to specify the path"
% options.google_path)
groot = options.google_path
sys.path.append(groot)
sys.path.append(os.path.join(groot, "lib/django"))
sys.path.append(os.path.join(groot, "lib/webob"))
sys.path.append(os.path.join(groot, "lib/yaml/lib"))
from google.appengine.tools import dev_appserver
from gblog import models
from tests import datasets
config, explicit_matcher = dev_appserver.LoadAppConfig(
os.path.dirname(__file__), {})
dev_appserver.SetupStubs(
config.application,
clear_datastore=False, # just removes the files when True
datastore_path=options.datastore_path,
history_path=options.history_path,
login_url=None)
datafixture = GoogleDatastoreFixture(env=models, style=NamedDataStyle())
data = datafixture.data(datasets.CommentData, datasets.EntryData)
data.setup()
print "Data loaded into datastore %s" % (options.datastore_path
or "[default]")
def main(argv):
"""Runs the development application server."""
args, option_dict = ParseArguments(argv)
if len(args) != 1:
print >> sys.stderr, 'Invalid arguments'
PrintUsageExit(1)
version_tuple = tuple(sys.version_info[:2])
if ARG_MULTIPROCESS not in option_dict and WARN_ABOUT_PYTHON_VERSION:
if version_tuple < PRODUCTION_VERSION:
sys.stderr.write(
'Warning: You are using a Python runtime (%d.%d) that '
'is older than the production runtime environment '
'(%d.%d). Your application may be dependent on Python '
'behaviors that have changed and may not work correctly '
'when deployed to production.\n' %
(version_tuple[0], version_tuple[1], PRODUCTION_VERSION[0],
PRODUCTION_VERSION[1]))
if version_tuple > PRODUCTION_VERSION:
sys.stderr.write(
'Warning: You are using a Python runtime (%d.%d) that '
'is more recent than the production runtime environment '
'(%d.%d). Your application may use features that are not '
'available in the production environment and may not work '
'correctly when deployed to production.\n' %
(version_tuple[0], version_tuple[1], PRODUCTION_VERSION[0],
PRODUCTION_VERSION[1]))
root_path = args[0]
if '_DEFAULT_ENV_AUTH_DOMAIN' in option_dict:
auth_domain = option_dict['_DEFAULT_ENV_AUTH_DOMAIN']
dev_appserver.DEFAULT_ENV['AUTH_DOMAIN'] = auth_domain
if '_ENABLE_LOGGING' in option_dict:
enable_logging = option_dict['_ENABLE_LOGGING']
dev_appserver.HardenedModulesHook.ENABLE_LOGGING = enable_logging
log_level = option_dict[ARG_LOG_LEVEL]
option_dict['root_path'] = os.path.realpath(root_path)
logging.getLogger().setLevel(log_level)
appinfo = None
try:
appinfo, matcher = dev_appserver.LoadAppConfig(root_path, {})
except yaml_errors.EventListenerError, e:
logging.error(
'Fatal error when loading application configuration:\n%s', e)
return 1
def get_appid():
from google.appengine.api import apiproxy_stub_map
have_appserver = bool(apiproxy_stub_map.apiproxy.GetStub('datastore_v3'))
if have_appserver:
appid = os.environ.get('APPLICATION_ID')
else:
try:
from google.appengine.tools import dev_appserver
from kay import PROJECT_DIR
from google.appengine.tools.dev_appserver import GetVersionObject
version = GetVersionObject()
if version and version.get('timestamp', 0) >= 1318895182:
# if GAE 1.6 or high
appconfig, unused, cache = dev_appserver.LoadAppConfig(
PROJECT_DIR, {})
else:
appconfig, unused = dev_appserver.LoadAppConfig(
PROJECT_DIR, {})
appid = appconfig.application
except ImportError:
appid = None
return appid
def get_appid():
from google.appengine.api import apiproxy_stub_map
have_appserver = bool(apiproxy_stub_map.apiproxy.GetStub('datastore_v3'))
if have_appserver:
appid = os.environ.get('APPLICATION_ID')
else:
try:
from google.appengine.tools import dev_appserver
appconfig, unused, unused = dev_appserver.LoadAppConfig(
os.path.dirname(os.path.abspath(__file__)), {})
appid = appconfig.application
except ImportError:
appid = None
return appid
def get_versionid():
from google.appengine.api import apiproxy_stub_map
have_appserver = bool(apiproxy_stub_map.apiproxy.GetStub('datastore_v3'))
if have_appserver:
versionid = os.environ.get('CURRENT_VERSION_ID')
else:
try:
from google.appengine.tools import dev_appserver
from kay import PROJECT_DIR
appconfig, unused = dev_appserver.LoadAppConfig(PROJECT_DIR, {})
versionid = appconfig.version
except ImportError:
versionid = None
return versionid
def main(argv):
"""Runs the development application server."""
args, option_dict = ParseArguments(argv)
if len(args) != 1:
print >> sys.stderr, 'Invalid arguments'
PrintUsageExit(1)
root_path = args[0]
for suffix in ('yaml', 'yml'):
path = os.path.join(root_path, 'app.%s' % suffix)
if os.path.exists(path):
api_version = SetPaths(path)
break
else:
logging.error("Application configuration file not found in %s" %
root_path)
return 1
SetGlobals()
dev_appserver.API_VERSION = api_version
if '_DEFAULT_ENV_AUTH_DOMAIN' in option_dict:
auth_domain = option_dict['_DEFAULT_ENV_AUTH_DOMAIN']
dev_appserver.DEFAULT_ENV['AUTH_DOMAIN'] = auth_domain
if '_ENABLE_LOGGING' in option_dict:
enable_logging = option_dict['_ENABLE_LOGGING']
dev_appserver.HardenedModulesHook.ENABLE_LOGGING = enable_logging
log_level = option_dict[ARG_LOG_LEVEL]
port = option_dict[ARG_PORT]
datastore_path = option_dict[ARG_DATASTORE_PATH]
login_url = option_dict[ARG_LOGIN_URL]
template_dir = option_dict[ARG_TEMPLATE_DIR]
serve_address = option_dict[ARG_ADDRESS]
require_indexes = option_dict[ARG_REQUIRE_INDEXES]
allow_skipped_files = option_dict[ARG_ALLOW_SKIPPED_FILES]
static_caching = option_dict[ARG_STATIC_CACHING]
logging.basicConfig(
level=log_level,
format='%(levelname)-8s %(asctime)s %(filename)s] %(message)s')
config = None
try:
config, matcher = dev_appserver.LoadAppConfig(root_path, {})
except yaml_errors.EventListenerError, e:
logging.error('Fatal error when loading application configuration:\n' +
str(e))
return 1
def setup_appserver():
"""
Set up appserver stubs as in dev_appserver.
"""
# these require setup_path to have been run
from google.appengine.tools import dev_appserver
from google.appengine.tools.dev_appserver_main import *
option_dict = DEFAULT_ARGS.copy()
option_dict[ARG_CLEAR_DATASTORE] = True
# path to app:
root_path = os.path.join(os.path.dirname(__file__), '..')
(config, matcher) = dev_appserver.LoadAppConfig(root_path, {})
# commented out stuff here that checked for SDK updates
dev_appserver.SetupStubs(config.application, **option_dict)
def setup():
from google.appengine.tools import dev_appserver
from google.appengine.tools.dev_appserver_main import (
ARG_CLEAR_DATASTORE,
ARG_LOG_LEVEL,
DEFAULT_ARGS,
logging,
)
option_dict = DEFAULT_ARGS.copy()
option_dict[ARG_CLEAR_DATASTORE] = True
logging.basicConfig(
level=option_dict[ARG_LOG_LEVEL],
format="%(levelname)-8s %(asctime)s %(filename)s] %(message)s")
config, matcher = dev_appserver.LoadAppConfig(root_path, {})
dev_appserver.SetupStubs(config.application, **option_dict)
def load_appengine_environment():
""" Loads the appengine environment. """
global APP_ID
from google.appengine.api import yaml_errors
from google.appengine.api import apiproxy_stub_map
stub = apiproxy_stub_map.apiproxy.GetStub("datastore_v3")
# Detect if we are running under an appserver.
try:
from google.appengine.tools import dev_appserver
appconfig, unused_matcher, options = dev_appserver.LoadAppConfig(
project_dir, {})
APP_ID = appconfig.application
except (ImportError, yaml_errors.EventListenerYAMLError), e:
logging.warn("Could not read the Application ID from app.yaml. "
"This may break things in unusual ways!")
# Something went wrong.
APP_ID = "unknown"
def main(argv):
"""Runs the development application server."""
args, option_dict = ParseArguments(argv)
if len(args) != 1:
print >>sys.stderr, 'Invalid arguments'
PrintUsageExit(1)
root_path = args[0]
if '_DEFAULT_ENV_AUTH_DOMAIN' in option_dict:
auth_domain = option_dict['_DEFAULT_ENV_AUTH_DOMAIN']
dev_appserver.DEFAULT_ENV['AUTH_DOMAIN'] = auth_domain
if '_ENABLE_LOGGING' in option_dict:
enable_logging = option_dict['_ENABLE_LOGGING']
dev_appserver.HardenedModulesHook.ENABLE_LOGGING = enable_logging
log_level = option_dict[ARG_LOG_LEVEL]
port = option_dict[ARG_PORT]
login_url = option_dict[ARG_LOGIN_URL]
template_dir = option_dict[ARG_TEMPLATE_DIR]
serve_address = option_dict[ARG_ADDRESS]
require_indexes = option_dict[ARG_REQUIRE_INDEXES]
allow_skipped_files = option_dict[ARG_ALLOW_SKIPPED_FILES]
static_caching = option_dict[ARG_STATIC_CACHING]
skip_sdk_update_check = option_dict[ARG_SKIP_SDK_UPDATE_CHECK]
option_dict['root_path'] = os.path.realpath(root_path)
logging.getLogger().setLevel(log_level)
config = None
try:
config, matcher = dev_appserver.LoadAppConfig(root_path, {})
except yaml_errors.EventListenerError, e:
logging.error('Fatal error when loading application configuration:\n' +
str(e))
return 1
def startup_appengine(gae_path='/usr/local/google_appengine',
clear_datastore=False):
# set up app engine paths
sys.path.append(gae_path)
sys.path.append(os.path.join(gae_path, "lib/django"))
sys.path.append(os.path.join(gae_path, "lib/webob"))
sys.path.append(os.path.join(gae_path, "lib/yaml/lib"))
sys.path.append(os.path.join(gae_path, "lib/antlr3"))
# set up dev app server
from google.appengine.tools import dev_appserver
config, explicit_matcher = dev_appserver.LoadAppConfig(chirp_root, {})
from appengine_django.db.base import get_datastore_paths
datastore_path, history_path = get_datastore_paths()
if clear_datastore:
print "clearing datastore"
dev_appserver.SetupStubs(config.application,
clear_datastore=clear_datastore,
datastore_path=datastore_path,
history_path=history_path,
login_url=None)
def setup_environ():
"""
This func will import the required modules and set up enough of an
appengine environment to let some of our management commands run inside the
SDK sandbox
"""
# add the lib directory to the sytem path
sys.path.insert(0, os.path.join(ROOT_PATH, 'vendor'))
# Find the path on which the SDK is installed
sdk_path = None
for path in os.environ.get('PATH').split(os.pathsep):
if not os.path.exists(path):
continue
if 'dev_appserver.py' in os.listdir(path):
test_path = os.path.join(path, 'dev_appserver.py')
sdk_path = os.path.dirname(os.readlink(test_path) if os.path.islink(test_path) else test_path)
break
# crap out if we can't find the SDK
if not sdk_path:
sys.stderr.write("Fatal: Can't find sdk_path")
sys.exit(1)
# add the SDK path to the system path
sys.path.insert(0, sdk_path)
# Use dev_appserver to set up the python path
from dev_appserver import fix_sys_path
fix_sys_path()
from google.appengine.tools import dev_appserver as tools_dev_appserver
from google.appengine import dist
# Parse `app.yaml`
appinfo, url_matcher, from_cache = tools_dev_appserver.LoadAppConfig(
ROOT_PATH, {}, default_partition='dev')
app_id = appinfo.application
# Useful for later scripts
os.environ['APPLICATION_ID'] = app_id
os.environ['APPLICATION_VERSION'] = appinfo.version
# Add third-party libs to the system path
if appinfo.libraries:
for library in appinfo.libraries:
try:
dist.use_library(library.name, library.version)
except ValueError, e:
if library.name == 'django' and library.version == '1.5':
# Work around an SDK issue
# print 'Warning: django 1.5 not recognised by dist, fixing python path'
sys.path.insert(0, os.path.join(sdk_path, 'lib', 'django-1.5'))
elif library.name == 'webapp2' and library.version == '2.5.2':
sys.path.insert(0, os.path.join(sdk_path, 'lib', 'webapp2-2.5.2'))
elif library.name == 'webob' and library.version == '1.2.3':
sys.path.insert(0, os.path.join(sdk_path, 'lib', 'webob-1.2.3'))
elif library.name == 'PIL':
try:
from PIL import Image
except ImportError:
print 'Warning: Make sure you have PIL installed locally'
else:
print 'Warning: Unsupported library:\n%s\n' % e
# Extra setup for django
if library.name == 'django':
try:
from config import settings
from django.core.management import setup_environ
setup_environ(settings)
except ImportError:
sys.stderr.write("\nWarning! Could not import django settings")
import os
from google.appengine.api.app_identity import get_application_id
from google.appengine.api import apiproxy_stub_map
server_software = os.environ.get('SERVER_SOFTWARE', '')
have_appserver = bool(apiproxy_stub_map.apiproxy.GetStub('datastore_v3'))
appid = None
if have_appserver:
appid = get_application_id()
else:
try:
project_dir = os.path.dirname(os.path.abspath(os.path.dirname(os.path.dirname(__file__))))
from google.appengine.tools import dev_appserver
appconfig, matcher, from_cache = dev_appserver.LoadAppConfig(project_dir, {})
appid = appconfig.application
except ImportError:
appid = None
#: ``True`` if running in the dev server, ``False`` otherwise.
on_development_server = bool(have_appserver and (not server_software or server_software.lower().startswith('devel')))
#: ``True`` if running on a google server, ``False`` otherwise.
on_server = bool(have_appserver and appid and server_software and not on_development_server)
#: ``True`` if running on a google server and the application ID ends in ``-int``, ``False`` otherwise.
on_integration_server = on_server and appid.lower().endswith('-int')
#: ``True`` if running on a google server and the application ID does not end in ``-int``, ``False`` otherwise.
on_production_server = on_server and not on_integration_server
import os
from google.appengine.api import apiproxy_stub_map
from google.appengine.api.app_identity import get_application_id
have_appserver = bool(apiproxy_stub_map.apiproxy.GetStub('datastore_v3'))
if have_appserver:
appid = get_application_id()
else:
try:
from google.appengine.tools import dev_appserver
from .boot import PROJECT_DIR
appconfig = dev_appserver.LoadAppConfig(PROJECT_DIR, {},
default_partition='dev')[0]
appid = appconfig.application.split('~', 1)[-1]
#appid = 'woyingng'
except ImportError, e:
raise Exception("Could not get appid. Is your app.yaml file missing? "
"Error was: %s" % e)
on_production_server = have_appserver and \
not os.environ.get('SERVER_SOFTWARE', '').lower().startswith('devel')
from google.appengine.api import apiproxy_stub_map
import os, sys
have_appserver = bool(apiproxy_stub_map.apiproxy.GetStub('datastore_v3'))
if have_appserver:
appid = os.environ.get('APPLICATION_ID')
else:
try:
from google.appengine.tools import dev_appserver
from aecmd import PROJECT_DIR
appconfig, unused = dev_appserver.LoadAppConfig(PROJECT_DIR, {})
appid = appconfig.application
except ImportError:
appid = None
on_production_server = not (os.environ.get('SERVER_SOFTWARE',
'').lower().startswith('devel')
or sys.argv[0].endswith('manage.py'))
from google.appengine.api import apiproxy_stub_map
import os
have_appserver = bool(apiproxy_stub_map.apiproxy.GetStub('datastore_v3'))
if have_appserver:
appid = os.environ.get('APPLICATION_ID')
else:
try:
from google.appengine.tools import dev_appserver
from .boot import PROJECT_DIR
try:
appconfig, unused = dev_appserver.LoadAppConfig(PROJECT_DIR, {})
except ValueError:
# https://bitbucket.org/wkornewald/django-nonrel/issue/13/managepy-test-broken-with-gae-sdk-16
appconfig, unused, from_cache = dev_appserver.LoadAppConfig(
PROJECT_DIR, {})
appid = appconfig.application
except ImportError, e:
raise Exception('Could not get appid. Is your app.yaml file missing? '
'Error was: %s' % e)
on_production_server = have_appserver and \
not os.environ.get('SERVER_SOFTWARE', '').lower().startswith('devel')
from google.appengine.api import apiproxy_stub_map
from google.appengine.api.app_identity import get_application_id
import os
have_appserver = bool(apiproxy_stub_map.apiproxy.GetStub('datastore_v3'))
if have_appserver:
appid = get_application_id()
else:
try:
from google.appengine.tools import dev_appserver
from .boot import PROJECT_DIR
appconfig = dev_appserver.LoadAppConfig(PROJECT_DIR, {})[0]
appid = appconfig.application
except ImportError, e:
raise Exception('Could not get appid. Is your app.yaml file missing? '
'Error was: %s' % e)
on_production_server = have_appserver and \
not os.environ.get('SERVER_SOFTWARE', '').lower().startswith('devel')
