class_docstr: Magics related to code management (loading, saving, editing, ...).
docstr: Bring up an editor and execute the resulting code.
  
  Usage:
    %edit [options] [args]
  
  %edit runs IPython's editor hook. The default version of this hook is
  set to call the editor specified by your $EDITOR environment variable.
  If this isn't found, it will default to vi under Linux/Unix and to
  notepad under Windows. See the end of this docstring for how to change
  the editor hook.
  
  You can also set the value of this editor via the
  ``TerminalInteractiveShell.editor`` option in your configuration file.
  This is useful if you wish to use a different editor from your typical
  default with IPython (and for Windows users who typically don't set
  environment variables).
  
  This command allows you to conveniently edit multi-line code right in
  your IPython session.
  
  If called without arguments, %edit opens up an empty editor with a
  temporary file and will execute the contents of this file when you
  close it (don't forget to save it!).
  
  
  Options:
  
  -n <number>: open the editor at a specified line number.  By default,
  the IPython editor hook uses the unix syntax 'editor +N filename', but
  you can configure this by providing your own modified hook if your
  favorite editor supports line-number specifications with a different
  syntax.
  
  -p: this will call the editor with the same data as the previous time
  it was used, regardless of how long ago (in your current session) it
  was.
  
  -r: use 'raw' input.  This option only applies to input taken from the
  user's history.  By default, the 'processed' history is used, so that
  magics are loaded in their transformed version to valid Python.  If
  this option is given, the raw input as typed as the command line is
  used instead.  When you exit the editor, it will be executed by
  IPython's own processor.
  
  -x: do not execute the edited code immediately upon exit. This is
  mainly useful if you are editing programs which need to be called with
  command line arguments, which you can then do using %run.
  
  
  Arguments:
  
  If arguments are given, the following possibilities exist:
  
  - If the argument is a filename, IPython will load that into the
    editor. It will execute its contents with execfile() when you exit,
    loading any code in the file into your interactive namespace.
  
  - The arguments are ranges of input history,  e.g. "7 ~1/4-6".
    The syntax is the same as in the %history magic.
  
  - If the argument is a string variable, its contents are loaded
    into the editor. You can thus edit any string which contains
    python code (including the result of previous edits).
  
  - If the argument is the name of an object (other than a string),
    IPython will try to locate the file where it was defined and open the
    editor at the point where it is defined. You can use `%edit function`
    to load an editor exactly at the point where 'function' is defined,
    edit it and have the file be executed automatically.
  
  - If the object is a macro (see %macro for details), this opens up your
    specified editor with a temporary file containing the macro's data.
    Upon exit, the macro is reloaded with the contents of the file.
  
  Note: opening at an exact line is only supported under Unix, and some
  editors (like kedit and gedit up to Gnome 2.8) do not understand the
  '+NUMBER' parameter necessary for this feature. Good editors like
  (X)Emacs, vi, jed, pico and joe all do.
  
  After executing your code, %edit will return as output the code you
  typed in the editor (except when it was an existing file). This way
  you can reload the code in further invocations of %edit as a variable,
  via _<NUMBER> or Out[<NUMBER>], where <NUMBER> is the prompt number of
  the output.
  
  Note that %edit is also available through the alias %ed.
  
  This is an example of creating a simple function inside the editor and
  then modifying it. First, start up the editor::
  
    In [1]: edit
    Editing... done. Executing edited code...
    Out[1]: 'def foo():\n    print "foo() was defined in an editing
    session"\n'
  
  We can then call the function foo()::
  
    In [2]: foo()
    foo() was defined in an editing session
  
  Now we edit foo.  IPython automatically loads the editor with the
  (temporary) file where foo() was previously defined::
  
    In [3]: edit foo
    Editing... done. Executing edited code...
  
  And if we call foo() again we get the modified version::
  
    In [4]: foo()
    foo() has now been changed!
  
  Here is an example of how to edit a code snippet successive
  times. First we call the editor::
  
    In [5]: edit
    Editing... done. Executing edited code...
    hello
    Out[5]: "print 'hello'\n"
  
  Now we call it again with the previous output (stored in _)::
  
    In [6]: edit _
    Editing... done. Executing edited code...
    hello world
    Out[6]: "print 'hello world'\n"
  
  Now we call it with the output #8 (stored in _8, also as Out[8])::
  
    In [7]: edit _8
    Editing... done. Executing edited code...
    hello again
    Out[7]: "print 'hello again'\n"
  
  
  Changing the default editor hook:
  
  If you wish to write your own editor hook, you can put it in a
  configuration file which you load at startup time.  The default hook
  is defined in the IPython.core.hooks module, and you can use that as a
  starting example for further modifications.  That file also has
  general instructions on how to set a new hook for use once you've
  defined it.
code: def edit(self, parameter_s="", last_call=["", ""]):
      """Bring up an editor and execute the resulting code.
  
      Usage:
        %edit [options] [args]
  
      %edit runs IPython's editor hook. The default version of this hook is
      set to call the editor specified by your $EDITOR environment variable.
      If this isn't found, it will default to vi under Linux/Unix and to
      notepad under Windows. See the end of this docstring for how to change
      the editor hook.
  
      You can also set the value of this editor via the
      ``TerminalInteractiveShell.editor`` option in your configuration file.
      This is useful if you wish to use a different editor from your typical
      default with IPython (and for Windows users who typically don't set
      environment variables).
  
      This command allows you to conveniently edit multi-line code right in
      your IPython session.
  
      If called without arguments, %edit opens up an empty editor with a
      temporary file and will execute the contents of this file when you
      close it (don't forget to save it!).
  
  
      Options:
  
      -n <number>: open the editor at a specified line number.  By default,
      the IPython editor hook uses the unix syntax 'editor +N filename', but
      you can configure this by providing your own modified hook if your
      favorite editor supports line-number specifications with a different
      syntax.
  
      -p: this will call the editor with the same data as the previous time
      it was used, regardless of how long ago (in your current session) it
      was.
  
      -r: use 'raw' input.  This option only applies to input taken from the
      user's history.  By default, the 'processed' history is used, so that
      magics are loaded in their transformed version to valid Python.  If
      this option is given, the raw input as typed as the command line is
      used instead.  When you exit the editor, it will be executed by
      IPython's own processor.
  
      -x: do not execute the edited code immediately upon exit. This is
      mainly useful if you are editing programs which need to be called with
      command line arguments, which you can then do using %run.
  
  
      Arguments:
  
      If arguments are given, the following possibilities exist:
  
      - If the argument is a filename, IPython will load that into the
        editor. It will execute its contents with execfile() when you exit,
        loading any code in the file into your interactive namespace.
  
      - The arguments are ranges of input history,  e.g. "7 ~1/4-6".
        The syntax is the same as in the %history magic.
  
      - If the argument is a string variable, its contents are loaded
        into the editor. You can thus edit any string which contains
        python code (including the result of previous edits).
  
      - If the argument is the name of an object (other than a string),
        IPython will try to locate the file where it was defined and open the
        editor at the point where it is defined. You can use `%edit function`
        to load an editor exactly at the point where 'function' is defined,
        edit it and have the file be executed automatically.
  
      - If the object is a macro (see %macro for details), this opens up your
        specified editor with a temporary file containing the macro's data.
        Upon exit, the macro is reloaded with the contents of the file.
  
      Note: opening at an exact line is only supported under Unix, and some
      editors (like kedit and gedit up to Gnome 2.8) do not understand the
      '+NUMBER' parameter necessary for this feature. Good editors like
      (X)Emacs, vi, jed, pico and joe all do.
  
      After executing your code, %edit will return as output the code you
      typed in the editor (except when it was an existing file). This way
      you can reload the code in further invocations of %edit as a variable,
      via _<NUMBER> or Out[<NUMBER>], where <NUMBER> is the prompt number of
      the output.
  
      Note that %edit is also available through the alias %ed.
  
      This is an example of creating a simple function inside the editor and
      then modifying it. First, start up the editor::
  
        In [1]: edit
        Editing... done. Executing edited code...
        Out[1]: 'def foo():\\n    print "foo() was defined in an editing
        session"\\n'
  
      We can then call the function foo()::
  
        In [2]: foo()
        foo() was defined in an editing session
  
      Now we edit foo.  IPython automatically loads the editor with the
      (temporary) file where foo() was previously defined::
  
        In [3]: edit foo
        Editing... done. Executing edited code...
  
      And if we call foo() again we get the modified version::
  
        In [4]: foo()
        foo() has now been changed!
  
      Here is an example of how to edit a code snippet successive
      times. First we call the editor::
  
        In [5]: edit
        Editing... done. Executing edited code...
        hello
        Out[5]: "print 'hello'\\n"
  
      Now we call it again with the previous output (stored in _)::
  
        In [6]: edit _
        Editing... done. Executing edited code...
        hello world
        Out[6]: "print 'hello world'\\n"
  
      Now we call it with the output #8 (stored in _8, also as Out[8])::
  
        In [7]: edit _8
        Editing... done. Executing edited code...
        hello again
        Out[7]: "print 'hello again'\\n"
  
  
      Changing the default editor hook:
  
      If you wish to write your own editor hook, you can put it in a
      configuration file which you load at startup time.  The default hook
      is defined in the IPython.core.hooks module, and you can use that as a
      starting example for further modifications.  That file also has
      general instructions on how to set a new hook for use once you've
      defined it."""
      opts, args = self.parse_options(parameter_s, "prxn:")
  
      try:
          filename, lineno, is_temp = self._find_edit_target(
              self.shell, args, opts, last_call
          )
      except MacroToEdit as e:
          self._edit_macro(args, e.args[0])
          return
      except InteractivelyDefined as e:
          print("Editing In[%i]" % e.index)
          args = str(e.index)
          filename, lineno, is_temp = self._find_edit_target(
              self.shell, args, opts, last_call
          )
      if filename is None:
          # nothing was found, warnings have already been issued,
          # just give up.
          return
  
      if is_temp:
          self._knowntemps.add(filename)
      elif filename in self._knowntemps:
          is_temp = True
  
      # do actual editing here
      print("Editing...", end=" ")
      sys.stdout.flush()
      try:
          # Quote filenames that may have spaces in them
          if " " in filename:
              filename = "'%s'" % filename
          self.shell.hooks.editor(filename, lineno)
      except TryNext:
          warn("Could not open editor")
          return
  
      # XXX TODO: should this be generalized for all string vars?
      # For now, this is special-cased to blocks created by cpaste
      if args.strip() == "pasted_block":
          with open(filename, "r") as f:
              self.shell.user_ns["pasted_block"] = f.read()
  
      if "x" in opts:  # -x prevents actual execution
          print()
      else:
          print("done. Executing edited code...")
          with preserve_keys(self.shell.user_ns, "__file__"):
              if not is_temp:
                  self.shell.user_ns["__file__"] = filename
              if "r" in opts:  # Untranslated IPython code
                  with open(filename, "r") as f:
                      source = f.read()
                  self.shell.run_cell(source, store_history=False)
              else:
                  self.shell.safe_execfile(
                      filename, self.shell.user_ns, self.shell.user_ns
                  )
  
      if is_temp:
          try:
              return open(filename).read()
          except IOError as msg:
              if msg.filename == filename:
                  warn("File not found. Did you forget to save?")
                  return
              else:
                  self.shell.showtraceback()
  
imports: from __future__ import print_function
  from __future__ import absolute_import
  import inspect
  import io
  import os
  import re
  import sys
  import ast
  from itertools import chain
  from IPython.core.error import TryNext, StdinNotImplementedError, UsageError
  from IPython.core.macro import Macro
  from IPython.core.magic import Magics, magics_class, line_magic
  from IPython.core.oinspect import find_file, find_source_lines
  from IPython.testing.skipdoctest import skip_doctest
  from IPython.utils import py3compat
  from IPython.utils.py3compat import string_types
  from IPython.utils.contexts import preserve_keys
  from IPython.utils.path import get_py_filename
  from warnings import warn
  from logging import error
  from IPython.utils.text import get_text_list
label_desc: Use image node_id 8 for calling the CodeMagics obj's underlying member method code with example usage: obj.edit(parameter_s, last_call) and returns: open