class_docstr: Magics related to code execution, debugging, profiling, etc.
  
      
docstr: Run the named file inside IPython as a program.
  
  Usage::
  
    %run [-n -i -e -G]
         [( -t [-N<N>] | -d [-b<N>] | -p [profile options] )]
         ( -m mod | file ) [args]
  
  Parameters after the filename are passed as command-line arguments to
  the program (put in sys.argv). Then, control returns to IPython's
  prompt.
  
  This is similar to running at a system prompt ``python file args``,
  but with the advantage of giving you IPython's tracebacks, and of
  loading all variables into your interactive namespace for further use
  (unless -p is used, see below).
  
  The file is executed in a namespace initially consisting only of
  ``__name__=='__main__'`` and sys.argv constructed as indicated. It thus
  sees its environment as if it were being run as a stand-alone program
  (except for sharing global objects such as previously imported
  modules). But after execution, the IPython interactive namespace gets
  updated with all variables defined in the program (except for __name__
  and sys.argv). This allows for very convenient loading of code for
  interactive work, while giving each program a 'clean sheet' to run in.
  
  Arguments are expanded using shell-like glob match.  Patterns
  '*', '?', '[seq]' and '[!seq]' can be used.  Additionally,
  tilde '~' will be expanded into user's home directory.  Unlike
  real shells, quotation does not suppress expansions.  Use
  *two* back slashes (e.g. ``\\*``) to suppress expansions.
  To completely disable these expansions, you can use -G flag.
  
  Options:
  
  -n
    __name__ is NOT set to '__main__', but to the running file's name
    without extension (as python does under import).  This allows running
    scripts and reloading the definitions in them without calling code
    protected by an ``if __name__ == "__main__"`` clause.
  
  -i
    run the file in IPython's namespace instead of an empty one. This
    is useful if you are experimenting with code written in a text editor
    which depends on variables defined interactively.
  
  -e
    ignore sys.exit() calls or SystemExit exceptions in the script
    being run.  This is particularly useful if IPython is being used to
    run unittests, which always exit with a sys.exit() call.  In such
    cases you are interested in the output of the test results, not in
    seeing a traceback of the unittest module.
  
  -t
    print timing information at the end of the run.  IPython will give
    you an estimated CPU time consumption for your script, which under
    Unix uses the resource module to avoid the wraparound problems of
    time.clock().  Under Unix, an estimate of time spent on system tasks
    is also given (for Windows platforms this is reported as 0.0).
  
  If -t is given, an additional ``-N<N>`` option can be given, where <N>
  must be an integer indicating how many times you want the script to
  run.  The final timing report will include total and per run results.
  
  For example (testing the script uniq_stable.py)::
  
      In [1]: run -t uniq_stable
  
      IPython CPU timings (estimated):
        User  :    0.19597 s.
        System:        0.0 s.
  
      In [2]: run -t -N5 uniq_stable
  
      IPython CPU timings (estimated):
      Total runs performed: 5
        Times :      Total       Per run
        User  :   0.910862 s,  0.1821724 s.
        System:        0.0 s,        0.0 s.
  
  -d
    run your program under the control of pdb, the Python debugger.
    This allows you to execute your program step by step, watch variables,
    etc.  Internally, what IPython does is similar to calling::
  
        pdb.run('execfile("YOURFILENAME")')
  
    with a breakpoint set on line 1 of your file.  You can change the line
    number for this automatic breakpoint to be <N> by using the -bN option
    (where N must be an integer). For example::
  
        %run -d -b40 myscript
  
    will set the first breakpoint at line 40 in myscript.py.  Note that
    the first breakpoint must be set on a line which actually does
    something (not a comment or docstring) for it to stop execution.
  
    Or you can specify a breakpoint in a different file::
  
        %run -d -b myotherfile.py:20 myscript
  
    When the pdb debugger starts, you will see a (Pdb) prompt.  You must
    first enter 'c' (without quotes) to start execution up to the first
    breakpoint.
  
    Entering 'help' gives information about the use of the debugger.  You
    can easily see pdb's full documentation with "import pdb;pdb.help()"
    at a prompt.
  
  -p
    run program under the control of the Python profiler module (which
    prints a detailed report of execution times, function calls, etc).
  
    You can pass other options after -p which affect the behavior of the
    profiler itself. See the docs for %prun for details.
  
    In this mode, the program's variables do NOT propagate back to the
    IPython interactive namespace (because they remain in the namespace
    where the profiler executes them).
  
    Internally this triggers a call to %prun, see its documentation for
    details on the options available specifically for profiling.
  
  There is one special usage for which the text above doesn't apply:
  if the filename ends with .ipy[nb], the file is run as ipython script,
  just as if the commands were written on IPython prompt.
  
  -m
    specify module name to load instead of script path. Similar to
    the -m option for the python interpreter. Use this option last if you
    want to combine with other %run options. Unlike the python interpreter
    only source modules are allowed no .pyc or .pyo files.
    For example::
  
        %run -m example
  
    will run the example module.
  
  -G
    disable shell-like glob expansion of arguments.
docstr_tok: ["Run","the","named","file","inside","IPython","as","a","program",".","Usage",":",":","%","run","[","-n","-i","-e","-G","]","[","(","-t","[","-N","<","N",">","]","|","-d","[","-b","<","N",">","]","|","-p","[","profile","options","]",")","]","(","-m","mod","|","file",")","[","args","]","Parameters","after","the","filename","are","passed","as","command-line","arguments","to","the","program","(","put","in","sys.argv",")",".","Then",",","control","returns","to","IPython's","prompt",".","This","is","similar","to","running","at","a","system","prompt","``","python","file","args","``",",","but","with","the","advantage","of","giving","you","IPython","'s","tracebacks",",","and","of","loading","all","variables","into","your","interactive","namespace","for","further","use","(","unless","-p","is","used",",","see","below",")",".","The","file","is","executed","in","a","namespace","initially","consisting","only","of","``","__name__=='__main__","'","``","and","sys.argv","constructed","as","indicated",".","It","thus","sees","its","environment","as","if","it","were","being","run","as","a","stand-alone","program","(","except","for","sharing","global","objects","such","as","previously","imported","modules",")",".","But","after","execution",",","the","IPython","interactive","namespace","gets","updated","with","all","variables","defined","in","the","program","(","except","for","__name__","and","sys.argv",")",".","This","allows","for","very","convenient","loading","of","code","for","interactive","work",",","while","giving","each","program","a","'clean","sheet","'","to","run","in",".","Arguments","are","expanded","using","shell-like","glob","match",".","Patterns","'","*","'",",","'","?","'",",","'","[","seq","]","'","and","'","[","!","seq","]","'","can","be","used",".","Additionally",",","tilde","'~","'","will","be","expanded","into","user","'s","home","directory",".","Unlike","real","shells",",","quotation","does","not","suppress","expansions",".","Use","*","two","*","back","slashes","(","e.g",".","``","\\\\","*","``",")","to","suppress","expansions",".","To","completely","disable","these","expansions",",","you","can","use","-G","flag",".","Options",":","-n","__name__","is","NOT","set","to","'__main__","'",",","but","to","the","running","file","'s","name","without","extension","(","as","python","does","under","import",")",".","This","allows","running","scripts","and","reloading","the","definitions","in","them","without","calling","code","protected","by","an","``","if","__name__","==","``","__main__","''","``","clause",".","-i","run","the","file","in","IPython","'s","namespace","instead","of","an","empty","one",".","This","is","useful","if","you","are","experimenting","with","code","written","in","a","text","editor","which","depends","on","variables","defined","interactively",".","-e","ignore","sys.exit","(",")","calls","or","SystemExit","exceptions","in","the","script","being","run",".","This","is","particularly","useful","if","IPython","is","being","used","to","run","unittests",",","which","always","exit","with","a","sys.exit","(",")","call",".","In","such","cases","you","are","interested","in","the","output","of","the","test","results",",","not","in","seeing","a","traceback","of","the","unittest","module",".","-t","print","timing","information","at","the","end","of","the","run",".","IPython","will","give","you","an","estimated","CPU","time","consumption","for","your","script",",","which","under","Unix","uses","the","resource","module","to","avoid","the","wraparound","problems","of","time.clock","(",")",".","Under","Unix",",","an","estimate","of","time","spent","on","system","tasks","is","also","given","(","for","Windows","platforms","this","is","reported","as","0.0",")",".","If","-t","is","given",",","an","additional","``","-N","<","N",">","``","option","can","be","given",",","where","<","N",">","must","be","an","integer","indicating","how","many","times","you","want","the","script","to","run",".","The","final","timing","report","will","include","total","and","per","run","results",".","For","example","(","testing","the","script","uniq_stable.py",")",":",":","In","[","1","]",":","run","-t","uniq_stable","IPython","CPU","timings","(","estimated",")",":","User",":","0.19597","s.","System",":","0.0","s.","In","[","2","]",":","run","-t","-N5","uniq_stable","IPython","CPU","timings","(","estimated",")",":","Total","runs","performed",":","5","Times",":","Total","Per","run","User",":","0.910862","s",",","0.1821724","s.","System",":","0.0","s",",","0.0","s.","-d","run","your","program","under","the","control","of","pdb",",","the","Python","debugger",".","This","allows","you","to","execute","your","program","step","by","step",",","watch","variables",",","etc",".","Internally",",","what","IPython","does","is","similar","to","calling",":",":","pdb.run","(","'execfile","(","``","YOURFILENAME","''",")","'",")","with","a","breakpoint","set","on","line","1","of","your","file",".","You","can","change","the","line","number","for","this","automatic","breakpoint","to","be","<","N",">","by","using","the","-bN","option","(","where","N","must","be","an","integer",")",".","For","example",":",":","%","run","-d","-b40","myscript","will","set","the","first","breakpoint","at","line","40","in","myscript.py",".","Note","that","the","first","breakpoint","must","be","set","on","a","line","which","actually","does","something","(","not","a","comment","or","docstring",")","for","it","to","stop","execution",".","Or","you","can","specify","a","breakpoint","in","a","different","file",":",":","%","run","-d","-b","myotherfile.py:20","myscript","When","the","pdb","debugger","starts",",","you","will","see","a","(","Pdb",")","prompt",".","You","must","first","enter","'","c","'","(","without","quotes",")","to","start","execution","up","to","the","first","breakpoint",".","Entering","'help","'","gives","information","about","the","use","of","the","debugger",".","You","can","easily","see","pdb","'s","full","documentation","with","``","import","pdb",";","pdb.help","(",")","''","at","a","prompt",".","-p","run","program","under","the","control","of","the","Python","profiler","module","(","which","prints","a","detailed","report","of","execution","times",",","function","calls",",","etc",")",".","You","can","pass","other","options","after","-p","which","affect","the","behavior","of","the","profiler","itself",".","See","the","docs","for","%","prun","for","details",".","In","this","mode",",","the","program","'s","variables","do","NOT","propagate","back","to","the","IPython","interactive","namespace","(","because","they","remain","in","the","namespace","where","the","profiler","executes","them",")",".","Internally","this","triggers","a","call","to","%","prun",",","see","its","documentation","for","details","on","the","options","available","specifically","for","profiling",".","There","is","one","special","usage","for","which","the","text","above","does","n't","apply",":","if","the","filename","ends","with",".ipy","[","nb","]",",","the","file","is","run","as","ipython","script",",","just","as","if","the","commands","were","written","on","IPython","prompt",".","-m","specify","module","name","to","load","instead","of","script","path",".","Similar","to","the","-m","option","for","the","python","interpreter",".","Use","this","option","last","if","you","want","to","combine","with","other","%","run","options",".","Unlike","the","python","interpreter","only","source","modules","are","allowed","no",".pyc","or",".pyo","files",".","For","example",":",":","%","run","-m","example","will","run","the","example","module",".","-G","disable","shell-like","glob","expansion","of","arguments","."]
code: def run(
      self, parameter_s="", runner=None, file_finder=get_py_filename
  ):
      """Run the named file inside IPython as a program.
  
      Usage::
  
        %run [-n -i -e -G]
             [( -t [-N<N>] | -d [-b<N>] | -p [profile options] )]
             ( -m mod | file ) [args]
  
      Parameters after the filename are passed as command-line arguments to
      the program (put in sys.argv). Then, control returns to IPython's
      prompt.
  
      This is similar to running at a system prompt ``python file args``,
      but with the advantage of giving you IPython's tracebacks, and of
      loading all variables into your interactive namespace for further use
      (unless -p is used, see below).
  
      The file is executed in a namespace initially consisting only of
      ``__name__=='__main__'`` and sys.argv constructed as indicated. It thus
      sees its environment as if it were being run as a stand-alone program
      (except for sharing global objects such as previously imported
      modules). But after execution, the IPython interactive namespace gets
      updated with all variables defined in the program (except for __name__
      and sys.argv). This allows for very convenient loading of code for
      interactive work, while giving each program a 'clean sheet' to run in.
  
      Arguments are expanded using shell-like glob match.  Patterns
      '*', '?', '[seq]' and '[!seq]' can be used.  Additionally,
      tilde '~' will be expanded into user's home directory.  Unlike
      real shells, quotation does not suppress expansions.  Use
      *two* back slashes (e.g. ``\\\\*``) to suppress expansions.
      To completely disable these expansions, you can use -G flag.
  
      Options:
  
      -n
        __name__ is NOT set to '__main__', but to the running file's name
        without extension (as python does under import).  This allows running
        scripts and reloading the definitions in them without calling code
        protected by an ``if __name__ == "__main__"`` clause.
  
      -i
        run the file in IPython's namespace instead of an empty one. This
        is useful if you are experimenting with code written in a text editor
        which depends on variables defined interactively.
  
      -e
        ignore sys.exit() calls or SystemExit exceptions in the script
        being run.  This is particularly useful if IPython is being used to
        run unittests, which always exit with a sys.exit() call.  In such
        cases you are interested in the output of the test results, not in
        seeing a traceback of the unittest module.
  
      -t
        print timing information at the end of the run.  IPython will give
        you an estimated CPU time consumption for your script, which under
        Unix uses the resource module to avoid the wraparound problems of
        time.clock().  Under Unix, an estimate of time spent on system tasks
        is also given (for Windows platforms this is reported as 0.0).
  
      If -t is given, an additional ``-N<N>`` option can be given, where <N>
      must be an integer indicating how many times you want the script to
      run.  The final timing report will include total and per run results.
  
      For example (testing the script uniq_stable.py)::
  
          In [1]: run -t uniq_stable
  
          IPython CPU timings (estimated):
            User  :    0.19597 s.
            System:        0.0 s.
  
          In [2]: run -t -N5 uniq_stable
  
          IPython CPU timings (estimated):
          Total runs performed: 5
            Times :      Total       Per run
            User  :   0.910862 s,  0.1821724 s.
            System:        0.0 s,        0.0 s.
  
      -d
        run your program under the control of pdb, the Python debugger.
        This allows you to execute your program step by step, watch variables,
        etc.  Internally, what IPython does is similar to calling::
  
            pdb.run('execfile("YOURFILENAME")')
  
        with a breakpoint set on line 1 of your file.  You can change the line
        number for this automatic breakpoint to be <N> by using the -bN option
        (where N must be an integer). For example::
  
            %run -d -b40 myscript
  
        will set the first breakpoint at line 40 in myscript.py.  Note that
        the first breakpoint must be set on a line which actually does
        something (not a comment or docstring) for it to stop execution.
  
        Or you can specify a breakpoint in a different file::
  
            %run -d -b myotherfile.py:20 myscript
  
        When the pdb debugger starts, you will see a (Pdb) prompt.  You must
        first enter 'c' (without quotes) to start execution up to the first
        breakpoint.
  
        Entering 'help' gives information about the use of the debugger.  You
        can easily see pdb's full documentation with "import pdb;pdb.help()"
        at a prompt.
  
      -p
        run program under the control of the Python profiler module (which
        prints a detailed report of execution times, function calls, etc).
  
        You can pass other options after -p which affect the behavior of the
        profiler itself. See the docs for %prun for details.
  
        In this mode, the program's variables do NOT propagate back to the
        IPython interactive namespace (because they remain in the namespace
        where the profiler executes them).
  
        Internally this triggers a call to %prun, see its documentation for
        details on the options available specifically for profiling.
  
      There is one special usage for which the text above doesn't apply:
      if the filename ends with .ipy[nb], the file is run as ipython script,
      just as if the commands were written on IPython prompt.
  
      -m
        specify module name to load instead of script path. Similar to
        the -m option for the python interpreter. Use this option last if you
        want to combine with other %run options. Unlike the python interpreter
        only source modules are allowed no .pyc or .pyo files.
        For example::
  
            %run -m example
  
        will run the example module.
  
      -G
        disable shell-like glob expansion of arguments.
  
      """
  
      # get arguments and set sys.argv for program to be run.
      opts, arg_lst = self.parse_options(
          parameter_s, "nidtN:b:pD:l:rs:T:em:G", mode="list", list_all=1
      )
      if "m" in opts:
          modulename = opts["m"][0]
          modpath = find_mod(modulename)
          if modpath is None:
              warn(
                  "%r is not a valid modulename on sys.path"
                  % modulename
              )
              return
          arg_lst = [modpath] + arg_lst
      try:
          filename = file_finder(arg_lst[0])
      except IndexError:
          warn("you must provide at least a filename.")
          print("\n%run:\n", oinspect.getdoc(self.run))
          return
      except IOError as e:
          try:
              msg = str(e)
          except UnicodeError:
              msg = e.message
          error(msg)
          return
  
      if filename.lower().endswith((".ipy", ".ipynb")):
          with preserve_keys(self.shell.user_ns, "__file__"):
              self.shell.user_ns["__file__"] = filename
              self.shell.safe_execfile_ipy(filename)
          return
  
      # Control the response to exit() calls made by the script being run
      exit_ignore = "e" in opts
  
      # Make sure that the running script gets a proper sys.argv as if it
      # were run from a system shell.
      save_argv = sys.argv  # save it for later restoring
  
      if "G" in opts:
          args = arg_lst[1:]
      else:
          # tilde and glob expansion
          args = shellglob(map(os.path.expanduser, arg_lst[1:]))
  
      sys.argv = [filename] + args  # put in the proper filename
      # protect sys.argv from potential unicode strings on Python 2:
      if not py3compat.PY3:
          sys.argv = [py3compat.cast_bytes(a) for a in sys.argv]
  
      if "i" in opts:
          # Run in user's interactive namespace
          prog_ns = self.shell.user_ns
          __name__save = self.shell.user_ns["__name__"]
          prog_ns["__name__"] = "__main__"
          main_mod = self.shell.user_module
  
          # Since '%run foo' emulates 'python foo.py' at the cmd line, we must
          # set the __file__ global in the script's namespace
          # TK: Is this necessary in interactive mode?
          prog_ns["__file__"] = filename
      else:
          # Run in a fresh, empty namespace
          if "n" in opts:
              name = os.path.splitext(os.path.basename(filename))[0]
          else:
              name = "__main__"
  
          # The shell MUST hold a reference to prog_ns so after %run
          # exits, the python deletion mechanism doesn't zero it out
          # (leaving dangling references). See interactiveshell for details
          main_mod = self.shell.new_main_mod(filename, name)
          prog_ns = main_mod.__dict__
  
      # pickle fix.  See interactiveshell for an explanation.  But we need to
      # make sure that, if we overwrite __main__, we replace it at the end
      main_mod_name = prog_ns["__name__"]
  
      if main_mod_name == "__main__":
          restore_main = sys.modules["__main__"]
      else:
          restore_main = False
  
      # This needs to be undone at the end to prevent holding references to
      # every single object ever created.
      sys.modules[main_mod_name] = main_mod
  
      if "p" in opts or "d" in opts:
          if "m" in opts:
              code = "run_module(modulename, prog_ns)"
              code_ns = {
                  "run_module": self.shell.safe_run_module,
                  "prog_ns": prog_ns,
                  "modulename": modulename,
              }
          else:
              if "d" in opts:
                  # allow exceptions to raise in debug mode
                  code = "execfile(filename, prog_ns, raise_exceptions=True)"
              else:
                  code = "execfile(filename, prog_ns)"
              code_ns = {
                  "execfile": self.shell.safe_execfile,
                  "prog_ns": prog_ns,
                  "filename": get_py_filename(filename),
              }
  
      try:
          stats = None
          if "p" in opts:
              stats = self._run_with_profiler(code, opts, code_ns)
          else:
              if "d" in opts:
                  bp_file, bp_line = parse_breakpoint(
                      opts.get("b", ["1"])[0], filename
                  )
                  self._run_with_debugger(
                      code, code_ns, filename, bp_line, bp_file
                  )
              else:
                  if "m" in opts:
  
                      def run():
                          self.shell.safe_run_module(
                              modulename, prog_ns
                          )
  
                  else:
                      if runner is None:
                          runner = self.default_runner
                      if runner is None:
                          runner = self.shell.safe_execfile
  
                      def run():
                          runner(
                              filename,
                              prog_ns,
                              prog_ns,
                              exit_ignore=exit_ignore,
                          )
  
                  if "t" in opts:
                      # timed execution
                      try:
                          nruns = int(opts["N"][0])
                          if nruns < 1:
                              error("Number of runs must be >=1")
                              return
                      except KeyError:
                          nruns = 1
                      self._run_with_timing(run, nruns)
                  else:
                      # regular execution
                      run()
  
          if "i" in opts:
              self.shell.user_ns["__name__"] = __name__save
          else:
              # update IPython interactive namespace
  
              # Some forms of read errors on the file may mean the
              # __name__ key was never set; using pop we don't have to
              # worry about a possible KeyError.
              prog_ns.pop("__name__", None)
  
              with preserve_keys(self.shell.user_ns, "__file__"):
                  self.shell.user_ns.update(prog_ns)
      finally:
          # It's a bit of a mystery why, but __builtins__ can change from
          # being a module to becoming a dict missing some key data after
          # %run.  As best I can see, this is NOT something IPython is doing
          # at all, and similar problems have been reported before:
          # http://coding.derkeiler.com/Archive/Python/comp.lang.python/2004-10/0188.html
          # Since this seems to be done by the interpreter itself, the best
          # we can do is to at least restore __builtins__ for the user on
          # exit.
          self.shell.user_ns["__builtins__"] = builtin_mod
  
          # Ensure key global structures are restored
          sys.argv = save_argv
          if restore_main:
              sys.modules["__main__"] = restore_main
          else:
              # Remove from sys.modules the reference to main_mod we'd
              # added.  Otherwise it will trap references to objects
              # contained therein.
              del sys.modules[main_mod_name]
  
      return stats
  
imports: from __future__ import print_function
  from __future__ import absolute_import
  import ast
  import bdb
  import gc
  import itertools
  import os
  import sys
  import time
  import timeit
  from pdb import Restart
  from IPython.core import oinspect
  from IPython.core import magic_arguments
  from IPython.core import page
  from IPython.core.error import UsageError
  from IPython.core.macro import Macro
  from IPython.core.magic import Magics, magics_class, line_magic, cell_magic, line_cell_magic, on_off, needs_local_scope
  from IPython.testing.skipdoctest import skip_doctest
  from IPython.utils import py3compat
  from IPython.utils.py3compat import builtin_mod, iteritems, PY3
  from IPython.utils.contexts import preserve_keys
  from IPython.utils.capture import capture_output
  from IPython.utils.ipstruct import Struct
  from IPython.utils.module_paths import find_mod
  from IPython.utils.path import get_py_filename, shellglob
  from IPython.utils.timing import clock, clock2
  from warnings import warn
  from logging import error
label_desc: Use image node_id 10 for calling the ExecutionMagics obj's underlying member method code with example usage: obj.run(parameter_s, runner, file_finder) and returns: stats