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