text: import os
  import select
  import sys
  import traceback
  from contextlib import suppress
  
  from django.core.management import BaseCommand, CommandError
  from django.utils.datastructures import OrderedSet
  
  
  class Command(BaseCommand):
      help = (
          "Runs a Python interactive interpreter. Tries to use IPython or "
          "bpython, if one of them is available. Any standard input is executed "
          "as code."
      )
  
      requires_system_checks = False
      shells = ['ipython', 'bpython', 'python']
  
      def add_arguments(self, parser):
          parser.add_argument(
              '--no-startup', action='store_true', dest='no_startup',
              help='When using plain Python, ignore the PYTHONSTARTUP environment variable and ~/.pythonrc.py script.',
          )
          parser.add_argument(
              '-i', '--interface', choices=self.shells, dest='interface',
              help='Specify an interactive interpreter interface. Available options: "ipython", "bpython", and "python"',
          )
          parser.add_argument(
              '-c', '--command', dest='command',
              help='Instead of opening an interactive shell, run a command as Django and exit.',
          )
  
      def ipython(self, options):
          from IPython import start_ipython
          start_ipython(argv=[])
  
      def bpython(self, options):
          import bpython
          bpython.embed()
  
      def python(self, options):
          import code
          # Set up a dictionary to serve as the environment for the shell, so
          # that tab completion works on objects that are imported at runtime.
          imported_objects = {}
          try:  # Try activating rlcompleter, because it's handy.
              import readline
          except ImportError:
              pass
          else:
              # We don't have to wrap the following import in a 'try', because
              # we already know 'readline' was imported successfully.
              import rlcompleter
              readline.set_completer(rlcompleter.Completer(imported_objects).complete)
              # Enable tab completion on systems using libedit (e.g. macOS).
              # These lines are copied from Python's Lib/site.py.
              readline_doc = getattr(readline, '__doc__', '')
              if readline_doc is not None and 'libedit' in readline_doc:
                  readline.parse_and_bind("bind ^I rl_complete")
              else:
                  readline.parse_and_bind("tab:complete")
  
          # We want to honor both $PYTHONSTARTUP and .pythonrc.py, so follow system
          # conventions and get $PYTHONSTARTUP first then .pythonrc.py.
          if not options['no_startup']:
              for pythonrc in OrderedSet([os.environ.get("PYTHONSTARTUP"), os.path.expanduser('~/.pythonrc.py')]):
                  if not pythonrc:
                      continue
                  if not os.path.isfile(pythonrc):
                      continue
                  with open(pythonrc) as handle:
                      pythonrc_code = handle.read()
                  # Match the behavior of the cpython shell where an error in
                  # PYTHONSTARTUP prints an exception and continues.
                  try:
                      exec(compile(pythonrc_code, pythonrc, 'exec'), imported_objects)
                  except Exception:
                      traceback.print_exc()
  
          code.interact(local=imported_objects)
  
      def handle(self, **options):
          # Execute the command and exit.
          if options['command']:
              exec(options['command'])
              return
  
          # Execute stdin if it has anything to read and exit.
          # Not supported on Windows due to select.select() limitations.
          if sys.platform != 'win32' and select.select([sys.stdin], [], [], 0)[0]:
              exec(sys.stdin.read())
              return
  
          available_shells = [options['interface']] if options['interface'] else self.shells
  
          for shell in available_shells:
              with suppress(ImportError):
                  return getattr(self, shell)(options)
          raise CommandError("Couldn't import {} interface.".format(shell))
  