def _run_autocomplete(self):
util = ManagementUtility(argv=sys.argv)
try:
util.autocomplete()
except SystemExit:
pass
return self.output.getvalue().strip().split('\n')
def _run_autocomplete(self):
util = ManagementUtility(argv=sys.argv)
try:
util.autocomplete()
except SystemExit:
pass
return self.output.getvalue().strip().split("\n")
def _run_autocomplete(self):
util = ManagementUtility(argv=sys.argv)
with captured_stdout() as stdout:
try:
util.autocomplete()
except SystemExit:
pass
return stdout.getvalue().strip().split('\n')
def _run_autocomplete(self):
util = ManagementUtility(argv=sys.argv)
with captured_stdout() as stdout:
try:
util.autocomplete()
except SystemExit:
pass
return stdout.getvalue().strip().split('\n')
def main():
"""
django-develop CLI entry point.
"""
# XXX: Bail out early if being invoked for autocompletion.
utility = ManagementUtility()
utility.autocomplete()
if not utils.is_inside_virtual_env():
_fail('Run django-develop inside a virtualenv')
dd = _get_DjangoDevelop()
if not dd.instance_path.exists():
_fail('django-develop not configured, try "django-develop-config"')
else:
# Set up and hand over to Django
dd.activate_dev_settings()
utility.execute()
def _run_autocomplete(self):
util = ManagementUtility(argv=sys.argv)
with captured_stdout() as stdout:
with suppress(SystemExit):
util.autocomplete()
return stdout.getvalue().strip().split('\n')
def django_init(self):
""" Checks for the required data and initializes the application. """
# manage.py
os.environ.setdefault("DJANGO_SETTINGS_MODULE", SETTINGS)
# django.core.management.execute_from_command_line(argv=ARGS)
"""
A simple method that runs a ManagementUtility.
"""
from django.core.management import ManagementUtility
utility = ManagementUtility(ARGS)
# utility.execute()
"""
Given the command-line arguments, this figures out which subcommand is
being run, creates a parser appropriate to that command, and runs it.
"""
from django.core.management import LaxOptionParser
# For backwards compatibility: get_version() used to be in this module.
from django import get_version
from django.core.management.base import BaseCommand, handle_default_options
# Preprocess options to extract --settings and --pythonpath.
# These options could affect the commands that are available, so they
# must be processed early.
parser = LaxOptionParser(usage="%prog subcommand [options] [args]",
version=get_version(),
option_list=BaseCommand.option_list)
utility.autocomplete()
try:
options, args = parser.parse_args(utility.argv)
handle_default_options(options)
except:
pass # Ignore any option errors at this point.
subcommand = utility.argv[1]
klass = utility.fetch_command(subcommand)
# klass.run_from_argv(utility.argv)
"""
Set up any environment changes requested (e.g., Python path
and Django settings), then run this command. If the
command raises a ``CommandError``, intercept it and print it sensibly
to stderr. If the ``--traceback`` option is present or the raised
``Exception`` is not ``CommandError``, raise it.
"""
from django.core.management.base import CommandError
parser = klass.create_parser(utility.argv[0], utility.argv[1])
options, args = parser.parse_args(utility.argv[2:])
handle_default_options(options)
options = options.__dict__
# klass.execute(*args, **options.__dict__)
"""
Try to execute this command, performing model validation if
needed (as controlled by the attribute
``klass.requires_model_validation``, except if force-skipped).
"""
from django.core.management.base import OutputWrapper
klass.stdout = OutputWrapper(options.get('stdout', sys.stdout))
klass.stderr = OutputWrapper(options.get('stderr', sys.stderr), klass.style.ERROR)
#klass.can_import_settings = True
from django.conf import settings
saved_locale = None
#klass.leave_locale_alone = False
# Only mess with locales if we can assume we have a working
# settings file, because django.utils.translation requires settings
# (The final saying about whether the i18n machinery is active will be
# found in the value of the USE_I18N setting)
#klass.can_import_settings = True
# Switch to US English, because django-admin.py creates database
# content like permissions, and those shouldn't contain any
# translations.
from django.utils import translation
saved_locale = translation.get_language()
translation.activate('en-us')
try:
# Validation is called explicitly each time the server is reloaded.
#klass.requires_model_validation = False
addrport = args[0]
print 'addrport %s' % addrport
args = args[1:]
# klass.handle(addrport='', *args, **options)
import re
from django.core.management.commands.runserver import naiveip_re, DEFAULT_PORT
from django.conf import settings
if not settings.DEBUG and not settings.ALLOWED_HOSTS:
raise CommandError('You must set settings.ALLOWED_HOSTS if DEBUG is False.')
klass.use_ipv6 = options.get('use_ipv6')
if klass.use_ipv6 and not socket.has_ipv6:
raise CommandError('Your Python does not support IPv6.')
if args:
raise CommandError('Usage is runserver %s' % klass.args)
klass._raw_ipv6 = False
if not addrport:
klass.addr = ''
klass.port = DEFAULT_PORT
else:
m = re.match(naiveip_re, addrport)
if m is None:
raise CommandError('"%s" is not a valid port number '
'or address:port pair.' % addrport)
klass.addr, _ipv4, _ipv6, _fqdn, klass.port = m.groups()
if not klass.port.isdigit():
raise CommandError("%r is not a valid port number." % klass.port)
if klass.addr:
if _ipv6:
klass.addr = klass.addr[1:-1]
klass.use_ipv6 = True
klass._raw_ipv6 = True
elif klass.use_ipv6 and not _fqdn:
raise CommandError('"%s" is not a valid IPv6 address.' % klass.addr)
if not klass.addr:
klass.addr = '::1' if klass.use_ipv6 else '127.0.0.1'
klass._raw_ipv6 = bool(klass.use_ipv6)
# klass.run(*args, **options)
"""
Runs the server, using the autoreloader if needed
"""
#from django.utils import autoreload
use_reloader = options.get('use_reloader')
if use_reloader:
# use queue and threading to start httpd
# skip for now
print 'reloader bypassed for Windows service'
pass
# klass.inner_run(*args, **options)
import errno
import socket
from django.utils import six
from django.utils.six.moves import socketserver
from django.core.servers.basehttp import WSGIServer, WSGIRequestHandler
from datetime import datetime
from django.conf import settings
from django.utils import translation
threading = options.get('use_threading')
shutdown_message = options.get('shutdown_message', '')
quit_command = 'CTRL-BREAK' if sys.platform == 'win32' else 'CONTROL-C'
klass.stdout.write("Validating models...\n\n")
klass.validate(display_num_errors=True)
klass.stdout.write((
"%(started_at)s\n"
"Django version %(version)s, using settings %(settings)r\n"
"Starting development server at http://%(addr)s:%(port)s/\n"
"Quit the server with %(quit_command)s.\n"
) % {
"started_at": datetime.now().strftime('%B %d, %Y - %X'),
"version": klass.get_version(),
"settings": settings.SETTINGS_MODULE,
"addr": '[%s]' % klass.addr if klass._raw_ipv6 else klass.addr,
"port": klass.port,
"quit_command": quit_command,
})
# django.core.management.base forces the locale to en-us. We should
# set it up correctly for the first request (particularly important
# in the "--noreload" case).
translation.activate(settings.LANGUAGE_CODE)
try:
handler = klass.get_handler(*args, **options)
# run(addr=klass.addr, port=int(klass.port), wsgi_handler=handler,
# ipv6=klass.use_ipv6, threading=threading)
server_address = (klass.addr, int(klass.port))
if threading:
httpd_cls = type(str('WSGIServer'), (socketserver.ThreadingMixIn, WSGIServer), {})
else:
httpd_cls = WSGIServer
httpd = httpd_cls(server_address, WSGIRequestHandler, ipv6=klass.use_ipv6)
httpd.set_app(handler)
except socket.error as e:
# Use helpful error messages instead of ugly tracebacks.
ERRORS = {
errno.EACCES: "You don't have permission to access that port.",
errno.EADDRINUSE: "That port is already in use.",
errno.EADDRNOTAVAIL: "That IP address can't be assigned-to.",
}
try:
error_text = ERRORS[e.errno]
except KeyError:
error_text = str(e)
klass.stderr.write("Error: %s" % error_text)
# Need to use an OS exit because sys.exit doesn't work in a thread
os._exit(1)
finally:
if saved_locale is not None:
translation.activate(saved_locale)
return httpd
