adds the optional parameter -s to the magic %load that loads specific function or classes from the python source given. forcing the patch ignoring whitespace changes

IPython/core/magics/code.py

@@ -18,6 +18,7 b' import io'
 import os
 import re
 import sys
+import ast
 from itertools import chain
 
 # Our own packages
@@ -47,7 +48,6 b' range_re = re.compile(r"""'
  (?P<end>\d+)?)?
 $""", re.VERBOSE)
 
-
 def extract_code_ranges(ranges_str):
     """Turn a string of range for %%load into 2-tuples of (start, stop)
     ready to use as a slice of the content splitted by lines.
@@ -76,6 +76,40 b' def extract_code_ranges(ranges_str):'
             start = int(start) - 1
         yield (start, end)
 
+def extract_symbols(code, symbols):
+    """
+    Return a list of code fragments for each symbol parsed from code
+    For example, suppose code is::
+
+        a = 10
+
+        def b(): return 42
+
+        class A: pass
+
+    >>> extract_symbols(code, 'A,b'):
+        class A: pass
+
+        def b(): return 42
+    """
+    try:
+        py_code = ast.parse(code)
+    except SyntaxError:
+        return []
+    marks = [(getattr(s, 'name', None), s.lineno) for s in py_code.body]
+    end = None
+    symbols_lines = {}
+    for name, start in reversed(marks):
+        if name:
+            symbols_lines[name] = (start - 1, end)
+        end = start - 1
+    blocks = []
+    code = code.split('\n')
+    for symbol in symbols.split(','):
+        if symbol in symbols_lines:
+            blocks.append('\n'.join(code[slice(*symbols_lines[symbol])]))
+    return blocks
+
 
 class InteractivelyDefined(Exception):
     """Exception for interactively defined variable in magic_edit"""
@@ -217,6 +251,8 b' class CodeMagics(Magics):'
           (x..(y-1)). Both limits x and y can be left blank (meaning the 
           beginning and end of the file, respectively).
 
+          -s <symbols>: Specify function or classes to load from python source. Could be
+
           -y : Don't ask confirmation for loading source above 200 000 characters.
 
         This magic command can either take a local filename, a URL, an history
@@ -230,8 +266,9 b' class CodeMagics(Magics):'
         %load http://www.example.com/myscript.py
         %load -r 5-10 myscript.py
         %load -r 10-20,30,40: foo.py
+        %load -s MyClass,wonder_function myscript.py
         """
-        opts,args = self.parse_options(arg_s,'yr:')
+        opts,args = self.parse_options(arg_s,'ys:r:')
 
         if not args:
             raise UsageError('Missing filename, URL, input history range, '
@@ -239,6 +276,9 b' class CodeMagics(Magics):'
 
         contents = self.shell.find_user_code(args)
 
+        if 's' in opts:
+            contents = '\n'.join(extract_symbols(contents, opts['s']))
+
         if 'r' in opts:
             ranges = opts['r'].replace(',', ' ')
             lines = contents.split('\n')
@@ -248,7 +288,6 b' class CodeMagics(Magics):'
 
         l = len(contents)
 
-
         # 200 000 is ~ 2500 full 80 caracter lines
         # so in average, more than 5000 lines
         if l > 200000 and 'y' not in opts:

IPython/core/tests/test_magic.py

@@ -60,6 +60,28 b' def test_extract_code_ranges():'
     actual = list(code.extract_code_ranges(instr))
     nt.assert_equal(actual, expected)
 
+
+def test_extract_symbols():
+    source = """import foo\na = 10\ndef b():\n    return 42\nclass A: pass\n"""
+    symbols_args = ["a", "b", "A", "A,b", "A,a", "z"]
+    expected = [[],
+                ["def b():\n    return 42"],
+                ["class A: pass\n"],
+                ["class A: pass\n", "def b():\n    return 42"],
+                ["class A: pass\n"],
+                []]
+    for symbols, exp in zip(symbols_args, expected):
+        nt.assert_equal(code.extract_symbols(source, symbols), exp)
+
+
+def test_extract_symbols_ignores_non_python_code():
+    source = ("=begin A Ruby program :)=end\n"
+              "def hello\n"
+              "puts 'Hello world'\n"
+              "end")
+    nt.assert_equal(code.extract_symbols(source, "hello"), [])
+
+
 def test_rehashx():
     # clear up everything
     _ip = get_ipython()