Notebook

Functions¶

Pass functions (Closure)¶

In [24]:

# :+ http://stackoverflow.com/questions/803616/passing-functions-with-arguments-to-another-function-in-python
# http://stackoverflow.com/questions/8954746/python-arguments-as-a-dictionary
def perform( fun, *args, **kargs ):
    # isinstance(fun, function) will NOT work: http://stackoverflow.com/questions/624926/how-to-detect-whether-a-python-variable-is-a-function
    print (fun, type(fun), callable(fun))
    fun( *args, **kargs )

def action1( ):
    print ('action1 without args')
    
def action2( a ):
    print ('a=' + a)

def action3( a, b='bbb' ):
    print ('a=' + a, 'b=' + b)

perform( action1 )
perform( action2, 'Avalue' )
perform( action3, a='AvaL', b="bVal")

<function action1 at 0x7fe7a8244488> <class 'function'> True
action1 without args
<function action2 at 0x7fe7a8244d08> <class 'function'> True
a=Avalue
<function action3 at 0x7fe7a8a90e18> <class 'function'> True
a=AvaL b=bVal

Dependant default values¶

In [9]:

def some(a=[1, 2, 3], b={'a': self.a}):
    print (a, b)

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-9-a8a92932291a> in <module>()
----> 1 def some(a=[1, 2, 3], b={'a': self.a}):
      2     print (a, b)

NameError: name 'self' is not defined

Typed arguments¶

http://stackoverflow.com/questions/2489669/function-parameter-types-in-python

In [31]:

def pick(l: list, index: int) -> int:
    return l[index]

In [32]:

pick([1, 2, 3], 2)

Out[32]:

In [33]:

pick([1, 2, 3], '2')

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-33-702d4bf346da> in <module>()
----> 1 pick([1, 2, 3], '2')

<ipython-input-31-2b1a6639c5b1> in pick(l, index)
      1 def pick(l: list, index: int) -> int:
----> 2     return l[index]

TypeError: list indices must be integers or slices, not str

ООП¶

In [3]:

class A:
    a_ = 'A.a_'

class B(A):
    a_ = 'B.a_'

b = B()
print(b.a_)

B.a_

Class, instance, default (!) static vars¶

ALL class vars by default static!!!

In [7]:

>>> class A():
...     var = 0
...     list = []
...     def __init__(self):
...         self.list1 = []
...
>>> a = A()
>>> b = A()
>>> a.var
0
>>> a.list
[]
>>> b.var
0
>>> b.list
[]
>>> a.var = 1
>>> b.var
0
>>> a.list.append('hello')
>>> b.list
['hello']
>>> b.list = ['newlist']
>>> a.list
['hello']
>>> b.list
['newlist']

Out[7]:

['newlist']

In [5]:

a.list1.append('one')
a.list1

Out[5]:

['one']

In [6]:

b.list1

Out[6]:

[]

In [8]:

class Test(object):
    _i = 3
    @property
    def i(self):
        return self._i
    @i.setter
    def i(self,val):
        self._i = val

In [9]:

x1 = Test()
x2 = Test()
x1.i = 50
assert x2.i == 3

Instance variables by :¶

In [28]:

# https://mypy.readthedocs.io/en/latest/cheat_sheet_py3.html#classes
class B():
    var_untyped: 0
    var_str: str = "4"

    def __init__(self):
        # Note, Types NOT enforced!
        # See https://www.python.org/dev/peps/pep-0526/#non-goals, quoting:
        #
        # It should also be emphasized that Python will remain a dynamically typed language, and the authors
        # have no desire to ever make type hints mandatory, even by convention.
        # Type annotations should not be confused with variable declarations in statically typed languages.
        # The goal of annotation syntax is to provide an easy way to specify structured type metadata for third
        # party tools.
        self.var_str = 5

In [34]:

b = B()
print(b.var_str)

In [19]:

print(B.var_str)

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-19-f29d20d363f9> in <module>()
----> 1 print(B.var_str)

AttributeError: type object 'B' has no attribute 'var_str'

init of parent must be called always!¶

In [26]:

class A:
    def __init__(self):
        print ('A.__init__')

class B(A):
    def __init__(self):
        print ('B.__init__')

b = B()

B.__init__

In [27]:

class B(A):
    def __init__(self):
        super().__init__() # <-++
        print ('B.__init__')

b = B()

A.__init__
B.__init__

In [32]:

class A:
    static = 'A.static'

    def __init__(self):
        print ('A.__init__')
        self.A__init = 'self.A__init'

class B(A):
    def __init__(self):
        super().__init__() # <-++
        print ('B.__init__')
        self.B__init = 'self.B__init'

b = B()
(b.A__init, b.B__init)

A.__init__
B.__init__

Out[32]:

('self.A__init', 'self.B__init')

Global constants¶

In [4]:

SOME_CONST=8

class C:
    def m(self):
        print (SOME_CONST)

c = C()
c.m()
SOME_CONST=4
c.m()

8
4

Call method by its string name¶

http://stackoverflow.com/questions/3521715/call-a-python-method-by-name

In [8]:

class Foo:
    def bar1(self):
        print ('bar1')
    def bar2(self):
        print ('bar2')

def callMethod(o, name):
    getattr(o, name)()


f = Foo()
callMethod(f, 'bar1')

bar1

getattr¶

In [6]:

getattr(b, 'a_')

Out[6]:

'B.a_'

In [7]:

getattr(b, 'not_existent', b.a_)

Out[7]:

'B.a_'

Class instance by its string name¶

http://stackoverflow.com/questions/4821104/python-dynamic-instantiation-from-string-name-of-a-class-in-dynamically-imported

In [2]:

className = 'sklearn.preprocessing.MinMaxScaler'

import importlib
module_name, class_name = className.rsplit(".", 1)
MyClass = getattr(importlib.import_module(module_name), class_name)
instance = MyClass()
instance

Out[2]:

MinMaxScaler(copy=True, feature_range=(0, 1))

function objectByClassName¶

In [7]:

import importlib

def objectByClassName(className, *args, **kargs):
    module_name, class_name = className.rsplit(".", 1)
    MyClass = getattr(importlib.import_module(module_name), class_name)
    return MyClass(*args, **kargs)

# Example:
objectByClassName('sklearn.preprocessing.MinMaxScaler')

Out[7]:

MinMaxScaler(copy=True, feature_range=(0, 1))

Language constructions¶

Exceptions¶

In [11]:

x = {1: False, 3: True} # no 2!

for v in [1,2,3]:
    try:
        print (x[v])
        print ('...continue')
    except Exception as e:
        print ('Exception happened', e)
        pass

False
...continue
Exception happened 2
True
...continue

Eval¶

In [3]:

eval('2 + 3')

Out[3]:

In [5]:

from sklearn.preprocessing import *
eval("Normalizer(norm='max')")

Out[5]:

Normalizer(copy=True, norm='max')

Time measure¶

In [ ]:

# Borrowed from https://gist.github.com/zed/5073409
# (http://stackoverflow.com/questions/15176619/timing-the-cpu-time-of-a-python-program)
# implementation of process_time function for Python 2 (backport)
import ctypes
import errno
from ctypes.util import find_library
from functools import partial

CLOCK_PROCESS_CPUTIME_ID = 2  # time.h
CLOCK_MONOTONIC_RAW = 4

clockid_t = ctypes.c_int
time_t = ctypes.c_long

class timespec(ctypes.Structure):
    _fields_ = [
        ('tv_sec', time_t),         # seconds
        ('tv_nsec', ctypes.c_long)  # nanoseconds
    ]
_clock_gettime = ctypes.CDLL(find_library('rt'), use_errno=True).clock_gettime
_clock_gettime.argtypes = [clockid_t, ctypes.POINTER(timespec)]


def clock_gettime(clk_id):
    tp = timespec()
    if _clock_gettime(clk_id, ctypes.byref(tp)) < 0:
        err = ctypes.get_errno()
        msg = errno.errorcode[err]
        if err == errno.EINVAL:
            msg += (" The clk_id specified is not supported on this system"
                    " clk_id=%r") % (clk_id,)
        raise OSError(err, msg)
    return tp.tv_sec + tp.tv_nsec * 1e-9

try:
    from time import perf_counter, process_time
except ImportError:  # Python <3.3
    perf_counter = partial(clock_gettime, CLOCK_MONOTONIC_RAW)
    perf_counter.__name__ = 'perf_counter'
    process_time = partial(clock_gettime, CLOCK_PROCESS_CPUTIME_ID)
    process_time.__name__ = 'process_time'

String format¶

Escape¶

http://stackoverflow.com/questions/5466451/how-can-i-print-a-literal-characters-in-python-string-and-also-use-format

In [1]:

'test_{}_{{}}'.format(1)

Out[1]:

'test_1_{}'

Garbage Collection¶

https://docs.python.org/3/library/gc.html

In [23]:

import gc
gc.garbage

Out[23]:

[]

In [21]:

gc.get_objects()

Out[21]:

[(ctypes.c_char, 16),
 (_ctypes.Array,),
 ctypes.c_char_Array_16,
 <attribute '__dict__' of 'c_char_Array_16' objects>,
 <attribute '__weakref__' of 'c_char_Array_16' objects>,
 (ctypes.c_char_Array_16, _ctypes.Array, _ctypes._CData, object),
 <weakref at 0x7f51c00ba728; to '_ctypes.PyCArrayType' at 0x55b8f5467248 (c_char_Array_16)>,
 {'__dict__': <attribute '__dict__' of 'c_char_Array_16' objects>,
  '__doc__': None,
  '__module__': 'ctypes',
  '__weakref__': <attribute '__weakref__' of 'c_char_Array_16' objects>,
  '_length_': 16,
  '_type_': ctypes.c_char,
  'raw': <attribute 'raw' of 'c_char_Array_16' objects>,
  'value': <attribute 'value' of 'c_char_Array_16' objects>},
 <attribute 'raw' of 'c_char_Array_16' objects>,
 <attribute 'value' of 'c_char_Array_16' objects>,
 <weakproxy at 0x7f51c00ba958 to _ctypes.PyCArrayType at 0x55b8f5467248>,
 <IPython.core.formatters.IPythonDisplayFormatter at 0x7f51c006e470>,
 {'_cross_validation_lock': False,
  '_trait_notifiers': {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
  '_trait_validators': {},
  '_trait_values': {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
   'deferred_printers': {},
   'enabled': True,
   'format_type': 'text/plain',
   'parent': <IPython.core.formatters.DisplayFormatter at 0x7f51c0113400>,
   'print_method': '_ipython_display_',
   'singleton_printers': {},
   'type_printers': {}}},
 [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>],
 {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]},
 {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
 {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
  'deferred_printers': {},
  'enabled': True,
  'format_type': 'text/plain',
  'parent': <IPython.core.formatters.DisplayFormatter at 0x7f51c0113400>,
  'print_method': '_ipython_display_',
  'singleton_printers': {},
  'type_printers': {}},
 <IPython.core.formatters.PlainTextFormatter at 0x7f51c006e4a8>,
 {'_cross_validation_lock': False,
  '_trait_notifiers': {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
  '_trait_validators': {},
  '_trait_values': {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
   'deferred_printers': {('collections',
     'Counter'): <function IPython.lib.pretty._counter_pprint>,
    ('collections',
     'OrderedDict'): <function IPython.lib.pretty._ordereddict_pprint>,
    ('collections',
     'defaultdict'): <function IPython.lib.pretty._defaultdict_pprint>,
    ('collections', 'deque'): <function IPython.lib.pretty._deque_pprint>},
   'enabled': True,
   'float_format': '%r',
   'float_precision': '',
   'format_type': 'text/plain',
   'max_seq_length': 1000,
   'max_width': 79,
   'newline': '\n',
   'parent': <IPython.core.formatters.DisplayFormatter at 0x7f51c0113400>,
   'pprint': True,
   'print_method': '_repr_pretty_',
   'singleton_printers': {139989402110976: <function IPython.lib.pretty._repr_pprint>,
    139989402111008: <function IPython.lib.pretty._repr_pprint>,
    139989402204240: <function IPython.lib.pretty._repr_pprint>,
    139989402204656: <function IPython.lib.pretty._repr_pprint>,
    139989402216560: <function IPython.lib.pretty._repr_pprint>},
   'type_printers': {tuple: <function IPython.lib.pretty._seq_pprinter_factory.<locals>.inner>,
    frozenset: <function IPython.lib.pretty._set_pprinter_factory.<locals>.inner>,
    method: <function IPython.lib.pretty._repr_pprint>,
    float: <function IPython.core.formatters.PlainTextFormatter._type_printers_default.<locals>.<lambda>>,
    datetime.datetime: <function IPython.lib.pretty._repr_pprint>,
    set: <function IPython.lib.pretty._set_pprinter_factory.<locals>.inner>,
    BaseException: <function IPython.lib.pretty._exception_pprint>,
    function: <function IPython.lib.pretty._function_pprint>,
    _sre.SRE_Pattern: <function IPython.lib.pretty._re_pattern_pprint>,
    dict: <function IPython.lib.pretty._dict_pprinter_factory.<locals>.inner>,
    builtin_function_or_method: <function IPython.lib.pretty._function_pprint>,
    slice: <function IPython.lib.pretty._repr_pprint>,
    str: <function IPython.lib.pretty._repr_pprint>,
    range: <function IPython.lib.pretty._repr_pprint>,
    type: <function IPython.lib.pretty._type_pprint>,
    list: <function IPython.lib.pretty._seq_pprinter_factory.<locals>.inner>,
    super: <function IPython.lib.pretty._super_pprint>,
    bytes: <function IPython.lib.pretty._repr_pprint>,
    int: <function IPython.lib.pretty._repr_pprint>,
    datetime.timedelta: <function IPython.lib.pretty._repr_pprint>},
   'verbose': False}},
 [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>],
 {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]},
 {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
 {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
  'deferred_printers': {('collections',
    'Counter'): <function IPython.lib.pretty._counter_pprint>,
   ('collections',
    'OrderedDict'): <function IPython.lib.pretty._ordereddict_pprint>,
   ('collections',
    'defaultdict'): <function IPython.lib.pretty._defaultdict_pprint>,
   ('collections', 'deque'): <function IPython.lib.pretty._deque_pprint>},
  'enabled': True,
  'float_format': '%r',
  'float_precision': '',
  'format_type': 'text/plain',
  'max_seq_length': 1000,
  'max_width': 79,
  'newline': '\n',
  'parent': <IPython.core.formatters.DisplayFormatter at 0x7f51c0113400>,
  'pprint': True,
  'print_method': '_repr_pretty_',
  'singleton_printers': {139989402110976: <function IPython.lib.pretty._repr_pprint>,
   139989402111008: <function IPython.lib.pretty._repr_pprint>,
   139989402204240: <function IPython.lib.pretty._repr_pprint>,
   139989402204656: <function IPython.lib.pretty._repr_pprint>,
   139989402216560: <function IPython.lib.pretty._repr_pprint>},
  'type_printers': {tuple: <function IPython.lib.pretty._seq_pprinter_factory.<locals>.inner>,
   frozenset: <function IPython.lib.pretty._set_pprinter_factory.<locals>.inner>,
   method: <function IPython.lib.pretty._repr_pprint>,
   float: <function IPython.core.formatters.PlainTextFormatter._type_printers_default.<locals>.<lambda>>,
   datetime.datetime: <function IPython.lib.pretty._repr_pprint>,
   set: <function IPython.lib.pretty._set_pprinter_factory.<locals>.inner>,
   BaseException: <function IPython.lib.pretty._exception_pprint>,
   function: <function IPython.lib.pretty._function_pprint>,
   _sre.SRE_Pattern: <function IPython.lib.pretty._re_pattern_pprint>,
   dict: <function IPython.lib.pretty._dict_pprinter_factory.<locals>.inner>,
   builtin_function_or_method: <function IPython.lib.pretty._function_pprint>,
   slice: <function IPython.lib.pretty._repr_pprint>,
   str: <function IPython.lib.pretty._repr_pprint>,
   range: <function IPython.lib.pretty._repr_pprint>,
   type: <function IPython.lib.pretty._type_pprint>,
   list: <function IPython.lib.pretty._seq_pprinter_factory.<locals>.inner>,
   super: <function IPython.lib.pretty._super_pprint>,
   bytes: <function IPython.lib.pretty._repr_pprint>,
   int: <function IPython.lib.pretty._repr_pprint>,
   datetime.timedelta: <function IPython.lib.pretty._repr_pprint>},
  'verbose': False},
 {'application/javascript': <IPython.core.formatters.JavascriptFormatter at 0x7f51c006e390>,
  'application/json': <IPython.core.formatters.JSONFormatter at 0x7f51c006e358>,
  'application/pdf': <IPython.core.formatters.PDFFormatter at 0x7f51c006e5c0>,
  'image/jpeg': <IPython.core.formatters.JPEGFormatter at 0x7f51c006e668>,
  'image/png': <IPython.core.formatters.PNGFormatter at 0x7f51c006e518>,
  'image/svg+xml': <IPython.core.formatters.SVGFormatter at 0x7f51c006e5f8>,
  'text/html': <IPython.core.formatters.HTMLFormatter at 0x7f51c006e438>,
  'text/latex': <IPython.core.formatters.LatexFormatter at 0x7f51c006e630>,
  'text/markdown': <IPython.core.formatters.MarkdownFormatter at 0x7f51c006e588>,
  'text/plain': <IPython.core.formatters.PlainTextFormatter at 0x7f51c006e4a8>},
 <IPython.core.formatters.HTMLFormatter at 0x7f51c006e438>,
 {'_cross_validation_lock': False,
  '_trait_notifiers': {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
  '_trait_validators': {},
  '_trait_values': {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
   'deferred_printers': {},
   'enabled': True,
   'format_type': 'text/html',
   'parent': <IPython.core.formatters.DisplayFormatter at 0x7f51c0113400>,
   'print_method': '_repr_html_',
   'singleton_printers': {},
   'type_printers': {}}},
 [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>],
 {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]},
 {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
 {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
  'deferred_printers': {},
  'enabled': True,
  'format_type': 'text/html',
  'parent': <IPython.core.formatters.DisplayFormatter at 0x7f51c0113400>,
  'print_method': '_repr_html_',
  'singleton_printers': {},
  'type_printers': {}},
 <IPython.core.formatters.MarkdownFormatter at 0x7f51c006e588>,
 {'_cross_validation_lock': False,
  '_trait_notifiers': {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
  '_trait_validators': {},
  '_trait_values': {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
   'deferred_printers': {},
   'enabled': True,
   'format_type': 'text/markdown',
   'parent': <IPython.core.formatters.DisplayFormatter at 0x7f51c0113400>,
   'print_method': '_repr_markdown_',
   'singleton_printers': {},
   'type_printers': {}}},
 [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>],
 {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]},
 {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
 {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
  'deferred_printers': {},
  'enabled': True,
  'format_type': 'text/markdown',
  'parent': <IPython.core.formatters.DisplayFormatter at 0x7f51c0113400>,
  'print_method': '_repr_markdown_',
  'singleton_printers': {},
  'type_printers': {}},
 <IPython.core.formatters.SVGFormatter at 0x7f51c006e5f8>,
 {'_cross_validation_lock': False,
  '_trait_notifiers': {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
  '_trait_validators': {},
  '_trait_values': {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
   'deferred_printers': {},
   'enabled': True,
   'format_type': 'image/svg+xml',
   'parent': <IPython.core.formatters.DisplayFormatter at 0x7f51c0113400>,
   'print_method': '_repr_svg_',
   'singleton_printers': {},
   'type_printers': {}}},
 [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>],
 {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]},
 {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
 {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
  'deferred_printers': {},
  'enabled': True,
  'format_type': 'image/svg+xml',
  'parent': <IPython.core.formatters.DisplayFormatter at 0x7f51c0113400>,
  'print_method': '_repr_svg_',
  'singleton_printers': {},
  'type_printers': {}},
 <IPython.core.formatters.PNGFormatter at 0x7f51c006e518>,
 {'_cross_validation_lock': False,
  '_trait_notifiers': {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
  '_trait_validators': {},
  '_trait_values': {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
   'deferred_printers': {},
   'enabled': True,
   'format_type': 'image/png',
   'parent': <IPython.core.formatters.DisplayFormatter at 0x7f51c0113400>,
   'print_method': '_repr_png_',
   'singleton_printers': {},
   'type_printers': {}}},
 [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>],
 {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]},
 {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
 {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
  'deferred_printers': {},
  'enabled': True,
  'format_type': 'image/png',
  'parent': <IPython.core.formatters.DisplayFormatter at 0x7f51c0113400>,
  'print_method': '_repr_png_',
  'singleton_printers': {},
  'type_printers': {}},
 <IPython.core.formatters.PDFFormatter at 0x7f51c006e5c0>,
 {'_cross_validation_lock': False,
  '_trait_notifiers': {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
  '_trait_validators': {},
  '_trait_values': {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
   'deferred_printers': {},
   'enabled': True,
   'format_type': 'application/pdf',
   'parent': <IPython.core.formatters.DisplayFormatter at 0x7f51c0113400>,
   'print_method': '_repr_pdf_',
   'singleton_printers': {},
   'type_printers': {}}},
 [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>],
 {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]},
 {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
 {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
  'deferred_printers': {},
  'enabled': True,
  'format_type': 'application/pdf',
  'parent': <IPython.core.formatters.DisplayFormatter at 0x7f51c0113400>,
  'print_method': '_repr_pdf_',
  'singleton_printers': {},
  'type_printers': {}},
 <IPython.core.formatters.JPEGFormatter at 0x7f51c006e668>,
 {'_cross_validation_lock': False,
  '_trait_notifiers': {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
  '_trait_validators': {},
  '_trait_values': {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
   'deferred_printers': {},
   'enabled': True,
   'format_type': 'image/jpeg',
   'parent': <IPython.core.formatters.DisplayFormatter at 0x7f51c0113400>,
   'print_method': '_repr_jpeg_',
   'singleton_printers': {},
   'type_printers': {}}},
 [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>],
 {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]},
 {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
 {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
  'deferred_printers': {},
  'enabled': True,
  'format_type': 'image/jpeg',
  'parent': <IPython.core.formatters.DisplayFormatter at 0x7f51c0113400>,
  'print_method': '_repr_jpeg_',
  'singleton_printers': {},
  'type_printers': {}},
 <IPython.core.formatters.LatexFormatter at 0x7f51c006e630>,
 {'_cross_validation_lock': False,
  '_trait_notifiers': {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
  '_trait_validators': {},
  '_trait_values': {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
   'deferred_printers': {},
   'enabled': True,
   'format_type': 'text/latex',
   'parent': <IPython.core.formatters.DisplayFormatter at 0x7f51c0113400>,
   'print_method': '_repr_latex_',
   'singleton_printers': {},
   'type_printers': {}}},
 [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>],
 {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]},
 {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
 {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
  'deferred_printers': {},
  'enabled': True,
  'format_type': 'text/latex',
  'parent': <IPython.core.formatters.DisplayFormatter at 0x7f51c0113400>,
  'print_method': '_repr_latex_',
  'singleton_printers': {},
  'type_printers': {}},
 <IPython.core.formatters.JSONFormatter at 0x7f51c006e358>,
 {'_cross_validation_lock': False,
  '_trait_notifiers': {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
  '_trait_validators': {},
  '_trait_values': {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
   'deferred_printers': {},
   'enabled': True,
   'format_type': 'application/json',
   'parent': <IPython.core.formatters.DisplayFormatter at 0x7f51c0113400>,
   'print_method': '_repr_json_',
   'singleton_printers': {},
   'type_printers': {}}},
 [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>],
 {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]},
 {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
 {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
  'deferred_printers': {},
  'enabled': True,
  'format_type': 'application/json',
  'parent': <IPython.core.formatters.DisplayFormatter at 0x7f51c0113400>,
  'print_method': '_repr_json_',
  'singleton_printers': {},
  'type_printers': {}},
 <IPython.core.formatters.JavascriptFormatter at 0x7f51c006e390>,
 {'_cross_validation_lock': False,
  '_trait_notifiers': {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
  '_trait_validators': {},
  '_trait_values': {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
   'deferred_printers': {},
   'enabled': True,
   'format_type': 'application/javascript',
   'parent': <IPython.core.formatters.DisplayFormatter at 0x7f51c0113400>,
   'print_method': '_repr_javascript_',
   'singleton_printers': {},
   'type_printers': {}}},
 [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>],
 {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]},
 {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
 {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
  'deferred_printers': {},
  'enabled': True,
  'format_type': 'application/javascript',
  'parent': <IPython.core.formatters.DisplayFormatter at 0x7f51c0113400>,
  'print_method': '_repr_javascript_',
  'singleton_printers': {},
  'type_printers': {}},
 {139989402110976: <function IPython.lib.pretty._repr_pprint>,
  139989402111008: <function IPython.lib.pretty._repr_pprint>,
  139989402204240: <function IPython.lib.pretty._repr_pprint>,
  139989402204656: <function IPython.lib.pretty._repr_pprint>,
  139989402216560: <function IPython.lib.pretty._repr_pprint>},
 <cell at 0x7f51c0149fd8: PlainTextFormatter object at 0x7f51c006e4a8>,
 {tuple: <function IPython.lib.pretty._seq_pprinter_factory.<locals>.inner>,
  frozenset: <function IPython.lib.pretty._set_pprinter_factory.<locals>.inner>,
  method: <function IPython.lib.pretty._repr_pprint>,
  float: <function IPython.core.formatters.PlainTextFormatter._type_printers_default.<locals>.<lambda>>,
  datetime.datetime: <function IPython.lib.pretty._repr_pprint>,
  set: <function IPython.lib.pretty._set_pprinter_factory.<locals>.inner>,
  BaseException: <function IPython.lib.pretty._exception_pprint>,
  function: <function IPython.lib.pretty._function_pprint>,
  _sre.SRE_Pattern: <function IPython.lib.pretty._re_pattern_pprint>,
  dict: <function IPython.lib.pretty._dict_pprinter_factory.<locals>.inner>,
  builtin_function_or_method: <function IPython.lib.pretty._function_pprint>,
  slice: <function IPython.lib.pretty._repr_pprint>,
  str: <function IPython.lib.pretty._repr_pprint>,
  range: <function IPython.lib.pretty._repr_pprint>,
  type: <function IPython.lib.pretty._type_pprint>,
  list: <function IPython.lib.pretty._seq_pprinter_factory.<locals>.inner>,
  super: <function IPython.lib.pretty._super_pprint>,
  bytes: <function IPython.lib.pretty._repr_pprint>,
  int: <function IPython.lib.pretty._repr_pprint>,
  datetime.timedelta: <function IPython.lib.pretty._repr_pprint>},
 (<cell at 0x7f51c0149fd8: PlainTextFormatter object at 0x7f51c006e4a8>,),
 <function IPython.core.formatters.PlainTextFormatter._type_printers_default.<locals>.<lambda>>,
 {('collections', 'Counter'): <function IPython.lib.pretty._counter_pprint>,
  ('collections',
   'OrderedDict'): <function IPython.lib.pretty._ordereddict_pprint>,
  ('collections',
   'defaultdict'): <function IPython.lib.pretty._defaultdict_pprint>,
  ('collections', 'deque'): <function IPython.lib.pretty._deque_pprint>},
 ['pick([1, 2, 3], 2)\n'],
 (19,
  1458427476.3872025,
  ['pick([1, 2, 3], 2)\n'],
  '<ipython-input-15-af0e982457fa>'),
 <weakref at 0x7f51c0057368; dead>,
 [],
 <frame at 0x55b8f5478ba8>,
 (<zmq.sugar.socket.Socket at 0x7f51c11eaca8>, 1),
 <frame at 0x7f51c0051448>,
 <frame at 0x7f51b4003988>,
 <zmq.sugar.frame.Frame at 0x7f51c00d3d38>,
 [<zmq.sugar.frame.Frame at 0x7f51c00d3d38>,
  <zmq.sugar.frame.Frame at 0x7f51c00591b8>,
  <zmq.sugar.frame.Frame at 0x7f51c0059270>,
  <zmq.sugar.frame.Frame at 0x7f51c0059328>,
  <zmq.sugar.frame.Frame at 0x7f51c00593e0>,
  <zmq.sugar.frame.Frame at 0x7f51c0059498>,
  <zmq.sugar.frame.Frame at 0x7f51c0059550>],
 <zmq.sugar.frame.Frame at 0x7f51c00591b8>,
 <zmq.sugar.frame.Frame at 0x7f51c0059270>,
 <zmq.sugar.frame.Frame at 0x7f51c0059328>,
 <zmq.sugar.frame.Frame at 0x7f51c00593e0>,
 <zmq.sugar.frame.Frame at 0x7f51c0059498>,
 <zmq.sugar.frame.Frame at 0x7f51c0059550>,
 <frame at 0x55b8f5453b18>,
 ([<zmq.sugar.frame.Frame at 0x7f51c00d3d38>,
   <zmq.sugar.frame.Frame at 0x7f51c00591b8>,
   <zmq.sugar.frame.Frame at 0x7f51c0059270>,
   <zmq.sugar.frame.Frame at 0x7f51c0059328>,
   <zmq.sugar.frame.Frame at 0x7f51c00593e0>,
   <zmq.sugar.frame.Frame at 0x7f51c0059498>,
   <zmq.sugar.frame.Frame at 0x7f51c0059550>],),
 ((), None),
 <frame at 0x7f51b4002c68>,
 ([<zmq.sugar.frame.Frame at 0x7f51c00d3d38>,
   <zmq.sugar.frame.Frame at 0x7f51c00591b8>,
   <zmq.sugar.frame.Frame at 0x7f51c0059270>,
   <zmq.sugar.frame.Frame at 0x7f51c0059328>,
   <zmq.sugar.frame.Frame at 0x7f51c00593e0>,
   <zmq.sugar.frame.Frame at 0x7f51c0059498>,
   <zmq.sugar.frame.Frame at 0x7f51c0059550>],),
 <frame at 0x7f51c004e9a8>,
 <frame at 0x55b8f5453e48>,
 [b'C7DE1DB7B2DD4D1FA63D6B1AAEF49737'],
 {'buffers': [],
  'content': {'allow_stdin': True,
   'code': "pick([1, 2, 3], '2')",
   'silent': False,
   'stop_on_error': True,
   'store_history': True,
   'user_expressions': {}},
  'header': {'date': '2016-03-20T01:44:44.341120',
   'msg_id': '087198E1BE4D48298E906BF6971E9E9A',
   'msg_type': 'execute_request',
   'session': 'C7DE1DB7B2DD4D1FA63D6B1AAEF49737',
   'username': 'username',
   'version': '5.0'},
  'metadata': {},
  'msg_id': '087198E1BE4D48298E906BF6971E9E9A',
  'msg_type': 'execute_request',
  'parent_header': {}},
 {'allow_stdin': True,
  'code': "pick([1, 2, 3], '2')",
  'silent': False,
  'stop_on_error': True,
  'store_history': True,
  'user_expressions': {}},
 [],
 <frame at 0x55b8f5445bb8>,
 <frame at 0x55b8f54540e8>,
 <frame at 0x55b8f5455958>,
 <cell at 0x7f51c00bd768: ExecutionResult object at 0x7f51c006bfd0>,
 <IPython.core.interactiveshell.ExecutionResult at 0x7f51c006bfd0>,
 (<cell at 0x7f51c00bd768: ExecutionResult object at 0x7f51c006bfd0>,),
 <function IPython.core.interactiveshell.InteractiveShell.run_cell.<locals>.error_before_exec>,
 ["pick([1, 2, 3], '2')\n"],
 (21,
  1458427484.3528702,
  ["pick([1, 2, 3], '2')\n"],
  '<ipython-input-16-48b0526ba3da>'),
 <_ast.Module at 0x7f51c006b9b0>,
 [<_ast.Expr at 0x7f51c006b9e8>],
 <_ast.Expr at 0x7f51c006b9e8>,
 <_ast.Call at 0x7f51c006bc88>,
 <_ast.Name at 0x7f51c006b128>,
 {'col_offset': 0,
  'ctx': <_ast.Load at 0x7f51c972e630>,
  'id': 'pick',
  'lineno': 1},
 {'args': [<_ast.List at 0x7f51c006b0b8>, <_ast.Str at 0x7f51c006b6a0>],
  'col_offset': 0,
  'func': <_ast.Name at 0x7f51c006b128>,
  'keywords': [],
  'kwargs': None,
  'lineno': 1,
  'starargs': None},
 [<_ast.List at 0x7f51c006b0b8>, <_ast.Str at 0x7f51c006b6a0>],
 <_ast.List at 0x7f51c006b0b8>,
 [<_ast.Num at 0x7f51c006b048>,
  <_ast.Num at 0x7f51c006b198>,
  <_ast.Num at 0x7f51c006bc18>],
 <_ast.Num at 0x7f51c006b048>,
 <_ast.Num at 0x7f51c006b198>,
 <_ast.Num at 0x7f51c006bc18>,
 {'col_offset': 5,
  'ctx': <_ast.Load at 0x7f51c972e630>,
  'elts': [<_ast.Num at 0x7f51c006b048>,
   <_ast.Num at 0x7f51c006b198>,
   <_ast.Num at 0x7f51c006bc18>],
  'lineno': 1},
 <_ast.Str at 0x7f51c006b6a0>,
 [],
 {'col_offset': 0, 'lineno': 1, 'value': <_ast.Call at 0x7f51c006bc88>},
 {'body': [<_ast.Expr at 0x7f51c006b9e8>]},
 <frame at 0x55b8f5479628>,
 [],
 [<_ast.Expr at 0x7f51c006b9e8>],
 [<_ast.Expr at 0x7f51c006b9e8>],
 <_ast.Interactive at 0x7f51c006b2b0>,
 {'body': [<_ast.Expr at 0x7f51c006b9e8>]},
 ('pick',),
 (1, 2, 3, '2', None),
 <frame at 0x55b8f54798f8>,
 <frame at 0x7f51c005c630>,
 [1, 2, 3],
 <frame at 0x55b8f545d198>,
 <traceback at 0x7f51c0076808>,
 <traceback at 0x7f51c0085148>,
 <traceback at 0x7f51c0085108>,
 ('list indices must be integers, not str',),
 TypeError('list indices must be integers, not str'),
 {'error_in_exec': TypeError('list indices must be integers, not str'),
  'execution_count': 16},
 <weakref at 0x7f51c0064908; dead>,
 {'index': '2', 'l': [1, 2, 3]},
 ['\x1b[1;31m---------------------------------------------------------------------------\x1b[0m',
  '\x1b[1;31mTypeError\x1b[0m                                 Traceback (most recent call last)',
  "\x1b[1;32m<ipython-input-16-48b0526ba3da>\x1b[0m in \x1b[0;36m<module>\x1b[1;34m()\x1b[0m\n\x1b[1;32m----> 1\x1b[1;33m \x1b[0mpick\x1b[0m\x1b[1;33m(\x1b[0m\x1b[1;33m[\x1b[0m\x1b[1;36m1\x1b[0m\x1b[1;33m,\x1b[0m \x1b[1;36m2\x1b[0m\x1b[1;33m,\x1b[0m \x1b[1;36m3\x1b[0m\x1b[1;33m]\x1b[0m\x1b[1;33m,\x1b[0m \x1b[1;34m'2'\x1b[0m\x1b[1;33m)\x1b[0m\x1b[1;33m\x1b[0m\x1b[0m\n\x1b[0m",
  '\x1b[1;32m<ipython-input-14-345e48108d28>\x1b[0m in \x1b[0;36mpick\x1b[1;34m(l, index)\x1b[0m\n\x1b[0;32m      1\x1b[0m \x1b[1;32mdef\x1b[0m \x1b[0mpick\x1b[0m\x1b[1;33m(\x1b[0m\x1b[0ml\x1b[0m\x1b[1;33m:\x1b[0m \x1b[0mlist\x1b[0m\x1b[1;33m,\x1b[0m \x1b[0mindex\x1b[0m\x1b[1;33m:\x1b[0m \x1b[0mint\x1b[0m\x1b[1;33m)\x1b[0m \x1b[1;33m->\x1b[0m \x1b[0mint\x1b[0m\x1b[1;33m:\x1b[0m\x1b[1;33m\x1b[0m\x1b[0m\n\x1b[1;32m----> 2\x1b[1;33m     \x1b[1;32mreturn\x1b[0m \x1b[0ml\x1b[0m\x1b[1;33m[\x1b[0m\x1b[0mindex\x1b[0m\x1b[1;33m]\x1b[0m\x1b[1;33m\x1b[0m\x1b[0m\n\x1b[0m\x1b[0;32m      3\x1b[0m \x1b[1;33m\x1b[0m\x1b[0m\n\x1b[0;32m      4\x1b[0m \x1b[0mpick\x1b[0m\x1b[1;33m(\x1b[0m\x1b[1;33m[\x1b[0m\x1b[1;36m1\x1b[0m\x1b[1;33m,\x1b[0m \x1b[1;36m2\x1b[0m\x1b[1;33m,\x1b[0m \x1b[1;36m3\x1b[0m\x1b[1;33m]\x1b[0m\x1b[1;33m,\x1b[0m \x1b[1;36m2\x1b[0m\x1b[1;33m)\x1b[0m\x1b[1;33m\x1b[0m\x1b[0m\n',
  '\x1b[1;31mTypeError\x1b[0m: list indices must be integers, not str'],
 {'ename': 'TypeError',
  'engine_info': {'engine_id': -1,
   'engine_uuid': '60debbe5-9e37-44be-8878-88c400d6728c',
   'method': 'execute'},
  'evalue': 'list indices must be integers, not str',
  'execution_count': 16,
  'payload': [],
  'status': 'error',
  'traceback': ['\x1b[1;31m---------------------------------------------------------------------------\x1b[0m',
   '\x1b[1;31mTypeError\x1b[0m                                 Traceback (most recent call last)',
   "\x1b[1;32m<ipython-input-16-48b0526ba3da>\x1b[0m in \x1b[0;36m<module>\x1b[1;34m()\x1b[0m\n\x1b[1;32m----> 1\x1b[1;33m \x1b[0mpick\x1b[0m\x1b[1;33m(\x1b[0m\x1b[1;33m[\x1b[0m\x1b[1;36m1\x1b[0m\x1b[1;33m,\x1b[0m \x1b[1;36m2\x1b[0m\x1b[1;33m,\x1b[0m \x1b[1;36m3\x1b[0m\x1b[1;33m]\x1b[0m\x1b[1;33m,\x1b[0m \x1b[1;34m'2'\x1b[0m\x1b[1;33m)\x1b[0m\x1b[1;33m\x1b[0m\x1b[0m\n\x1b[0m",
   '\x1b[1;32m<ipython-input-14-345e48108d28>\x1b[0m in \x1b[0;36mpick\x1b[1;34m(l, index)\x1b[0m\n\x1b[0;32m      1\x1b[0m \x1b[1;32mdef\x1b[0m \x1b[0mpick\x1b[0m\x1b[1;33m(\x1b[0m\x1b[0ml\x1b[0m\x1b[1;33m:\x1b[0m \x1b[0mlist\x1b[0m\x1b[1;33m,\x1b[0m \x1b[0mindex\x1b[0m\x1b[1;33m:\x1b[0m \x1b[0mint\x1b[0m\x1b[1;33m)\x1b[0m \x1b[1;33m->\x1b[0m \x1b[0mint\x1b[0m\x1b[1;33m:\x1b[0m\x1b[1;33m\x1b[0m\x1b[0m\n\x1b[1;32m----> 2\x1b[1;33m     \x1b[1;32mreturn\x1b[0m \x1b[0ml\x1b[0m\x1b[1;33m[\x1b[0m\x1b[0mindex\x1b[0m\x1b[1;33m]\x1b[0m\x1b[1;33m\x1b[0m\x1b[0m\n\x1b[0m\x1b[0;32m      3\x1b[0m \x1b[1;33m\x1b[0m\x1b[0m\n\x1b[0;32m      4\x1b[0m \x1b[0mpick\x1b[0m\x1b[1;33m(\x1b[0m\x1b[1;33m[\x1b[0m\x1b[1;36m1\x1b[0m\x1b[1;33m,\x1b[0m \x1b[1;36m2\x1b[0m\x1b[1;33m,\x1b[0m \x1b[1;36m3\x1b[0m\x1b[1;33m]\x1b[0m\x1b[1;33m,\x1b[0m \x1b[1;36m2\x1b[0m\x1b[1;33m)\x1b[0m\x1b[1;33m\x1b[0m\x1b[0m\n',
   '\x1b[1;31mTypeError\x1b[0m: list indices must be integers, not str'],
  'user_expressions': {}},
 [],
 {'ename': 'TypeError',
  'engine_info': {'engine_id': -1,
   'engine_uuid': '60debbe5-9e37-44be-8878-88c400d6728c',
   'method': 'execute'},
  'evalue': 'list indices must be integers, not str',
  'execution_count': 16,
  'payload': [],
  'status': 'error',
  'traceback': ['\x1b[1;31m---------------------------------------------------------------------------\x1b[0m',
   '\x1b[1;31mTypeError\x1b[0m                                 Traceback (most recent call last)',
   "\x1b[1;32m<ipython-input-16-48b0526ba3da>\x1b[0m in \x1b[0;36m<module>\x1b[1;34m()\x1b[0m\n\x1b[1;32m----> 1\x1b[1;33m \x1b[0mpick\x1b[0m\x1b[1;33m(\x1b[0m\x1b[1;33m[\x1b[0m\x1b[1;36m1\x1b[0m\x1b[1;33m,\x1b[0m \x1b[1;36m2\x1b[0m\x1b[1;33m,\x1b[0m \x1b[1;36m3\x1b[0m\x1b[1;33m]\x1b[0m\x1b[1;33m,\x1b[0m \x1b[1;34m'2'\x1b[0m\x1b[1;33m)\x1b[0m\x1b[1;33m\x1b[0m\x1b[0m\n\x1b[0m",
   '\x1b[1;32m<ipython-input-14-345e48108d28>\x1b[0m in \x1b[0;36mpick\x1b[1;34m(l, index)\x1b[0m\n\x1b[0;32m      1\x1b[0m \x1b[1;32mdef\x1b[0m \x1b[0mpick\x1b[0m\x1b[1;33m(\x1b[0m\x1b[0ml\x1b[0m\x1b[1;33m:\x1b[0m \x1b[0mlist\x1b[0m\x1b[1;33m,\x1b[0m \x1b[0mindex\x1b[0m\x1b[1;33m:\x1b[0m \x1b[0mint\x1b[0m\x1b[1;33m)\x1b[0m \x1b[1;33m->\x1b[0m \x1b[0mint\x1b[0m\x1b[1;33m:\x1b[0m\x1b[1;33m\x1b[0m\x1b[0m\n\x1b[1;32m----> 2\x1b[1;33m     \x1b[1;32mreturn\x1b[0m \x1b[0ml\x1b[0m\x1b[1;33m[\x1b[0m\x1b[0mindex\x1b[0m\x1b[1;33m]\x1b[0m\x1b[1;33m\x1b[0m\x1b[0m\n\x1b[0m\x1b[0;32m      3\x1b[0m \x1b[1;33m\x1b[0m\x1b[0m\n\x1b[0;32m      4\x1b[0m \x1b[0mpick\x1b[0m\x1b[1;33m(\x1b[0m\x1b[1;33m[\x1b[0m\x1b[1;36m1\x1b[0m\x1b[1;33m,\x1b[0m \x1b[1;36m2\x1b[0m\x1b[1;33m,\x1b[0m \x1b[1;36m3\x1b[0m\x1b[1;33m]\x1b[0m\x1b[1;33m,\x1b[0m \x1b[1;36m2\x1b[0m\x1b[1;33m)\x1b[0m\x1b[1;33m\x1b[0m\x1b[0m\n',
   '\x1b[1;31mTypeError\x1b[0m: list indices must be integers, not str'],
  'user_expressions': {}},
 ['\x1b[1;31m---------------------------------------------------------------------------\x1b[0m',
  '\x1b[1;31mTypeError\x1b[0m                                 Traceback (most recent call last)',
  "\x1b[1;32m<ipython-input-16-48b0526ba3da>\x1b[0m in \x1b[0;36m<module>\x1b[1;34m()\x1b[0m\n\x1b[1;32m----> 1\x1b[1;33m \x1b[0mpick\x1b[0m\x1b[1;33m(\x1b[0m\x1b[1;33m[\x1b[0m\x1b[1;36m1\x1b[0m\x1b[1;33m,\x1b[0m \x1b[1;36m2\x1b[0m\x1b[1;33m,\x1b[0m \x1b[1;36m3\x1b[0m\x1b[1;33m]\x1b[0m\x1b[1;33m,\x1b[0m \x1b[1;34m'2'\x1b[0m\x1b[1;33m)\x1b[0m\x1b[1;33m\x1b[0m\x1b[0m\n\x1b[0m",
  '\x1b[1;32m<ipython-input-14-345e48108d28>\x1b[0m in \x1b[0;36mpick\x1b[1;34m(l, index)\x1b[0m\n\x1b[0;32m      1\x1b[0m \x1b[1;32mdef\x1b[0m \x1b[0mpick\x1b[0m\x1b[1;33m(\x1b[0m\x1b[0ml\x1b[0m\x1b[1;33m:\x1b[0m \x1b[0mlist\x1b[0m\x1b[1;33m,\x1b[0m \x1b[0mindex\x1b[0m\x1b[1;33m:\x1b[0m \x1b[0mint\x1b[0m\x1b[1;33m)\x1b[0m \x1b[1;33m->\x1b[0m \x1b[0mint\x1b[0m\x1b[1;33m:\x1b[0m\x1b[1;33m\x1b[0m\x1b[0m\n\x1b[1;32m----> 2\x1b[1;33m     \x1b[1;32mreturn\x1b[0m \x1b[0ml\x1b[0m\x1b[1;33m[\x1b[0m\x1b[0mindex\x1b[0m\x1b[1;33m]\x1b[0m\x1b[1;33m\x1b[0m\x1b[0m\n\x1b[0m\x1b[0;32m      3\x1b[0m \x1b[1;33m\x1b[0m\x1b[0m\n\x1b[0;32m      4\x1b[0m \x1b[0mpick\x1b[0m\x1b[1;33m(\x1b[0m\x1b[1;33m[\x1b[0m\x1b[1;36m1\x1b[0m\x1b[1;33m,\x1b[0m \x1b[1;36m2\x1b[0m\x1b[1;33m,\x1b[0m \x1b[1;36m3\x1b[0m\x1b[1;33m]\x1b[0m\x1b[1;33m,\x1b[0m \x1b[1;36m2\x1b[0m\x1b[1;33m)\x1b[0m\x1b[1;33m\x1b[0m\x1b[0m\n',
  '\x1b[1;31mTypeError\x1b[0m: list indices must be integers, not str'],
 {'content': {'ename': 'TypeError',
   'engine_info': {'engine_id': -1,
    'engine_uuid': '60debbe5-9e37-44be-8878-88c400d6728c',
    'method': 'execute'},
   'evalue': 'list indices must be integers, not str',
   'execution_count': 16,
   'payload': [],
   'status': 'error',
   'traceback': ['\x1b[1;31m---------------------------------------------------------------------------\x1b[0m',
    '\x1b[1;31mTypeError\x1b[0m                                 Traceback (most recent call last)',
    "\x1b[1;32m<ipython-input-16-48b0526ba3da>\x1b[0m in \x1b[0;36m<module>\x1b[1;34m()\x1b[0m\n\x1b[1;32m----> 1\x1b[1;33m \x1b[0mpick\x1b[0m\x1b[1;33m(\x1b[0m\x1b[1;33m[\x1b[0m\x1b[1;36m1\x1b[0m\x1b[1;33m,\x1b[0m \x1b[1;36m2\x1b[0m\x1b[1;33m,\x1b[0m \x1b[1;36m3\x1b[0m\x1b[1;33m]\x1b[0m\x1b[1;33m,\x1b[0m \x1b[1;34m'2'\x1b[0m\x1b[1;33m)\x1b[0m\x1b[1;33m\x1b[0m\x1b[0m\n\x1b[0m",
    '\x1b[1;32m<ipython-input-14-345e48108d28>\x1b[0m in \x1b[0;36mpick\x1b[1;34m(l, index)\x1b[0m\n\x1b[0;32m      1\x1b[0m \x1b[1;32mdef\x1b[0m \x1b[0mpick\x1b[0m\x1b[1;33m(\x1b[0m\x1b[0ml\x1b[0m\x1b[1;33m:\x1b[0m \x1b[0mlist\x1b[0m\x1b[1;33m,\x1b[0m \x1b[0mindex\x1b[0m\x1b[1;33m:\x1b[0m \x1b[0mint\x1b[0m\x1b[1;33m)\x1b[0m \x1b[1;33m->\x1b[0m \x1b[0mint\x1b[0m\x1b[1;33m:\x1b[0m\x1b[1;33m\x1b[0m\x1b[0m\n\x1b[1;32m----> 2\x1b[1;33m     \x1b[1;32mreturn\x1b[0m \x1b[0ml\x1b[0m\x1b[1;33m[\x1b[0m\x1b[0mindex\x1b[0m\x1b[1;33m]\x1b[0m\x1b[1;33m\x1b[0m\x1b[0m\n\x1b[0m\x1b[0;32m      3\x1b[0m \x1b[1;33m\x1b[0m\x1b[0m\n\x1b[0;32m      4\x1b[0m \x1b[0mpick\x1b[0m\x1b[1;33m(\x1b[0m\x1b[1;33m[\x1b[0m\x1b[1;36m1\x1b[0m\x1b[1;33m,\x1b[0m \x1b[1;36m2\x1b[0m\x1b[1;33m,\x1b[0m \x1b[1;36m3\x1b[0m\x1b[1;33m]\x1b[0m\x1b[1;33m,\x1b[0m \x1b[1;36m2\x1b[0m\x1b[1;33m)\x1b[0m\x1b[1;33m\x1b[0m\x1b[0m\n',
    '\x1b[1;31mTypeError\x1b[0m: list indices must be integers, not str'],
   'user_expressions': {}},
  'header': {'date': datetime.datetime(2016, 3, 20, 1, 44, 44, 397010),
   'msg_id': 'af24561a-19fb-429b-a859-0f3c966193e6',
   'msg_type': 'execute_reply',
   'session': 'bbd10ed7-5a2c-43a4-98b6-3a4760409ca6',
   'username': 'pasha',
   'version': '5.0'},
  'metadata': {'dependencies_met': True,
   'engine': '60debbe5-9e37-44be-8878-88c400d6728c',
   'started': datetime.datetime(2016, 3, 20, 1, 44, 44, 349092),
   'status': 'error'},
  'msg_id': 'af24561a-19fb-429b-a859-0f3c966193e6',
  'msg_type': 'execute_reply',
  'parent_header': {'date': '2016-03-20T01:44:44.341120',
   'msg_id': '087198E1BE4D48298E906BF6971E9E9A',
   'msg_type': 'execute_request',
   'session': 'C7DE1DB7B2DD4D1FA63D6B1AAEF49737',
   'username': 'username',
   'version': '5.0'},
  'tracker': <zmq.sugar.tracker.MessageTracker at 0x7f51c2222b38>},
 ['import gc\n'],
 (10, 1458492336.533345, ['import gc\n'], '<ipython-input-17-9c3271702575>'),
 [],
 <weakref at 0x7f51c00649a8; dead>,
 <frame at 0x55b8f5438048>,
 (<zmq.sugar.socket.Socket at 0x7f51c11eaca8>, 1),
 <frame at 0x7f51c00bfc48>,
 <frame at 0x55b8f5455ff8>,
 <zmq.sugar.frame.Frame at 0x7f51c0059048>,
 [<zmq.sugar.frame.Frame at 0x7f51c0059048>,
  <zmq.sugar.frame.Frame at 0x7f51c0059b10>,
  <zmq.sugar.frame.Frame at 0x7f51c0059bc8>,
  <zmq.sugar.frame.Frame at 0x7f51c0059c80>,
  <zmq.sugar.frame.Frame at 0x7f51c0059d38>,
  <zmq.sugar.frame.Frame at 0x7f51c0059df0>,
  <zmq.sugar.frame.Frame at 0x7f51c0059ea8>],
 <zmq.sugar.frame.Frame at 0x7f51c0059b10>,
 <zmq.sugar.frame.Frame at 0x7f51c0059bc8>,
 <zmq.sugar.frame.Frame at 0x7f51c0059c80>,
 <zmq.sugar.frame.Frame at 0x7f51c0059d38>,
 <zmq.sugar.frame.Frame at 0x7f51c0059df0>,
 <zmq.sugar.frame.Frame at 0x7f51c0059ea8>,
 <frame at 0x55b8f546ec88>,
 ([<zmq.sugar.frame.Frame at 0x7f51c0059048>,
   <zmq.sugar.frame.Frame at 0x7f51c0059b10>,
   <zmq.sugar.frame.Frame at 0x7f51c0059bc8>,
   <zmq.sugar.frame.Frame at 0x7f51c0059c80>,
   <zmq.sugar.frame.Frame at 0x7f51c0059d38>,
   <zmq.sugar.frame.Frame at 0x7f51c0059df0>,
   <zmq.sugar.frame.Frame at 0x7f51c0059ea8>],),
 ((), None),
 <frame at 0x55b8f5486078>,
 ([<zmq.sugar.frame.Frame at 0x7f51c0059048>,
   <zmq.sugar.frame.Frame at 0x7f51c0059b10>,
   <zmq.sugar.frame.Frame at 0x7f51c0059bc8>,
   <zmq.sugar.frame.Frame at 0x7f51c0059c80>,
   <zmq.sugar.frame.Frame at 0x7f51c0059d38>,
   <zmq.sugar.frame.Frame at 0x7f51c0059df0>,
   <zmq.sugar.frame.Frame at 0x7f51c0059ea8>],),
 <frame at 0x7f51c004fda0>,
 <frame at 0x55b8f5477c18>,
 [b'4CE6797D9E26478A800FA96DD84CCB50'],
 {'buffers': [],
  'content': {'allow_stdin': True,
   'code': 'import gc\nпс',
   'silent': False,
   'stop_on_error': True,
   'store_history': True,
   'user_expressions': {}},
  'header': {'date': '2016-03-20T19:45:39.854931',
   'msg_id': '1B8734E26BD647268275E6A2781E1807',
   'msg_type': 'execute_request',
   'session': '4CE6797D9E26478A800FA96DD84CCB50',
   'username': 'username',
   'version': '5.0'},
  'metadata': {},
  'msg_id': '1B8734E26BD647268275E6A2781E1807',
  'msg_type': 'execute_request',
  'parent_header': {}},
 {'allow_stdin': True,
  'code': 'import gc\nпс',
  'silent': False,
  'stop_on_error': True,
  'store_history': True,
  'user_expressions': {}},
 [],
 <frame at 0x55b8f5487038>,
 <frame at 0x55b8f5487938>,
 <frame at 0x55b8f5487be8>,
 <cell at 0x7f51c00bd618: ExecutionResult object at 0x7f51c006b518>,
 <IPython.core.interactiveshell.ExecutionResult at 0x7f51c006b518>,
 (<cell at 0x7f51c00bd618: ExecutionResult object at 0x7f51c006b518>,),
 <function IPython.core.interactiveshell.InteractiveShell.run_cell.<locals>.error_before_exec>,
 ['import gc\n', 'пс\n'],
 (13,
  1458492339.8650405,
  ['import gc\n', 'пс\n'],
  '<ipython-input-18-9c73640366da>'),
 <_ast.Module at 0x7f51c006e748>,
 [<_ast.Import at 0x7f51c006e7f0>, <_ast.Expr at 0x7f51c006ea90>],
 <_ast.Import at 0x7f51c006e7f0>,
 [<_ast.alias at 0x7f51c006e3c8>],
 <_ast.alias at 0x7f51c006e3c8>,
 {'col_offset': 0, 'lineno': 1, 'names': [<_ast.alias at 0x7f51c006e3c8>]},
 <_ast.Expr at 0x7f51c006ea90>,
 <_ast.Name at 0x7f51c006ebe0>,
 {'col_offset': 0,
  'ctx': <_ast.Load at 0x7f51c972e630>,
  'id': 'пс',
  'lineno': 2},
 {'col_offset': 0, 'lineno': 2, 'value': <_ast.Name at 0x7f51c006ebe0>},
 {'body': [<_ast.Import at 0x7f51c006e7f0>, <_ast.Expr at 0x7f51c006ea90>]},
 <frame at 0x55b8f545c548>,
 [<_ast.Import at 0x7f51c006e7f0>],
 [<_ast.Expr at 0x7f51c006ea90>],
 [<_ast.Expr at 0x7f51c006ea90>],
 <_ast.Interactive at 0x7f51c006ecc0>,
 {'body': [<_ast.Expr at 0x7f51c006ea90>]},
 ('пс',),
 (None,),
 <frame at 0x55b8f546d168>,
 <frame at 0x55b8f5458da8>,
 <traceback at 0x7f51c0062048>,
 <traceback at 0x7f51c0086188>,
 ("name 'пс' is not defined",),
 NameError("name 'пс' is not defined"),
 {'error_in_exec': NameError("name 'пс' is not defined"),
  'execution_count': 18},
 <weakref at 0x7f51c00644f8; dead>,
 [0, 0, 2],
 ['\x1b[1;31m---------------------------------------------------------------------------\x1b[0m',
  '\x1b[1;31mNameError\x1b[0m                                 Traceback (most recent call last)',
  '\x1b[1;32m<ipython-input-18-9c73640366da>\x1b[0m in \x1b[0;36m<module>\x1b[1;34m()\x1b[0m\n\x1b[0;32m      1\x1b[0m \x1b[1;32mimport\x1b[0m \x1b[0mgc\x1b[0m\x1b[1;33m\x1b[0m\x1b[0m\n\x1b[1;32m----> 2\x1b[1;33m \x1b[0mпс\x1b[0m\x1b[1;33m\x1b[0m\x1b[0m\n\x1b[0m',
  "\x1b[1;31mNameError\x1b[0m: name 'пс' is not defined"],
 {'ename': 'NameError',
  'engine_info': {'engine_id': -1,
   'engine_uuid': '60debbe5-9e37-44be-8878-88c400d6728c',
   'method': 'execute'},
  'evalue': "name 'пс' is not defined",
  'execution_count': 18,
  'payload': [],
  'status': 'error',
  'traceback': ['\x1b[1;31m---------------------------------------------------------------------------\x1b[0m',
   '\x1b[1;31mNameError\x1b[0m                                 Traceback (most recent call last)',
   '\x1b[1;32m<ipython-input-18-9c73640366da>\x1b[0m in \x1b[0;36m<module>\x1b[1;34m()\x1b[0m\n\x1b[0;32m      1\x1b[0m \x1b[1;32mimport\x1b[0m \x1b[0mgc\x1b[0m\x1b[1;33m\x1b[0m\x1b[0m\n\x1b[1;32m----> 2\x1b[1;33m \x1b[0mпс\x1b[0m\x1b[1;33m\x1b[0m\x1b[0m\n\x1b[0m',
   "\x1b[1;31mNameError\x1b[0m: name 'пс' is not defined"],
  'user_expressions': {}},
 [],
 {'ename': 'NameError',
  'engine_info': {'engine_id': -1,
   'engine_uuid': '60debbe5-9e37-44be-8878-88c400d6728c',
   'method': 'execute'},
  'evalue': "name 'пс' is not defined",
  'execution_count': 18,
  'payload': [],
  'status': 'error',
  'traceback': ['\x1b[1;31m---------------------------------------------------------------------------\x1b[0m',
   '\x1b[1;31mNameError\x1b[0m                                 Traceback (most recent call last)',
   '\x1b[1;32m<ipython-input-18-9c73640366da>\x1b[0m in \x1b[0;36m<module>\x1b[1;34m()\x1b[0m\n\x1b[0;32m      1\x1b[0m \x1b[1;32mimport\x1b[0m \x1b[0mgc\x1b[0m\x1b[1;33m\x1b[0m\x1b[0m\n\x1b[1;32m----> 2\x1b[1;33m \x1b[0mпс\x1b[0m\x1b[1;33m\x1b[0m\x1b[0m\n\x1b[0m',
   "\x1b[1;31mNameError\x1b[0m: name 'пс' is not defined"],
  'user_expressions': {}},
 ['\x1b[1;31m---------------------------------------------------------------------------\x1b[0m',
  '\x1b[1;31mNameError\x1b[0m                                 Traceback (most recent call last)',
  '\x1b[1;32m<ipython-input-18-9c73640366da>\x1b[0m in \x1b[0;36m<module>\x1b[1;34m()\x1b[0m\n\x1b[0;32m      1\x1b[0m \x1b[1;32mimport\x1b[0m \x1b[0mgc\x1b[0m\x1b[1;33m\x1b[0m\x1b[0m\n\x1b[1;32m----> 2\x1b[1;33m \x1b[0mпс\x1b[0m\x1b[1;33m\x1b[0m\x1b[0m\n\x1b[0m',
  "\x1b[1;31mNameError\x1b[0m: name 'пс' is not defined"],
 {'content': {'ename': 'NameError',
   'engine_info': {'engine_id': -1,
    'engine_uuid': '60debbe5-9e37-44be-8878-88c400d6728c',
    'method': 'execute'},
   'evalue': "name 'пс' is not defined",
   'execution_count': 18,
   'payload': [],
   'status': 'error',
   'traceback': ['\x1b[1;31m---------------------------------------------------------------------------\x1b[0m',
    '\x1b[1;31mNameError\x1b[0m                                 Traceback (most recent call last)',
    '\x1b[1;32m<ipython-input-18-9c73640366da>\x1b[0m in \x1b[0;36m<module>\x1b[1;34m()\x1b[0m\n\x1b[0;32m      1\x1b[0m \x1b[1;32mimport\x1b[0m \x1b[0mgc\x1b[0m\x1b[1;33m\x1b[0m\x1b[0m\n\x1b[1;32m----> 2\x1b[1;33m \x1b[0mпс\x1b[0m\x1b[1;33m\x1b[0m\x1b[0m\n\x1b[0m',
    "\x1b[1;31mNameError\x1b[0m: name 'пс' is not defined"],
   'user_expressions': {}},
  'header': {'date': datetime.datetime(2016, 3, 20, 19, 45, 39, 887091),
   'msg_id': '82a931b7-220f-45ed-a36c-b46ed83f1011',
   'msg_type': 'execute_reply',
   'session': 'bbd10ed7-5a2c-43a4-98b6-3a4760409ca6',
   'username': 'pasha',
   'version': '5.0'},
  'metadata': {'dependencies_met': True,
   'engine': '60debbe5-9e37-44be-8878-88c400d6728c',
   'started': datetime.datetime(2016, 3, 20, 19, 45, 39, 855338),
   'status': 'error'},
  'msg_id': '82a931b7-220f-45ed-a36c-b46ed83f1011',
  'msg_type': 'execute_reply',
  'parent_header': {'date': '2016-03-20T19:45:39.854931',
   'msg_id': '1B8734E26BD647268275E6A2781E1807',
   'msg_type': 'execute_request',
   'session': '4CE6797D9E26478A800FA96DD84CCB50',
   'username': 'username',
   'version': '5.0'},
  'tracker': <zmq.sugar.tracker.MessageTracker at 0x7f51c2222b38>},
 ['import gc\n', 'gc\n'],
 (13,
  1458492343.0486176,
  ['import gc\n', 'gc\n'],
  '<ipython-input-19-6ceba25ff0d6>'),
 <weakref at 0x7f51c0064638; dead>,
 {14: 3, 15: 3, 19: <module 'gc' (built-in)>, 20: []},
 ['import gc\n', 'gc.garbage\n'],
 (21,
  1458492346.42364,
  ['import gc\n', 'gc.garbage\n'],
  '<ipython-input-20-f74d4ae451db>'),
 <weakref at 0x7f51c0064b38; dead>,
 [],
 <_io.StringIO at 0x7f51c00a43a8>,
 [],
 <_io.StringIO at 0x7f51c00a4ca8>,
 [],
 (<zmq.sugar.socket.Socket at 0x7f51c11eaca8>, 5),
 [],
 [functools.partial(<function wrap.<locals>.null_wrapper at 0x7f51c00b5ea0>)],
 [(21, 'gc.get_objects()', 'gc.get_objects()')],
 [],
 <frame at 0x55b8f545cbe8>,
 <frame at 0x55b8f5454be8>,
 <function lock.acquire>,
 (1.0,),
 [(<zmq.sugar.socket.Socket at 0x7f51c11eaca8>, 1)],
 (<zmq.sugar.socket.Socket at 0x7f51c11eaca8>, 1),
 <frame at 0x55b8f546ea48>,
 (<zmq.sugar.socket.Socket at 0x7f51c11eaca8>, 1),
 (<zmq.eventloop.zmqstream.ZMQStream at 0x7f51c12216d8>,
  <zmq.sugar.socket.Socket at 0x7f51c11eaca8>,
  1),
 <frame at 0x55b8f545b988>,
 <frame at 0x55b8f5470fb8>,
 <zmq.sugar.frame.Frame at 0x7f51c0059f60>,
 [<zmq.sugar.frame.Frame at 0x7f51c0059f60>,
  <zmq.sugar.frame.Frame at 0x7f51c0084048>,
  <zmq.sugar.frame.Frame at 0x7f51c0084100>,
  <zmq.sugar.frame.Frame at 0x7f51c00841b8>,
  <zmq.sugar.frame.Frame at 0x7f51c0084270>,
  <zmq.sugar.frame.Frame at 0x7f51c0084328>,
  <zmq.sugar.frame.Frame at 0x7f51c00843e0>],
 <zmq.sugar.frame.Frame at 0x7f51c0084048>,
 <zmq.sugar.frame.Frame at 0x7f51c0084100>,
 <zmq.sugar.frame.Frame at 0x7f51c00841b8>,
 <zmq.sugar.frame.Frame at 0x7f51c0084270>,
 <zmq.sugar.frame.Frame at 0x7f51c0084328>,
 <zmq.sugar.frame.Frame at 0x7f51c00843e0>,
 <frame at 0x55b8f5459738>,
 ([<zmq.sugar.frame.Frame at 0x7f51c0059f60>,
   <zmq.sugar.frame.Frame at 0x7f51c0084048>,
   <zmq.sugar.frame.Frame at 0x7f51c0084100>,
   <zmq.sugar.frame.Frame at 0x7f51c00841b8>,
   <zmq.sugar.frame.Frame at 0x7f51c0084270>,
   <zmq.sugar.frame.Frame at 0x7f51c0084328>,
   <zmq.sugar.frame.Frame at 0x7f51c00843e0>],),
 <tornado.stack_context.NullContext at 0x7f51c006e1d0>,
 <bound method NullContext.__exit__ of <tornado.stack_context.NullContext object at 0x7f51c006e1d0>>,
 ((), None),
 ([<zmq.sugar.frame.Frame at 0x7f51c0059f60>,
   <zmq.sugar.frame.Frame at 0x7f51c0084048>,
   <zmq.sugar.frame.Frame at 0x7f51c0084100>,
   <zmq.sugar.frame.Frame at 0x7f51c00841b8>,
   <zmq.sugar.frame.Frame at 0x7f51c0084270>,
   <zmq.sugar.frame.Frame at 0x7f51c0084328>,
   <zmq.sugar.frame.Frame at 0x7f51c00843e0>],),
 <frame at 0x55b8f54373e8>,
 ([<zmq.sugar.frame.Frame at 0x7f51c0059f60>,
   <zmq.sugar.frame.Frame at 0x7f51c0084048>,
   <zmq.sugar.frame.Frame at 0x7f51c0084100>,
   <zmq.sugar.frame.Frame at 0x7f51c00841b8>,
   <zmq.sugar.frame.Frame at 0x7f51c0084270>,
   <zmq.sugar.frame.Frame at 0x7f51c0084328>,
   <zmq.sugar.frame.Frame at 0x7f51c00843e0>],),
 ([<zmq.sugar.frame.Frame at 0x7f51c0059f60>,
   <zmq.sugar.frame.Frame at 0x7f51c0084048>,
   <zmq.sugar.frame.Frame at 0x7f51c0084100>,
   <zmq.sugar.frame.Frame at 0x7f51c00841b8>,
   <zmq.sugar.frame.Frame at 0x7f51c0084270>,
   <zmq.sugar.frame.Frame at 0x7f51c0084328>,
   <zmq.sugar.frame.Frame at 0x7f51c00843e0>],),
 <frame at 0x55b8f545d508>,
 <frame at 0x55b8f545b0e8>,
 [b'4CE6797D9E26478A800FA96DD84CCB50'],
 {'buffers': [],
  'content': {'allow_stdin': True,
   'code': 'gc.get_objects()',
   'silent': False,
   'stop_on_error': True,
   'store_history': True,
   'user_expressions': {}},
  'header': {'date': '2016-03-20T19:46:05.318327',
   'msg_id': 'BF3CEE6EC01944EEA25FA7825F7AD98A',
   'msg_type': 'execute_request',
   'session': '4CE6797D9E26478A800FA96DD84CCB50',
   'username': 'username',
   'version': '5.0'},
  'metadata': {},
  'msg_id': 'BF3CEE6EC01944EEA25FA7825F7AD98A',
  'msg_type': 'execute_request',
  'parent_header': {}},
 {'allow_stdin': True,
  'code': 'gc.get_objects()',
  'silent': False,
  'stop_on_error': True,
  'store_history': True,
  'user_expressions': {}},
 [],
 [b'kernel.60debbe5-9e37-44be-8878-88c400d6728c.status',
  b'<IDS|MSG>',
  b'ecb412c063171fde8c8f2fac7430fe7a46d403f5ba39f666f11aae27874b1ae4',
  b'{"version":"5.0","msg_id":"5eed5d40-b2ce-4322-97a5-7e640fb8f489","session":"bbd10ed7-5a2c-43a4-98b6-3a4760409ca6","username":"pasha","msg_type":"status","date":"2016-03-20T19:46:05.318538"}',
  b'{"session":"4CE6797D9E26478A800FA96DD84CCB50","msg_type":"execute_request","version":"5.0","username":"username","msg_id":"BF3CEE6EC01944EEA25FA7825F7AD98A","date":"2016-03-20T19:46:05.318327"}',
  b'{}',
  b'{"execution_state":"busy"}'],
 ([b'kernel.60debbe5-9e37-44be-8878-88c400d6728c.status',
   b'<IDS|MSG>',
   b'ecb412c063171fde8c8f2fac7430fe7a46d403f5ba39f666f11aae27874b1ae4',
   b'{"version":"5.0","msg_id":"5eed5d40-b2ce-4322-97a5-7e640fb8f489","session":"bbd10ed7-5a2c-43a4-98b6-3a4760409ca6","username":"pasha","msg_type":"status","date":"2016-03-20T19:46:05.318538"}',
   b'{"session":"4CE6797D9E26478A800FA96DD84CCB50","msg_type":"execute_request","version":"5.0","username":"username","msg_id":"BF3CEE6EC01944EEA25FA7825F7AD98A","date":"2016-03-20T19:46:05.318327"}',
   b'{}',
   b'{"execution_state":"busy"}'],),
 <cell at 0x7f51c00bd378: tuple object at 0x7f51c00a5eb8>,
 <cell at 0x7f51c00bd318: dict object at 0x7f51c0079f88>,
 <cell at 0x7f51c00bd468: IOPubThread object at 0x7f51c124be48>,
 (<cell at 0x7f51c00bd378: tuple object at 0x7f51c00a5eb8>,
  <cell at 0x7f51c00bd318: dict object at 0x7f51c0079f88>,
  <cell at 0x7f51c00bd468: IOPubThread object at 0x7f51c124be48>),
 <function ipykernel.iostream.IOPubThread.send_multipart.<locals>.<lambda>>,
 <cell at 0x7f51c00bd8e8: list object at 0x7f51c00862c8>,
 <cell at 0x7f51c00bd8b8: function object at 0x7f51c00b5598>,
 [((), None)],
 (<cell at 0x7f51c00bd8e8: list object at 0x7f51c00862c8>,
  <cell at 0x7f51c00bd8b8: function object at 0x7f51c00b5598>),
 <function tornado.stack_context.wrap.<locals>.null_wrapper>,
 functools.partial(<function wrap.<locals>.null_wrapper at 0x7f51c00b5ea0>),
 <frame at 0x55b8f5489a58>,
 [(18, 1)],
 (18, 1),
 [functools.partial(<function wrap.<locals>.null_wrapper at 0x7f51c00b5f28>)],
 [],
 <list_iterator at 0x7f51c006b160>,
 <frame at 0x7f51b4001f48>,
 <frame at 0x55b8f54549a8>,
 <frame at 0x7f51c00ceaf8>,
 (<ipykernel.iostream.IOPubThread at 0x7f51c124be48>,
  [b'kernel.60debbe5-9e37-44be-8878-88c400d6728c.status',
   b'<IDS|MSG>',
   b'ecb412c063171fde8c8f2fac7430fe7a46d403f5ba39f666f11aae27874b1ae4',
   b'{"version":"5.0","msg_id":"5eed5d40-b2ce-4322-97a5-7e640fb8f489","session":"bbd10ed7-5a2c-43a4-98b6-3a4760409ca6","username":"pasha","msg_type":"status","date":"2016-03-20T19:46:05.318538"}',
   b'{"session":"4CE6797D9E26478A800FA96DD84CCB50","msg_type":"execute_request","version":"5.0","username":"username","msg_id":"BF3CEE6EC01944EEA25FA7825F7AD98A","date":"2016-03-20T19:46:05.318327"}',
   b'{}',
   b'{"execution_state":"busy"}']),
 ('copy', True),
 <frame at 0x7f51c00d5238>,
 (<zmq.sugar.socket.Socket at 0x7f51c11eadc8>,
  [b'kernel.60debbe5-9e37-44be-8878-88c400d6728c.status',
   b'<IDS|MSG>',
   b'ecb412c063171fde8c8f2fac7430fe7a46d403f5ba39f666f11aae27874b1ae4',
   b'{"version":"5.0","msg_id":"5eed5d40-b2ce-4322-97a5-7e640fb8f489","session":"bbd10ed7-5a2c-43a4-98b6-3a4760409ca6","username":"pasha","msg_type":"status","date":"2016-03-20T19:46:05.318538"}',
   b'{"session":"4CE6797D9E26478A800FA96DD84CCB50","msg_type":"execute_request","version":"5.0","username":"username","msg_id":"BF3CEE6EC01944EEA25FA7825F7AD98A","date":"2016-03-20T19:46:05.318327"}',
   b'{}',
   b'{"execution_state":"busy"}']),
 ('copy', True),
 <frame at 0x55b8f54875d8>,
 [b'kernel.60debbe5-9e37-44be-8878-88c400d6728c.status',
  b'<IDS|MSG>',
  b'ecb412c063171fde8c8f2fac7430fe7a46d403f5ba39f666f11aae27874b1ae4',
  b'{"version":"5.0","msg_id":"5eed5d40-b2ce-4322-97a5-7e640fb8f489","session":"bbd10ed7-5a2c-43a4-98b6-3a4760409ca6","username":"pasha","msg_type":"status","date":"2016-03-20T19:46:05.318538"}',
  b'{"session":"4CE6797D9E26478A800FA96DD84CCB50","msg_type":"execute_request","version":"5.0","username":"username","msg_id":"BF3CEE6EC01944EEA25FA7825F7AD98A","date":"2016-03-20T19:46:05.318327"}',
  b'{}'],
 <list_iterator at 0x7f51c006eef0>,
 <function Socket.send>,
 (b'ecb412c063171fde8c8f2fac7430fe7a46d403f5ba39f666f11aae27874b1ae4', 2),
 [b'kernel.60debbe5-9e37-44be-8878-88c400d6728c.execute_input',
  b'<IDS|MSG>',
  b'bab7db0cbbf705a3806db6eb7783adbff55ac0f37e237047e122362a253e4331',
  b'{"version":"5.0","msg_id":"3ad7161c-ae6c-43d0-bfc4-d8bdc7ca7d81","session":"bbd10ed7-5a2c-43a4-98b6-3a4760409ca6","username":"pasha","msg_type":"execute_input","date":"2016-03-20T19:46:05.318956"}',
  b'{"session":"4CE6797D9E26478A800FA96DD84CCB50","msg_type":"execute_request","version":"5.0","username":"username","msg_id":"BF3CEE6EC01944EEA25FA7825F7AD98A","date":"2016-03-20T19:46:05.318327"}',
  b'{}',
  b'{"execution_count":21,"code":"gc.get_objects()"}'],
 ([b'kernel.60debbe5-9e37-44be-8878-88c400d6728c.execute_input',
   b'<IDS|MSG>',
   b'bab7db0cbbf705a3806db6eb7783adbff55ac0f37e237047e122362a253e4331',
   b'{"version":"5.0","msg_id":"3ad7161c-ae6c-43d0-bfc4-d8bdc7ca7d81","session":"bbd10ed7-5a2c-43a4-98b6-3a4760409ca6","username":"pasha","msg_type":"execute_input","date":"2016-03-20T19:46:05.318956"}',
   b'{"session":"4CE6797D9E26478A800FA96DD84CCB50","msg_type":"execute_request","version":"5.0","username":"username","msg_id":"BF3CEE6EC01944EEA25FA7825F7AD98A","date":"2016-03-20T19:46:05.318327"}',
   b'{}',
   b'{"execution_count":21,"code":"gc.get_objects()"}'],),
 <cell at 0x7f51c00bd198: tuple object at 0x7f51c006e8d0>,
 <cell at 0x7f51c00bd438: dict object at 0x7f51c0086308>,
 <cell at 0x7f51c00bd288: IOPubThread object at 0x7f51c124be48>,
 (<cell at 0x7f51c00bd198: tuple object at 0x7f51c006e8d0>,
  <cell at 0x7f51c00bd438: dict object at 0x7f51c0086308>,
  <cell at 0x7f51c00bd288: IOPubThread object at 0x7f51c124be48>),
 <function ipykernel.iostream.IOPubThread.send_multipart.<locals>.<lambda>>,
 <cell at 0x7f51c00bd108: list object at 0x7f51c0086fc8>,
 <cell at 0x7f51c00bd0a8: function object at 0x7f51c00b57b8>,
 [((), None)],
 (<cell at 0x7f51c00bd108: list object at 0x7f51c0086fc8>,
  <cell at 0x7f51c00bd0a8: function object at 0x7f51c00b57b8>),
 <function tornado.stack_context.wrap.<locals>.null_wrapper>,
 functools.partial(<function wrap.<locals>.null_wrapper at 0x7f51c00b5f28>),
 <frame at 0x55b8f548a358>,
 <bound method IPythonKernel.raw_input of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
 <bound method IPythonKernel.getpass of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
 <frame at 0x55b8f548a608>,
 <cell at 0x7f51c00bd3a8: ExecutionResult object at 0x7f51c006e400>,
 <IPython.core.interactiveshell.ExecutionResult at 0x7f51c006e400>,
 (<cell at 0x7f51c00bd3a8: ExecutionResult object at 0x7f51c006e400>,),
 <function IPython.core.interactiveshell.InteractiveShell.run_cell.<locals>.error_before_exec>,
 ['gc.get_objects()'],
 <bound method assemble_python_lines.get_line of <IPython.core.inputtransformer.assemble_python_lines object at 0x7f51c00a5438>>,
 <frame at 0x55b8f54446f8>,
 <generator object _tokenize at 0x7f51c00bccf0>,
 (21, 'gc.get_objects()', 'gc.get_objects()'),
 <bound method BuiltinTrap.__exit__ of <IPython.core.builtin_trap.BuiltinTrap object at 0x7f51c016eef0>>,
 ['gc.get_objects()\n'],
 (17,
  1458492365.3196926,
  ['gc.get_objects()\n'],
  '<ipython-input-21-270fbd95f7f5>'),
 <bound method DisplayTrap.__exit__ of <IPython.core.display_trap.DisplayTrap object at 0x7f51c0113320>>,
 <_ast.Module at 0x7f51c006ee80>,
 [<_ast.Expr at 0x7f51c006ec88>],
 <_ast.Expr at 0x7f51c006ec88>,
 <_ast.Call at 0x7f51c006e7b8>,
 <_ast.Attribute at 0x7f51c006ed30>,
 <_ast.Name at 0x7f51c006efd0>,
 {'col_offset': 0,
  'ctx': <_ast.Load at 0x7f51c972e630>,
  'id': 'gc',
  'lineno': 1},
 {'attr': 'get_objects',
  'col_offset': 0,
  'ctx': <_ast.Load at 0x7f51c972e630>,
  'lineno': 1,
  'value': <_ast.Name at 0x7f51c006efd0>},
 {'args': [],
  'col_offset': 0,
  'func': <_ast.Attribute at 0x7f51c006ed30>,
  'keywords': [],
  'kwargs': None,
  'lineno': 1,
  'starargs': None},
 [],
 [],
 {'col_offset': 0, 'lineno': 1, 'value': <_ast.Call at 0x7f51c006e7b8>},
 {'body': [<_ast.Expr at 0x7f51c006ec88>]},
 <frame at 0x55b8f546c078>,
 [],
 [<_ast.Expr at 0x7f51c006ec88>],
 <enumerate at 0x7f51c00d0828>,
 <list_iterator at 0x7f51c006e2b0>,
 (0, <_ast.Expr at 0x7f51c006ec88>),
 [<_ast.Expr at 0x7f51c006ec88>],
 <_ast.Interactive at 0x7f51c006eda0>,
 {'body': [<_ast.Expr at 0x7f51c006ec88>]},
 ('gc', 'get_objects'),
 (None,),
 <frame at 0x55b8f5489ed8>,
 <bound method ZMQInteractiveShell.excepthook of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>,
 (<code object <module> at 0x7f51c00a4810, file "<ipython-input-21-270fbd95f7f5>", line 1>,
  {'In': ['',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
    "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    'def pick(l: list, index: int) -> int:\n    return l[index]',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
    'pick([1, 2, 3], 2)',
    "pick([1, 2, 3], '2')",
    'import gc',
    'import gc\nпс',
    'import gc\ngc',
    'import gc\ngc.garbage',
    'gc.get_objects()'],
   'Out': {14: 3, 15: 3, 19: <module 'gc' (built-in)>, 20: []},
   '_': [],
   '_14': 3,
   '_15': 3,
   '_19': <module 'gc' (built-in)>,
   '_20': [],
   '__': <module 'gc' (built-in)>,
   '___': 3,
   '__builtin__': <module 'builtins' (built-in)>,
   '__builtins__': <module 'builtins' (built-in)>,
   '__doc__': 'Automatically created module for IPython interactive environment',
   '__loader__': None,
   '__name__': '__main__',
   '__package__': None,
   '__spec__': None,
   '_dh': ['/home/pasha/machine-learning.coursera/LearnInProgress/final.assignment/Kaggle'],
   '_i': 'import gc\ngc.garbage',
   '_i1': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
   '_i10': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_i11': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   '_i12': 'def pick(l: list, index: int) -> int:\n    return l[index]',
   '_i13': 'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
   '_i14': 'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
   '_i15': 'pick([1, 2, 3], 2)',
   '_i16': "pick([1, 2, 3], '2')",
   '_i17': 'import gc',
   '_i18': 'import gc\nпс',
   '_i19': 'import gc\ngc',
   '_i2': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
   '_i20': 'import gc\ngc.garbage',
   '_i21': 'gc.get_objects()',
   '_i3': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
   '_i4': "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   '_i5': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   '_i6': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_i7': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_i8': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_i9': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_ih': ['',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
    "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    'def pick(l: list, index: int) -> int:\n    return l[index]',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
    'pick([1, 2, 3], 2)',
    "pick([1, 2, 3], '2')",
    'import gc',
    'import gc\nпс',
    'import gc\ngc',
    'import gc\ngc.garbage',
    'gc.get_objects()'],
   '_ii': 'import gc\ngc',
   '_iii': 'import gc\nпс',
   '_oh': {14: 3, 15: 3, 19: <module 'gc' (built-in)>, 20: []},
   '_sh': <module 'IPython.core.shadowns' from '/home/pasha/.local/lib/python3.4/site-packages/IPython/core/shadowns.py'>,
   'exit': <IPython.core.autocall.ZMQExitAutocall at 0x7f51c016ef98>,
   'gc': <module 'gc' (built-in)>,
   'get_ipython': <bound method ZMQInteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>,
   'pick': <function __main__.pick>,
   'quit': <IPython.core.autocall.ZMQExitAutocall at 0x7f51c016ef98>,
   'v': 3,
   'x': {1: False, 3: True}},
  {'In': ['',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
    "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    'def pick(l: list, index: int) -> int:\n    return l[index]',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
    'pick([1, 2, 3], 2)',
    "pick([1, 2, 3], '2')",
    'import gc',
    'import gc\nпс',
    'import gc\ngc',
    'import gc\ngc.garbage',
    'gc.get_objects()'],
   'Out': {14: 3, 15: 3, 19: <module 'gc' (built-in)>, 20: []},
   '_': [],
   '_14': 3,
   '_15': 3,
   '_19': <module 'gc' (built-in)>,
   '_20': [],
   '__': <module 'gc' (built-in)>,
   '___': 3,
   '__builtin__': <module 'builtins' (built-in)>,
   '__builtins__': <module 'builtins' (built-in)>,
   '__doc__': 'Automatically created module for IPython interactive environment',
   '__loader__': None,
   '__name__': '__main__',
   '__package__': None,
   '__spec__': None,
   '_dh': ['/home/pasha/machine-learning.coursera/LearnInProgress/final.assignment/Kaggle'],
   '_i': 'import gc\ngc.garbage',
   '_i1': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
   '_i10': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_i11': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   '_i12': 'def pick(l: list, index: int) -> int:\n    return l[index]',
   '_i13': 'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
   '_i14': 'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
   '_i15': 'pick([1, 2, 3], 2)',
   '_i16': "pick([1, 2, 3], '2')",
   '_i17': 'import gc',
   '_i18': 'import gc\nпс',
   '_i19': 'import gc\ngc',
   '_i2': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
   '_i20': 'import gc\ngc.garbage',
   '_i21': 'gc.get_objects()',
   '_i3': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
   '_i4': "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   '_i5': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   '_i6': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_i7': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_i8': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_i9': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_ih': ['',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
    "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    'def pick(l: list, index: int) -> int:\n    return l[index]',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
    'pick([1, 2, 3], 2)',
    "pick([1, 2, 3], '2')",
    'import gc',
    'import gc\nпс',
    'import gc\ngc',
    'import gc\ngc.garbage',
    'gc.get_objects()'],
   '_ii': 'import gc\ngc',
   '_iii': 'import gc\nпс',
   '_oh': {14: 3, 15: 3, 19: <module 'gc' (built-in)>, 20: []},
   '_sh': <module 'IPython.core.shadowns' from '/home/pasha/.local/lib/python3.4/site-packages/IPython/core/shadowns.py'>,
   'exit': <IPython.core.autocall.ZMQExitAutocall at 0x7f51c016ef98>,
   'gc': <module 'gc' (built-in)>,
   'get_ipython': <bound method ZMQInteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>,
   'pick': <function __main__.pick>,
   'quit': <IPython.core.autocall.ZMQExitAutocall at 0x7f51c016ef98>,
   'v': 3,
   'x': {1: False, 3: True}}),
 <frame at 0x7f51c004e228>,
 (<zmq.sugar.socket.Socket at 0x7f51c11eae28>, 5),
 <Thread(Thread-2, started daemon 139989023192832)>,
 {'_args': (),
  '_daemonic': True,
  '_ident': 139989023192832,
  '_initialized': True,
  '_is_stopped': False,
  '_kwargs': {},
  '_name': 'Thread-2',
  '_started': <threading.Event at 0x7f51c12212e8>,
  '_stderr': <_io.TextIOWrapper name='<stderr>' mode='w' encoding='UTF-8'>,
  '_target': <bound method IOPubThread._thread_main of <ipykernel.iostream.IOPubThread object at 0x7f51c124be48>>,
  '_tstate_lock': <_thread.lock at 0x7f51c12893f0>},
 <threading.Event at 0x7f51c12212e8>,
 {'_cond': <Condition(<_thread.lock object at 0x7f51c125c3a0>, 0)>,
  '_flag': True},
 <weakref at 0x7f51c11d5548; to 'Thread' at 0x7f51c1221fd0>,
 {},
 <bound method Thread._bootstrap of <Thread(Thread-2, started daemon 139989023192832)>>,
 (<Thread(Thread-2, started daemon 139989023192832)>,),
 <frame at 0x7f51c11dc418>,
 <frame at 0x7f51b40008d8>,
 <weakref at 0x7f51caad94f8; to '_thread.lock' at 0x7f51c12893f0>,
 <frame at 0x7f51c11f6428>,
 (<ipykernel.iostream.IOPubThread at 0x7f51c124be48>,),
 <frame at 0x7f51c11dbd88>,
 <frame at 0x7f51b4000e68>,
 <frame at 0x7f51b40010a8>,
 <logging.Logger at 0x7f51c1221ef0>,
 {'disabled': False,
  'filters': [],
  'handlers': [],
  'level': 0,
  'manager': <logging.Manager at 0x7f51c9fd5cf8>,
  'name': 'tornado',
  'parent': <logging.RootLogger at 0x7f51c9fd5be0>,
  'propagate': True},
 [],
 <logging.StreamHandler at 0x7f51c1fe6400>,
 {'_name': None,
  'filters': [],
  'formatter': <logging.Formatter at 0x7f51c1221e10>,
  'level': 0,
  'lock': <_thread.RLock owner=0 count=0>,
  'stream': <_io.TextIOWrapper name='<stderr>' mode='w' encoding='UTF-8'>},
 <weakref at 0x7f51c1241688; to 'StreamHandler' at 0x7f51c1fe6400>,
 <logging.Formatter at 0x7f51c1221e10>,
 {'_fmt': '%(levelname)s:%(name)s:%(message)s',
  '_style': <logging.PercentStyle at 0x7f51c1221d68>,
  'datefmt': None},
 <weakref at 0x7f51c1241638; to '_thread._localdummy' at 0x7f51c124e5f0>,
 {'instance': <zmq.eventloop.ioloop.ZMQIOLoop at 0x7f51c124bcf8>},
 <bound method IOPubThread.stop of <ipykernel.iostream.IOPubThread object at 0x7f51c124be48>>,
 <function zmq.sugar.context.Context.__init__.<locals>._notify_atexit>,
 <Heartbeat(Thread-3, started daemon 139989014800128)>,
 {'_args': (),
  '_daemonic': True,
  '_ident': 139989014800128,
  '_initialized': True,
  '_is_stopped': False,
  '_kwargs': {},
  '_name': 'Thread-3',
  '_started': <threading.Event at 0x7f51c1221c18>,
  '_stderr': <_io.TextIOWrapper name='<stderr>' mode='w' encoding='UTF-8'>,
  '_target': None,
  '_tstate_lock': <_thread.lock at 0x7f51c12895a8>,
  'addr': ('127.0.0.1', 39269),
  'context': <zmq.sugar.context.Context at 0x7f51c11ee2e8>,
  'ip': '127.0.0.1',
  'port': 39269,
  'socket': <zmq.sugar.socket.Socket at 0x7f51c11eae88>,
  'transport': 'tcp'},
 <threading.Event at 0x7f51c1221c18>,
 {'_cond': <Condition(<_thread.lock object at 0x7f51c1289490>, 0)>,
  '_flag': True},
 <weakref at 0x7f51c1241778; to 'Heartbeat' at 0x7f51c1221d30>,
 <bound method Heartbeat._bootstrap of <Heartbeat(Thread-3, started daemon 139989014800128)>>,
 (<Heartbeat(Thread-3, started daemon 139989014800128)>,),
 <frame at 0x7f51c11dc7e8>,
 <frame at 0x7f51ac0008d8>,
 <weakref at 0x7f51c12417c8; to '_thread.lock' at 0x7f51c12895a8>,
 <frame at 0x7f51ac000e68>,
 <zmq.sugar.socket.Socket at 0x7f51c11eae88>,
 (3,
  <zmq.sugar.socket.Socket at 0x7f51c11eae88>,
  <zmq.sugar.socket.Socket at 0x7f51c11eae88>),
 (<zmq.sugar.socket.Socket at 0x7f51c11eae88>,
  <zmq.sugar.socket.Socket at 0x7f51c11eae88>),
 <ipykernel.iostream.OutStream at 0x7f51c1221b70>,
 {'_buffer': <_io.StringIO at 0x7f51c00a43a8>,
  '_flush_lock': <_thread.lock at 0x7f51c12894e0>,
  '_flush_timeout': None,
  '_io_loop': <zmq.eventloop.ioloop.ZMQIOLoop at 0x7f51c124bcf8>,
  '_master_pid': 22826,
  'encoding': 'UTF-8',
  'name': 'stdout',
  'parent_header': {'date': '2016-03-20T19:46:05.318327',
   'msg_id': 'BF3CEE6EC01944EEA25FA7825F7AD98A',
   'msg_type': 'execute_request',
   'session': '4CE6797D9E26478A800FA96DD84CCB50',
   'username': 'username',
   'version': '5.0'},
  'pub_thread': <ipykernel.iostream.IOPubThread at 0x7f51c124be48>,
  'session': <jupyter_client.session.Session at 0x7f51c124be10>,
  'softspace': 0,
  'topic': b'stream.stdout'},
 <ipykernel.iostream.OutStream at 0x7f51c1221b38>,
 {'_buffer': <_io.StringIO at 0x7f51c00a4ca8>,
  '_flush_lock': <_thread.lock at 0x7f51c1289508>,
  '_flush_timeout': None,
  '_io_loop': <zmq.eventloop.ioloop.ZMQIOLoop at 0x7f51c124bcf8>,
  '_master_pid': 22826,
  'encoding': 'UTF-8',
  'name': 'stderr',
  'parent_header': {'date': '2016-03-20T19:46:05.318327',
   'msg_id': 'BF3CEE6EC01944EEA25FA7825F7AD98A',
   'msg_type': 'execute_request',
   'session': '4CE6797D9E26478A800FA96DD84CCB50',
   'username': 'username',
   'version': '5.0'},
  'pub_thread': <ipykernel.iostream.IOPubThread at 0x7f51c124be48>,
  'session': <jupyter_client.session.Session at 0x7f51c124be10>,
  'topic': b'stream.stderr'},
 <ipykernel.displayhook.ZMQDisplayHook at 0x7f51c12217b8>,
 {'parent_header': {},
  'pub_socket': <ipykernel.iostream.BackgroundSocket at 0x7f51c124bdd8>,
  'session': <jupyter_client.session.Session at 0x7f51c124be10>},
 <module 'faulthandler' (built-in)>,
 {'__doc__': 'faulthandler module.',
  '__loader__': _frozen_importlib.BuiltinImporter,
  '__name__': 'faulthandler',
  '__package__': '',
  '__spec__': ModuleSpec(name='faulthandler', loader=<class '_frozen_importlib.BuiltinImporter'>, origin='built-in'),
  '_fatal_error': <function faulthandler._fatal_error>,
  '_read_null': <function faulthandler._read_null>,
  '_sigabrt': <function faulthandler._sigabrt>,
  '_sigbus': <function faulthandler._sigbus>,
  '_sigfpe': <function faulthandler._sigfpe>,
  '_sigill': <function faulthandler._sigill>,
  '_sigsegv': <function faulthandler._sigsegv>,
  '_stack_overflow': <function faulthandler._stack_overflow>,
  'cancel_dump_traceback_later': <function faulthandler.cancel_dump_traceback_later>,
  'disable': <function faulthandler.disable>,
  'dump_traceback': <function faulthandler.dump_traceback>,
  'dump_traceback_later': <function faulthandler.dump_traceback_later>,
  'enable': <function ipykernel.kernelapp.IPKernelApp.patch_io.<locals>.enable>,
  'is_enabled': <function faulthandler.is_enabled>,
  'register': <function ipykernel.kernelapp.IPKernelApp.patch_io.<locals>.register>,
  'unregister': <function faulthandler.unregister>},
 <function faulthandler.disable>,
 <function faulthandler.is_enabled>,
 <function faulthandler.dump_traceback>,
 <function faulthandler.dump_traceback_later>,
 <function faulthandler.cancel_dump_traceback_later>,
 <function faulthandler.unregister>,
 <function faulthandler._read_null>,
 <function faulthandler._sigsegv>,
 <function faulthandler._sigabrt>,
 <function faulthandler._sigfpe>,
 <function faulthandler._sigbus>,
 <function faulthandler._sigill>,
 <function faulthandler._fatal_error>,
 <function faulthandler._stack_overflow>,
 <function ipykernel.kernelapp.IPKernelApp.patch_io.<locals>.enable>,
 (<_io.TextIOWrapper name='<stderr>' mode='w' encoding='UTF-8'>, True),
 <function ipykernel.kernelapp.IPKernelApp.patch_io.<locals>.register>,
 (<_io.TextIOWrapper name='<stderr>' mode='w' encoding='UTF-8'>, True, False),
 <zmq.eventloop.zmqstream.ZMQStream at 0x7f51c12216d8>,
 {'_close_callback': None,
  '_flushed': False,
  '_recv_callback': <function tornado.stack_context.wrap.<locals>.null_wrapper>,
  '_recv_copy': False,
  '_send_callback': <function tornado.stack_context.wrap.<locals>.null_wrapper>,
  '_send_queue': <queue.Queue at 0x7f51c1221390>,
  '_state': 25,
  'bind': <function Socket.bind>,
  'bind_to_random_port': <bound method Socket.bind_to_random_port of <zmq.sugar.socket.Socket object at 0x7f51c11eaca8>>,
  'connect': <function Socket.connect>,
  'getsockopt': <function Socket.get>,
  'getsockopt_string': <bound method Socket.get_string of <zmq.sugar.socket.Socket object at 0x7f51c11eaca8>>,
  'getsockopt_unicode': <bound method Socket.get_string of <zmq.sugar.socket.Socket object at 0x7f51c11eaca8>>,
  'io_loop': <zmq.eventloop.ioloop.ZMQIOLoop at 0x7f51c12214a8>,
  'poller': <zmq.sugar.poll.Poller at 0x7f51c1221320>,
  'setsockopt': <function Socket.set>,
  'setsockopt_string': <bound method Socket.set_string of <zmq.sugar.socket.Socket object at 0x7f51c11eaca8>>,
  'setsockopt_unicode': <bound method Socket.set_string of <zmq.sugar.socket.Socket object at 0x7f51c11eaca8>>,
  'socket': <zmq.sugar.socket.Socket at 0x7f51c11eaca8>},
 <zmq.eventloop.ioloop.ZMQIOLoop at 0x7f51c12214a8>,
 {'_blocking_signal_threshold': None,
  '_callback_lock': <_thread.lock at 0x7f51c1289558>,
  '_callbacks': [],
  '_cancellations': 0,
  '_closing': False,
  '_events': {},
  '_handlers': {<zmq.sugar.socket.Socket at 0x7f51c11eaca8>: (<zmq.sugar.socket.Socket at 0x7f51c11eaca8>,
    <function tornado.stack_context.wrap.<locals>.null_wrapper>),
   29: (29, <function tornado.stack_context.wrap.<locals>.null_wrapper>),
   <zmq.sugar.socket.Socket at 0x7f51c11ead68>: (<zmq.sugar.socket.Socket at 0x7f51c11ead68>,
    <function tornado.stack_context.wrap.<locals>.null_wrapper>)},
  '_impl': <zmq.eventloop.ioloop.ZMQPoller at 0x7f51c1221438>,
  '_running': True,
  '_stopped': False,
  '_thread_ident': 139989404575488,
  '_timeout_counter': count(0),
  '_timeouts': [],
  '_waker': <tornado.platform.posix.Waker at 0x7f51c1221ba8>,
  'time_func': <function time.time>},
 [],
 count(0),
 <tornado.platform.posix.Waker at 0x7f51c1221ba8>,
 {'reader': <_io.FileIO name=29 mode='rb'>,
  'writer': <_io.FileIO name=30 mode='wb'>},
 <_io.FileIO name=30 mode='wb'>,
 {<zmq.sugar.socket.Socket at 0x7f51c11eaca8>: (<zmq.sugar.socket.Socket at 0x7f51c11eaca8>,
   <function tornado.stack_context.wrap.<locals>.null_wrapper>),
  29: (29, <function tornado.stack_context.wrap.<locals>.null_wrapper>),
  <zmq.sugar.socket.Socket at 0x7f51c11ead68>: (<zmq.sugar.socket.Socket at 0x7f51c11ead68>,
   <function tornado.stack_context.wrap.<locals>.null_wrapper>)},
 <zmq.sugar.poll.Poller at 0x7f51c1221320>,
 {'_map': {}, 'sockets': []},
 <queue.Queue at 0x7f51c1221390>,
 {'all_tasks_done': <Condition(<_thread.lock object at 0x7f51c12895d0>, 0)>,
  'maxsize': 0,
  'mutex': <_thread.lock at 0x7f51c12895d0>,
  'not_empty': <Condition(<_thread.lock object at 0x7f51c12895d0>, 0)>,
  'not_full': <Condition(<_thread.lock object at 0x7f51c12895d0>, 0)>,
  'queue': deque([]),
  'unfinished_tasks': 25},
 <Condition(<_thread.lock object at 0x7f51c12895d0>, 0)>,
 {'_lock': <_thread.lock at 0x7f51c12895d0>,
  '_waiters': deque([]),
  'acquire': <function lock.acquire>,
  'release': <function lock.release>},
 <function lock.release>,
 deque([]),
 <Condition(<_thread.lock object at 0x7f51c12895d0>, 0)>,
 {'_lock': <_thread.lock at 0x7f51c12895d0>,
  '_waiters': deque([]),
  'acquire': <function lock.acquire>,
  'release': <function lock.release>},
 <function lock.release>,
 deque([]),
 <Condition(<_thread.lock object at 0x7f51c12895d0>, 0)>,
 {'_lock': <_thread.lock at 0x7f51c12895d0>,
  '_waiters': deque([]),
  'acquire': <function lock.acquire>,
  'release': <function lock.release>},
 <function lock.release>,
 deque([]),
 (<zmq.sugar.socket.Socket at 0x7f51c11eaca8>,
  <function tornado.stack_context.wrap.<locals>.null_wrapper>),
 <function Socket.bind>,
 <bound method Socket.bind_to_random_port of <zmq.sugar.socket.Socket object at 0x7f51c11eaca8>>,
 <function Socket.connect>,
 <function Socket.set>,
 <function Socket.get>,
 <bound method Socket.set_string of <zmq.sugar.socket.Socket object at 0x7f51c11eaca8>>,
 <bound method Socket.get_string of <zmq.sugar.socket.Socket object at 0x7f51c11eaca8>>,
 <bound method Socket.set_string of <zmq.sugar.socket.Socket object at 0x7f51c11eaca8>>,
 <bound method Socket.get_string of <zmq.sugar.socket.Socket object at 0x7f51c11eaca8>>,
 <zmq.eventloop.zmqstream.ZMQStream at 0x7f51c1221358>,
 {'_close_callback': None,
  '_flushed': False,
  '_recv_callback': <function tornado.stack_context.wrap.<locals>.null_wrapper>,
  '_recv_copy': False,
  '_send_callback': None,
  '_send_queue': <queue.Queue at 0x7f51c1221160>,
  '_state': 25,
  'bind': <function Socket.bind>,
  'bind_to_random_port': <bound method Socket.bind_to_random_port of <zmq.sugar.socket.Socket object at 0x7f51c11ead68>>,
  'connect': <function Socket.connect>,
  'getsockopt': <function Socket.get>,
  'getsockopt_string': <bound method Socket.get_string of <zmq.sugar.socket.Socket object at 0x7f51c11ead68>>,
  'getsockopt_unicode': <bound method Socket.get_string of <zmq.sugar.socket.Socket object at 0x7f51c11ead68>>,
  'io_loop': <zmq.eventloop.ioloop.ZMQIOLoop at 0x7f51c12214a8>,
  'poller': <zmq.sugar.poll.Poller at 0x7f51c1221198>,
  'setsockopt': <function Socket.set>,
  'setsockopt_string': <bound method Socket.set_string of <zmq.sugar.socket.Socket object at 0x7f51c11ead68>>,
  'setsockopt_unicode': <bound method Socket.set_string of <zmq.sugar.socket.Socket object at 0x7f51c11ead68>>,
  'socket': <zmq.sugar.socket.Socket at 0x7f51c11ead68>},
 <zmq.sugar.poll.Poller at 0x7f51c1221198>,
 {'_map': {}, 'sockets': []},
 <queue.Queue at 0x7f51c1221160>,
 {'all_tasks_done': <Condition(<_thread.lock object at 0x7f51c1289648>, 0)>,
  'maxsize': 0,
  'mutex': <_thread.lock at 0x7f51c1289648>,
  'not_empty': <Condition(<_thread.lock object at 0x7f51c1289648>, 0)>,
  'not_full': <Condition(<_thread.lock object at 0x7f51c1289648>, 0)>,
  'queue': deque([]),
  'unfinished_tasks': 0},
 <Condition(<_thread.lock object at 0x7f51c1289648>, 0)>,
 {'_lock': <_thread.lock at 0x7f51c1289648>,
  '_waiters': deque([]),
  'acquire': <function lock.acquire>,
  'release': <function lock.release>},
 <function lock.release>,
 deque([]),
 <Condition(<_thread.lock object at 0x7f51c1289648>, 0)>,
 {'_lock': <_thread.lock at 0x7f51c1289648>,
  '_waiters': deque([]),
  'acquire': <function lock.acquire>,
  'release': <function lock.release>},
 <function lock.release>,
 deque([]),
 <Condition(<_thread.lock object at 0x7f51c1289648>, 0)>,
 {'_lock': <_thread.lock at 0x7f51c1289648>,
  '_waiters': deque([]),
  'acquire': <function lock.acquire>,
  'release': <function lock.release>},
 <function lock.release>,
 deque([]),
 (<zmq.sugar.socket.Socket at 0x7f51c11ead68>,
  <function tornado.stack_context.wrap.<locals>.null_wrapper>),
 <function Socket.bind>,
 <bound method Socket.bind_to_random_port of <zmq.sugar.socket.Socket object at 0x7f51c11ead68>>,
 <function Socket.connect>,
 <function Socket.set>,
 <function Socket.get>,
 <bound method Socket.set_string of <zmq.sugar.socket.Socket object at 0x7f51c11ead68>>,
 <bound method Socket.get_string of <zmq.sugar.socket.Socket object at 0x7f51c11ead68>>,
 <bound method Socket.set_string of <zmq.sugar.socket.Socket object at 0x7f51c11ead68>>,
 <bound method Socket.get_string of <zmq.sugar.socket.Socket object at 0x7f51c11ead68>>,
 [<zmq.eventloop.zmqstream.ZMQStream at 0x7f51c12216d8>,
  <zmq.eventloop.zmqstream.ZMQStream at 0x7f51c1221358>],
 <ipykernel.ipkernel.IPythonKernel at 0x7f51c1221278>,
 {'_cross_validation_lock': False,
  '_save_getpass': <function getpass.unix_getpass>,
  '_trait_notifiers': {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
  '_trait_validators': {},
  '_trait_values': {'_allow_stdin': True,
   '_darwin_app_nap': True,
   '_execute_sleep': 0.0005,
   '_parent_header': {'buffers': [],
    'content': {'allow_stdin': True,
     'code': 'gc.get_objects()',
     'silent': False,
     'stop_on_error': True,
     'store_history': True,
     'user_expressions': {}},
    'header': {'date': '2016-03-20T19:46:05.318327',
     'msg_id': 'BF3CEE6EC01944EEA25FA7825F7AD98A',
     'msg_type': 'execute_request',
     'session': '4CE6797D9E26478A800FA96DD84CCB50',
     'username': 'username',
     'version': '5.0'},
    'metadata': {},
    'msg_id': 'BF3CEE6EC01944EEA25FA7825F7AD98A',
    'msg_type': 'execute_request',
    'parent_header': {}},
   '_parent_ident': [b'4CE6797D9E26478A800FA96DD84CCB50'],
   '_poll_interval': 0.05,
   '_recorded_ports': {'control': 42492,
    'hb': 39269,
    'iopub': 54629,
    'shell': 39890,
    'stdin': 58359},
   '_sys_eval_input': None,
   '_sys_raw_input': <function input>,
   'aborted': set(),
   'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
   'control_stream': None,
   'eventloop': None,
   'help_links': [{'text': 'Python', 'url': 'http://docs.python.org/3.4'},
    {'text': 'IPython', 'url': 'http://ipython.org/documentation.html'},
    {'text': 'NumPy', 'url': 'http://docs.scipy.org/doc/numpy/reference/'},
    {'text': 'SciPy', 'url': 'http://docs.scipy.org/doc/scipy/reference/'},
    {'text': 'Matplotlib', 'url': 'http://matplotlib.org/contents.html'},
    {'text': 'SymPy', 'url': 'http://docs.sympy.org/latest/index.html'},
    {'text': 'pandas', 'url': 'http://pandas.pydata.org/pandas-docs/stable/'}],
   'ident': '60debbe5-9e37-44be-8878-88c400d6728c',
   'int_id': -1,
   'iopub_socket': <ipykernel.iostream.BackgroundSocket at 0x7f51c124bdd8>,
   'iopub_thread': <ipykernel.iostream.IOPubThread at 0x7f51c124be48>,
   'log': <logging.Logger at 0x7f51d2a1aba8>,
   'parent': <ipykernel.kernelapp.IPKernelApp at 0x7f51d2a1ac18>,
   'profile_dir': <IPython.core.profiledir.ProfileDir at 0x7f51c1221518>,
   'session': <jupyter_client.session.Session at 0x7f51c124be10>,
   'shell': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>,
   'shell_class': ipykernel.zmqshell.ZMQInteractiveShell,
   'shell_streams': [<zmq.eventloop.zmqstream.ZMQStream at 0x7f51c12216d8>,
    <zmq.eventloop.zmqstream.ZMQStream at 0x7f51c1221358>],
   'stdin_socket': <zmq.sugar.socket.Socket at 0x7f51c11ead08>,
   'user_module': None,
   'user_ns': None},
  'comm_manager': <ipykernel.comm.manager.CommManager at 0x7f51c0147940>,
  'control_handlers': {'abort_request': <bound method IPythonKernel.abort_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
   'apply_request': <bound method IPythonKernel.apply_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
   'clear_request': <bound method IPythonKernel.clear_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
   'comm_info_request': <bound method IPythonKernel.comm_info_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
   'complete_request': <bound method IPythonKernel.complete_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
   'connect_request': <bound method IPythonKernel.connect_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
   'execute_request': <bound method IPythonKernel.execute_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
   'history_request': <bound method IPythonKernel.history_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
   'inspect_request': <bound method IPythonKernel.inspect_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
   'is_complete_request': <bound method IPythonKernel.is_complete_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
   'kernel_info_request': <bound method IPythonKernel.kernel_info_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
   'shutdown_request': <bound method IPythonKernel.shutdown_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>},
  'saved_sigint_handler': 1,
  'shell_handlers': {'apply_request': <bound method IPythonKernel.apply_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
   'comm_close': <bound method CommManager.comm_close of <ipykernel.comm.manager.CommManager object at 0x7f51c0147940>>,
   'comm_info_request': <bound method IPythonKernel.comm_info_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
   'comm_msg': <bound method CommManager.comm_msg of <ipykernel.comm.manager.CommManager object at 0x7f51c0147940>>,
   'comm_open': <bound method CommManager.comm_open of <ipykernel.comm.manager.CommManager object at 0x7f51c0147940>>,
   'complete_request': <bound method IPythonKernel.complete_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
   'connect_request': <bound method IPythonKernel.connect_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
   'execute_request': <bound method IPythonKernel.execute_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
   'history_request': <bound method IPythonKernel.history_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
   'inspect_request': <bound method IPythonKernel.inspect_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
   'is_complete_request': <bound method IPythonKernel.is_complete_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
   'kernel_info_request': <bound method IPythonKernel.kernel_info_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
   'shutdown_request': <bound method IPythonKernel.shutdown_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>}},
 {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
 (27075,
  1457880526.352978,
  ['"""Base class for a kernel that talks to frontends over 0MQ."""\n',
   '\n',
   '# Copyright (c) IPython Development Team.\n',
   '# Distributed under the terms of the Modified BSD License.\n',
   '\n',
   'from __future__ import print_function\n',
   '\n',
   'import sys\n',
   'import time\n',
   'import logging\n',
   'import uuid\n',
   '\n',
   'from datetime import datetime\n',
   'from signal import (\n',
   '        signal, default_int_handler, SIGINT\n',
   ')\n',
   '\n',
   'import zmq\n',
   'from zmq.eventloop import ioloop\n',
   'from zmq.eventloop.zmqstream import ZMQStream\n',
   '\n',
   'from traitlets.config.configurable import SingletonConfigurable\n',
   'from IPython.core.error import StdinNotImplementedError\n',
   'from ipython_genutils import py3compat\n',
   'from ipython_genutils.py3compat import unicode_type, string_types\n',
   'from ipykernel.jsonutil import json_clean\n',
   'from traitlets import (\n',
   '    Any, Instance, Float, Dict, List, Set, Integer, Unicode, Bool,\n',
   ')\n',
   '\n',
   'from jupyter_client.session import Session\n',
   '\n',
   'from ._version import kernel_protocol_version\n',
   '\n',
   'class Kernel(SingletonConfigurable):\n',
   '\n',
   '    #---------------------------------------------------------------------------\n',
   '    # Kernel interface\n',
   '    #---------------------------------------------------------------------------\n',
   '\n',
   '    # attribute to override with a GUI\n',
   '    eventloop = Any(None)\n',
   '    def _eventloop_changed(self, name, old, new):\n',
   '        """schedule call to eventloop from IOLoop"""\n',
   '        loop = ioloop.IOLoop.instance()\n',
   '        loop.add_callback(self.enter_eventloop)\n',
   '\n',
   '    session = Instance(Session, allow_none=True)\n',
   "    profile_dir = Instance('IPython.core.profiledir.ProfileDir', allow_none=True)\n",
   '    shell_streams = List()\n',
   '    control_stream = Instance(ZMQStream, allow_none=True)\n',
   '    iopub_socket = Any()\n',
   '    iopub_thread = Any()\n',
   '    stdin_socket = Any()\n',
   '    log = Instance(logging.Logger, allow_none=True)\n',
   '\n',
   '    # identities:\n',
   '    int_id = Integer(-1)\n',
   '    ident = Unicode()\n',
   '\n',
   '    def _ident_default(self):\n',
   '        return unicode_type(uuid.uuid4())\n',
   '\n',
   '    # This should be overridden by wrapper kernels that implement any real\n',
   '    # language.\n',
   '    language_info = {}\n',
   '\n',
   '    # any links that should go in the help menu\n',
   '    help_links = List()\n',
   '\n',
   '    # Private interface\n',
   '\n',
   '    _darwin_app_nap = Bool(True, config=True,\n',
   '        help="""Whether to use appnope for compatiblity with OS X App Nap.\n',
   '\n',
   '        Only affects OS X >= 10.9.\n',
   '        """\n',
   '    )\n',
   '\n',
   '    # track associations with current request\n',
   '    _allow_stdin = Bool(False)\n',
   '    _parent_header = Dict()\n',
   "    _parent_ident = Any(b'')\n",
   '    # Time to sleep after flushing the stdout/err buffers in each execute\n',
   '    # cycle.  While this introduces a hard limit on the minimal latency of the\n',
   '    # execute cycle, it helps prevent output synchronization problems for\n',
   '    # clients.\n',
   '    # Units are in seconds.  The minimum zmq latency on local host is probably\n',
   '    # ~150 microseconds, set this to 500us for now.  We may need to increase it\n',
   "    # a little if it's not enough after more interactive testing.\n",
   '    _execute_sleep = Float(0.0005, config=True)\n',
   '\n',
   "    # Frequency of the kernel's event loop.\n",
   '    # Units are in seconds, kernel subclasses for GUI toolkits may need to\n',
   '    # adapt to milliseconds.\n',
   '    _poll_interval = Float(0.05, config=True)\n',
   '\n',
   '    # If the shutdown was requested over the network, we leave here the\n',
   '    # necessary reply message so it can be sent by our registered atexit\n',
   '    # handler.  This ensures that the reply is only sent to clients truly at\n',
   '    # the end of our shutdown process (which happens after the underlying\n',
   "    # IPython shell's own shutdown).\n",
   '    _shutdown_message = None\n',
   '\n',
   '    # This is a dict of port number that the kernel is listening on. It is set\n',
   '    # by record_ports and used by connect_request.\n',
   '    _recorded_ports = Dict()\n',
   '\n',
   '    # set of aborted msg_ids\n',
   '    aborted = Set()\n',
   '\n',
   '    # Track execution count here. For IPython, we override this to use the\n',
   '    # execution count we store in the shell.\n',
   '    execution_count = 0\n',
   '    \n',
   '    msg_types = [\n',
   "        'execute_request', 'complete_request',\n",
   "        'inspect_request', 'history_request',\n",
   "        'comm_info_request', 'kernel_info_request',\n",
   "        'connect_request', 'shutdown_request',\n",
   "        'is_complete_request',\n",
   '        # deprecated:\n',
   "        'apply_request',\n",
   '    ]\n',
   '    # add deprecated ipyparallel control messages\n',
   "    control_msg_types = msg_types + ['clear_request', 'abort_request']\n",
   '\n',
   '    def __init__(self, **kwargs):\n',
   '        super(Kernel, self).__init__(**kwargs)\n',
   '\n',
   '        # Build dict of handlers for message types\n',
   '        self.shell_handlers = {}\n',
   '        for msg_type in self.msg_types:\n',
   '            self.shell_handlers[msg_type] = getattr(self, msg_type)\n',
   '\n',
   '        self.control_handlers = {}\n',
   '        for msg_type in self.control_msg_types:\n',
   '            self.control_handlers[msg_type] = getattr(self, msg_type)\n',
   '\n',
   '\n',
   '    def dispatch_control(self, msg):\n',
   '        """dispatch control requests"""\n',
   '        idents,msg = self.session.feed_identities(msg, copy=False)\n',
   '        try:\n',
   '            msg = self.session.deserialize(msg, content=True, copy=False)\n',
   '        except:\n',
   '            self.log.error("Invalid Control Message", exc_info=True)\n',
   '            return\n',
   '\n',
   '        self.log.debug("Control received: %s", msg)\n',
   '\n',
   '        # Set the parent message for side effects.\n',
   '        self.set_parent(idents, msg)\n',
   "        self._publish_status(u'busy')\n",
   '\n',
   "        header = msg['header']\n",
   "        msg_type = header['msg_type']\n",
   '\n',
   '        handler = self.control_handlers.get(msg_type, None)\n',
   '        if handler is None:\n',
   '            self.log.error("UNKNOWN CONTROL MESSAGE TYPE: %r", msg_type)\n',
   '        else:\n',
   '            try:\n',
   '                handler(self.control_stream, idents, msg)\n',
   '            except Exception:\n',
   '                self.log.error("Exception in control handler:", exc_info=True)\n',
   '\n',
   '        sys.stdout.flush()\n',
   '        sys.stderr.flush()\n',
   "        self._publish_status(u'idle')\n",
   '\n',
   '    def should_handle(self, stream, msg, idents):\n',
   '        """Check whether a shell-channel message should be handled\n',
   '        \n',
   '        Allows subclasses to prevent handling of certain messages (e.g. aborted requests).\n',
   '        """\n',
   "        msg_id = msg['header']['msg_id']\n",
   '        if msg_id in self.aborted:\n',
   "            msg_type = msg['header']['msg_type']\n",
   '            # is it safe to assume a msg_id will not be resubmitted?\n',
   '            self.aborted.remove(msg_id)\n',
   "            reply_type = msg_type.split('_')[0] + '_reply'\n",
   "            status = {'status' : 'aborted'}\n",
   "            md = {'engine' : self.ident}\n",
   '            md.update(status)\n',
   '            self.session.send(stream, reply_type, metadata=md,\n',
   '                        content=status, parent=msg, ident=idents)\n',
   '            return False\n',
   '        return True\n',
   '\n',
   '    def dispatch_shell(self, stream, msg):\n',
   '        """dispatch shell requests"""\n',
   '        # flush control requests first\n',
   '        if self.control_stream:\n',
   '            self.control_stream.flush()\n',
   '\n',
   '        idents,msg = self.session.feed_identities(msg, copy=False)\n',
   '        try:\n',
   '            msg = self.session.deserialize(msg, content=True, copy=False)\n',
   '        except:\n',
   '            self.log.error("Invalid Message", exc_info=True)\n',
   '            return\n',
   '\n',
   '        # Set the parent message for side effects.\n',
   '        self.set_parent(idents, msg)\n',
   "        self._publish_status(u'busy')\n",
   '\n',
   "        header = msg['header']\n",
   "        msg_id = header['msg_id']\n",
   "        msg_type = msg['header']['msg_type']\n",
   '\n',
   "        # Print some info about this message and leave a '--->' marker, so it's\n",
   '        # easier to trace visually the message chain when debugging.  Each\n',
   '        # handler prints its message at the end.\n',
   "        self.log.debug('\\n*** MESSAGE TYPE:%s***', msg_type)\n",
   "        self.log.debug('   Content: %s\\n   --->\\n   ', msg['content'])\n",
   '\n',
   '        if not self.should_handle(stream, msg, idents):\n',
   '            return\n',
   '\n',
   '        handler = self.shell_handlers.get(msg_type, None)\n',
   '        if handler is None:\n',
   '            self.log.error("UNKNOWN MESSAGE TYPE: %r", msg_type)\n',
   '        else:\n',
   '            self.log.debug("%s: %s", msg_type, msg)\n',
   '            self.pre_handler_hook()\n',
   '            try:\n',
   '                handler(stream, idents, msg)\n',
   '            except Exception:\n',
   '                self.log.error("Exception in message handler:", exc_info=True)\n',
   '            finally:\n',
   '                self.post_handler_hook()\n',
   '\n',
   '        sys.stdout.flush()\n',
   '        sys.stderr.flush()\n',
   "        self._publish_status(u'idle')\n",
   '\n',
   '    def pre_handler_hook(self):\n',
   '        """Hook to execute before calling message handler"""\n',
   '        # ensure default_int_handler during handler call\n',
   '        self.saved_sigint_handler = signal(SIGINT, default_int_handler)\n',
   '\n',
   '    def post_handler_hook(self):\n',
   '        """Hook to execute after calling message handler"""\n',
   '        signal(SIGINT, self.saved_sigint_handler)\n',
   '\n',
   '    def enter_eventloop(self):\n',
   '        """enter eventloop"""\n',
   '        self.log.info("entering eventloop %s", self.eventloop)\n',
   '        for stream in self.shell_streams:\n',
   '            # flush any pending replies,\n',
   '            # which may be skipped by entering the eventloop\n',
   '            stream.flush(zmq.POLLOUT)\n',
   '        # restore default_int_handler\n',
   '        signal(SIGINT, default_int_handler)\n',
   '        while self.eventloop is not None:\n',
   '            try:\n',
   '                self.eventloop(self)\n',
   '            except KeyboardInterrupt:\n',
   "                # Ctrl-C shouldn't crash the kernel\n",
   '                self.log.error("KeyboardInterrupt caught in kernel")\n',
   '                continue\n',
   '            else:\n',
   '                # eventloop exited cleanly, this means we should stop (right?)\n',
   '                self.eventloop = None\n',
   '                break\n',
   '        self.log.info("exiting eventloop")\n',
   '\n',
   '    def start(self):\n',
   '        """register dispatchers for streams"""\n',
   '        if self.control_stream:\n',
   '            self.control_stream.on_recv(self.dispatch_control, copy=False)\n',
   '\n',
   '        def make_dispatcher(stream):\n',
   '            def dispatcher(msg):\n',
   '                return self.dispatch_shell(stream, msg)\n',
   '            return dispatcher\n',
   '\n',
   '        for s in self.shell_streams:\n',
   '            s.on_recv(make_dispatcher(s), copy=False)\n',
   '\n',
   '        # publish idle status\n',
   "        self._publish_status('starting')\n",
   '\n',
   '    def do_one_iteration(self):\n',
   '        """step eventloop just once"""\n',
   '        if self.control_stream:\n',
   '            self.control_stream.flush()\n',
   '        for stream in self.shell_streams:\n',
   '            # handle at most one request per iteration\n',
   '            stream.flush(zmq.POLLIN, 1)\n',
   '            stream.flush(zmq.POLLOUT)\n',
   '\n',
   '\n',
   '    def record_ports(self, ports):\n',
   '        """Record the ports that this kernel is using.\n',
   '\n',
   '        The creator of the Kernel instance must call this methods if they\n',
   '        want the :meth:`connect_request` method to return the port numbers.\n',
   '        """\n',
   '        self._recorded_ports = ports\n',
   '\n',
   '    #---------------------------------------------------------------------------\n',
   '    # Kernel request handlers\n',
   '    #---------------------------------------------------------------------------\n',
   '\n',
   '    def _publish_execute_input(self, code, parent, execution_count):\n',
   '        """Publish the code request on the iopub stream."""\n',
   '\n',
   "        self.session.send(self.iopub_socket, u'execute_input',\n",
   "                            {u'code':code, u'execution_count': execution_count},\n",
   "                            parent=parent, ident=self._topic('execute_input')\n",
   '        )\n',
   '\n',
   '    def _publish_status(self, status, parent=None):\n',
   '        """send status (busy/idle) on IOPub"""\n',
   '        self.session.send(self.iopub_socket,\n',
   "                          u'status',\n",
   "                          {u'execution_state': status},\n",
   '                          parent=parent or self._parent_header,\n',
   "                          ident=self._topic('status'),\n",
   '                          )\n',
   '\n',
   '    def set_parent(self, ident, parent):\n',
   '        """Set the current parent_header\n',
   '\n',
   '        Side effects (IOPub messages) and replies are associated with\n',
   '        the request that caused them via the parent_header.\n',
   '\n',
   '        The parent identity is used to route input_request messages\n',
   '        on the stdin channel.\n',
   '        """\n',
   '        self._parent_ident = ident\n',
   '        self._parent_header = parent\n',
   '\n',
   '    def send_response(self, stream, msg_or_type, content=None, ident=None,\n',
   '             buffers=None, track=False, header=None, metadata=None):\n',
   '        """Send a response to the message we\'re currently processing.\n',
   '\n',
   '        This accepts all the parameters of :meth:`jupyter_client.session.Session.send`\n',
   '        except ``parent``.\n',
   '\n',
   '        This relies on :meth:`set_parent` having been called for the current\n',
   '        message.\n',
   '        """\n',
   '        return self.session.send(stream, msg_or_type, content, self._parent_header,\n',
   '                                 ident, buffers, track, header, metadata)\n',
   '    \n',
   '    def init_metadata(self, parent):\n',
   '        """Initialize metadata.\n',
   '        \n',
   '        Run at the beginning of execution requests.\n',
   '        """\n',
   '        return {\n',
   "            'started': datetime.now(),\n",
   '        }\n',
   '    \n',
   '    def finish_metadata(self, parent, metadata, reply_content):\n',
   '        """Finish populating metadata.\n',
   '        \n',
   '        Run after completing an execution request.\n',
   '        """\n',
   '        return metadata\n',
   '\n',
   '    def execute_request(self, stream, ident, parent):\n',
   '        """handle an execute_request"""\n',
   '\n',
   '        try:\n',
   "            content = parent[u'content']\n",
   "            code = py3compat.cast_unicode_py2(content[u'code'])\n",
   "            silent = content[u'silent']\n",
   "            store_history = content.get(u'store_history', not silent)\n",
   "            user_expressions = content.get('user_expressions', {})\n",
   "            allow_stdin = content.get('allow_stdin', False)\n",
   '        except:\n',
   '            self.log.error("Got bad msg: ")\n',
   '            self.log.error("%s", parent)\n',
   '            return\n',
   '\n',
   "        stop_on_error = content.get('stop_on_error', True)\n",
   '\n',
   '        metadata = self.init_metadata(parent)\n',
   '\n',
   '        # Re-broadcast our input for the benefit of listening clients, and\n',
   '        # start computing output\n',
   '        if not silent:\n',
   '            self.execution_count += 1\n',
   '            self._publish_execute_input(code, parent, self.execution_count)\n',
   '\n',
   '        reply_content = self.do_execute(code, silent, store_history,\n',
   '                                        user_expressions, allow_stdin)\n',
   '\n',
   '        # Flush output before sending the reply.\n',
   '        sys.stdout.flush()\n',
   '        sys.stderr.flush()\n',
   "        # FIXME: on rare occasions, the flush doesn't seem to make it to the\n",
   '        # clients... This seems to mitigate the problem, but we definitely need\n',
   "        # to better understand what's going on.\n",
   '        if self._execute_sleep:\n',
   '            time.sleep(self._execute_sleep)\n',
   '\n',
   '        # Send the reply.\n',
   '        reply_content = json_clean(reply_content)\n',
   '        metadata = self.finish_metadata(parent, metadata, reply_content)\n',
   '\n',
   "        reply_msg = self.session.send(stream, u'execute_reply',\n",
   '                                      reply_content, parent, metadata=metadata,\n',
   '                                      ident=ident)\n',
   '\n',
   '        self.log.debug("%s", reply_msg)\n',
   '\n',
   "        if not silent and reply_msg['content']['status'] == u'error' and stop_on_error:\n",
   '            self._abort_queues()\n',
   '\n',
   '    def do_execute(self, code, silent, store_history=True,\n',
   '                   user_expressions=None, allow_stdin=False):\n',
   '        """Execute user code. Must be overridden by subclasses.\n',
   '        """\n',
   '        raise NotImplementedError\n',
   '\n',
   '    def complete_request(self, stream, ident, parent):\n',
   "        content = parent['content']\n",
   "        code = content['code']\n",
   "        cursor_pos = content['cursor_pos']\n",
   '\n',
   '        matches = self.do_complete(code, cursor_pos)\n',
   '        matches = json_clean(matches)\n',
   "        completion_msg = self.session.send(stream, 'complete_reply',\n",
   '                                           matches, parent, ident)\n',
   '        self.log.debug("%s", completion_msg)\n',
   '\n',
   '    def do_complete(self, code, cursor_pos):\n',
   '        """Override in subclasses to find completions.\n',
   '        """\n',
   "        return {'matches' : [],\n",
   "                'cursor_end' : cursor_pos,\n",
   "                'cursor_start' : cursor_pos,\n",
   "                'metadata' : {},\n",
   "                'status' : 'ok'}\n",
   '\n',
   '    def inspect_request(self, stream, ident, parent):\n',
   "        content = parent['content']\n",
   '\n',
   "        reply_content = self.do_inspect(content['code'], content['cursor_pos'],\n",
   "                                        content.get('detail_level', 0))\n",
   '        # Before we send this object over, we scrub it for JSON usage\n',
   '        reply_content = json_clean(reply_content)\n',
   "        msg = self.session.send(stream, 'inspect_reply',\n",
   '                                reply_content, parent, ident)\n',
   '        self.log.debug("%s", msg)\n',
   '\n',
   '    def do_inspect(self, code, cursor_pos, detail_level=0):\n',
   '        """Override in subclasses to allow introspection.\n',
   '        """\n',
   "        return {'status': 'ok', 'data': {}, 'metadata': {}, 'found': False}\n",
   '\n',
   '    def history_request(self, stream, ident, parent):\n',
   "        content = parent['content']\n",
   '\n',
   '        reply_content = self.do_history(**content)\n',
   '\n',
   '        reply_content = json_clean(reply_content)\n',
   "        msg = self.session.send(stream, 'history_reply',\n",
   '                                reply_content, parent, ident)\n',
   '        self.log.debug("%s", msg)\n',
   '\n',
   '    def do_history(self, hist_access_type, output, raw, session=None, start=None,\n',
   '                   stop=None, n=None, pattern=None, unique=False):\n',
   '        """Override in subclasses to access history.\n',
   '        """\n',
   "        return {'history': []}\n",
   '\n',
   '    def connect_request(self, stream, ident, parent):\n',
   '        if self._recorded_ports is not None:\n',
   '            content = self._recorded_ports.copy()\n',
   '        else:\n',
   '            content = {}\n',
   "        msg = self.session.send(stream, 'connect_reply',\n",
   '                                content, parent, ident)\n',
   '        self.log.debug("%s", msg)\n',
   '\n',
   '    @property\n',
   '    def kernel_info(self):\n',
   '        return {\n',
   "            'protocol_version': kernel_protocol_version,\n",
   "            'implementation': self.implementation,\n",
   "            'implementation_version': self.implementation_version,\n",
   "            'language_info': self.language_info,\n",
   "            'banner': self.banner,\n",
   "            'help_links': self.help_links,\n",
   '        }\n',
   '\n',
   '    def kernel_info_request(self, stream, ident, parent):\n',
   "        msg = self.session.send(stream, 'kernel_info_reply',\n",
   '                                self.kernel_info, parent, ident)\n',
   '        self.log.debug("%s", msg)\n',
   '\n',
   '    def comm_info_request(self, stream, ident, parent):\n',
   "        content = parent['content']\n",
   "        target_name = content.get('target_name', None)\n",
   '\n',
   '        # Should this be moved to ipkernel?\n',
   "        if hasattr(self, 'comm_manager'):\n",
   '            comms = {\n',
   '                k: dict(target_name=v.target_name)\n',
   '                for (k, v) in self.comm_manager.comms.items()\n',
   '                if v.target_name == target_name or target_name is None\n',
   '            }\n',
   '        else:\n',
   '            comms = {}\n',
   '        reply_content = dict(comms=comms)\n',
   "        msg = self.session.send(stream, 'comm_info_reply',\n",
   '                                reply_content, parent, ident)\n',
   '        self.log.debug("%s", msg)\n',
   '\n',
   '    def shutdown_request(self, stream, ident, parent):\n',
   "        content = self.do_shutdown(parent['content']['restart'])\n",
   "        self.session.send(stream, u'shutdown_reply', content, parent, ident=ident)\n",
   '        # same content, but different msg_id for broadcasting on IOPub\n',
   "        self._shutdown_message = self.session.msg(u'shutdown_reply',\n",
   '                                                  content, parent\n',
   '        )\n',
   '\n',
   '        self._at_shutdown()\n',
   '        # call sys.exit after a short delay\n',
   '        loop = ioloop.IOLoop.instance()\n',
   '        loop.add_timeout(time.time()+0.1, loop.stop)\n',
   '\n',
   '    def do_shutdown(self, restart):\n',
   '        """Override in subclasses to do things when the frontend shuts down the\n',
   '        kernel.\n',
   '        """\n',
   "        return {'status': 'ok', 'restart': restart}\n",
   '\n',
   '    def is_complete_request(self, stream, ident, parent):\n',
   "        content = parent['content']\n",
   "        code = content['code']\n",
   '\n',
   '        reply_content = self.do_is_complete(code)\n',
   '        reply_content = json_clean(reply_content)\n',
   "        reply_msg = self.session.send(stream, 'is_complete_reply',\n",
   '                                           reply_content, parent, ident)\n',
   '        self.log.debug("%s", reply_msg)\n',
   '\n',
   '    def do_is_complete(self, code):\n',
   '        """Override in subclasses to find completions.\n',
   '        """\n',
   "        return {'status' : 'unknown',\n",
   '                }\n',
   '\n',
   '    #---------------------------------------------------------------------------\n',
   '    # Engine methods (DEPRECATED)\n',
   '    #---------------------------------------------------------------------------\n',
   '\n',
   '    def apply_request(self, stream, ident, parent):\n',
   '        self.log.warn("""apply_request is deprecated in kernel_base, moving to ipyparallel.""")\n',
   '        try:\n',
   "            content = parent[u'content']\n",
   "            bufs = parent[u'buffers']\n",
   "            msg_id = parent['header']['msg_id']\n",
   '        except:\n',
   '            self.log.error("Got bad msg: %s", parent, exc_info=True)\n',
   '            return\n',
   '\n',
   '        md = self.init_metadata(parent)\n',
   '\n',
   '        reply_content, result_buf = self.do_apply(content, bufs, msg_id, md)\n',
   '        \n',
   '        # flush i/o\n',
   '        sys.stdout.flush()\n',
   '        sys.stderr.flush()\n',
   '\n',
   '        md = self.finish_metadata(parent, md, reply_content)\n',
   '\n',
   "        self.session.send(stream, u'apply_reply', reply_content,\n",
   '                    parent=parent, ident=ident,buffers=result_buf, metadata=md)\n',
   '\n',
   '    def do_apply(self, content, bufs, msg_id, reply_metadata):\n',
   '        """DEPRECATED"""\n',
   '        raise NotImplementedError\n',
   '\n',
   '    #---------------------------------------------------------------------------\n',
   '    # Control messages (DEPRECATED)\n',
   '    #---------------------------------------------------------------------------\n',
   '\n',
   '    def abort_request(self, stream, ident, parent):\n',
   '        """abort a specific msg by id"""\n',
   '        self.log.warn("abort_request is deprecated in kernel_base. It os only part of IPython parallel")\n',
   "        msg_ids = parent['content'].get('msg_ids', None)\n",
   '        if isinstance(msg_ids, string_types):\n',
   '            msg_ids = [msg_ids]\n',
   '        if not msg_ids:\n',
   '            self._abort_queues()\n',
   '        for mid in msg_ids:\n',
   '            self.aborted.add(str(mid))\n',
   '\n',
   "        content = dict(status='ok')\n",
   "        reply_msg = self.session.send(stream, 'abort_reply', content=content,\n",
   '                parent=parent, ident=ident)\n',
   '        self.log.debug("%s", reply_msg)\n',
   '\n',
   '    def clear_request(self, stream, idents, parent):\n',
   '        """Clear our namespace."""\n',
   '        self.log.warn("clear_request is deprecated in kernel_base. It os only part of IPython parallel")\n',
   '        content = self.do_clear()\n',
   "        self.session.send(stream, 'clear_reply', ident=idents, parent=parent,\n",
   '                content = content)\n',
   '\n',
   '    def do_clear(self):\n',
   '        """DEPRECATED"""\n',
   '        raise NotImplementedError\n',
   '\n',
   '    #---------------------------------------------------------------------------\n',
   '    # Protected interface\n',
   '    #---------------------------------------------------------------------------\n',
   '\n',
   '    def _topic(self, topic):\n',
   '        """prefixed topic for IOPub messages"""\n',
   '        base = "kernel.%s" % self.ident\n',
   '\n',
   '        return py3compat.cast_bytes("%s.%s" % (base, topic))\n',
   '\n',
   '    def _abort_queues(self):\n',
   '        for stream in self.shell_streams:\n',
   '            if stream:\n',
   '                self._abort_queue(stream)\n',
   '\n',
   '    def _abort_queue(self, stream):\n',
   '        poller = zmq.Poller()\n',
   '        poller.register(stream.socket, zmq.POLLIN)\n',
   '        while True:\n',
   '            idents,msg = self.session.recv(stream, zmq.NOBLOCK, content=True)\n',
   '            if msg is None:\n',
   '                return\n',
   '\n',
   '            self.log.info("Aborting:")\n',
   '            self.log.info("%s", msg)\n',
   "            msg_type = msg['header']['msg_type']\n",
   "            reply_type = msg_type.split('_')[0] + '_reply'\n",
   '\n',
   "            status = {'status' : 'aborted'}\n",
   "            md = {'engine' : self.ident}\n",
   '            md.update(status)\n',
   '            reply_msg = self.session.send(stream, reply_type, metadata=md,\n',
   '                        content=status, parent=msg, ident=idents)\n',
   '            self.log.debug("%s", reply_msg)\n',
   '            # We need to wait a bit for requests to come in. This can probably\n',
   '            # be set shorter for true asynchronous clients.\n',
   '            poller.poll(50)\n',
   '\n',
   '\n',
   '    def _no_raw_input(self):\n',
   '        """Raise StdinNotImplentedError if active frontend doesn\'t support\n',
   '        stdin."""\n',
   '        raise StdinNotImplementedError("raw_input was called, but this "\n',
   '                                       "frontend does not support stdin.")\n',
   '\n',
   "    def getpass(self, prompt=''):\n",
   '        """Forward getpass to frontends\n',
   '\n',
   '        Raises\n',
   '        ------\n',
   "        StdinNotImplentedError if active frontend doesn't support stdin.\n",
   '        """\n',
   '        if not self._allow_stdin:\n',
   '            raise StdinNotImplementedError(\n',
   '                "getpass was called, but this frontend does not support input requests."\n',
   '            )\n',
   '        return self._input_request(prompt,\n',
   '            self._parent_ident,\n',
   '            self._parent_header,\n',
   '            password=True,\n',
   '        )\n',
   '\n',
   "    def raw_input(self, prompt=''):\n",
   '        """Forward raw_input to frontends\n',
   '\n',
   '        Raises\n',
   '        ------\n',
   "        StdinNotImplentedError if active frontend doesn't support stdin.\n",
   '        """\n',
   '        if not self._allow_stdin:\n',
   '            raise StdinNotImplementedError(\n',
   '                "raw_input was called, but this frontend does not support input requests."\n',
   '            )\n',
   '        return self._input_request(prompt,\n',
   '            self._parent_ident,\n',
   '            self._parent_header,\n',
   '            password=False,\n',
   '        )\n',
   '\n',
   '    def _input_request(self, prompt, ident, parent, password=False):\n',
   '        # Flush output before making the request.\n',
   '        sys.stderr.flush()\n',
   '        sys.stdout.flush()\n',
   '        # flush the stdin socket, to purge stale replies\n',
   '        while True:\n',
   '            try:\n',
   '                self.stdin_socket.recv_multipart(zmq.NOBLOCK)\n',
   '            except zmq.ZMQError as e:\n',
   '                if e.errno == zmq.EAGAIN:\n',
   '                    break\n',
   '                else:\n',
   '                    raise\n',
   '\n',
   '        # Send the input request.\n',
   '        content = json_clean(dict(prompt=prompt, password=password))\n',
   "        self.session.send(self.stdin_socket, u'input_request', content, parent,\n",
   '                          ident=ident)\n',
   '\n',
   '        # Await a response.\n',
   '        while True:\n',
   '            try:\n',
   '                ident, reply = self.session.recv(self.stdin_socket, 0)\n',
   '            except Exception:\n',
   '                self.log.warn("Invalid Message:", exc_info=True)\n',
   '            except KeyboardInterrupt:\n',
   '                # re-raise KeyboardInterrupt, to truncate traceback\n',
   '                raise KeyboardInterrupt\n',
   '            else:\n',
   '                break\n',
   '        try:\n',
   "            value = py3compat.unicode_to_str(reply['content']['value'])\n",
   '        except:\n',
   '            self.log.error("Bad input_reply: %s", parent)\n',
   "            value = ''\n",
   "        if value == '\\x04':\n",
   '            # EOF\n',
   '            raise EOFError\n',
   '        return value\n',
   '\n',
   '    def _at_shutdown(self):\n',
   '        """Actions taken at shutdown by the kernel, called by python\'s atexit.\n',
   '        """\n',
   '        # io.rprint("Kernel at_shutdown") # dbg\n',
   '        if self._shutdown_message is not None:\n',
   "            self.session.send(self.iopub_socket, self._shutdown_message, ident=self._topic('shutdown'))\n",
   '            self.log.debug("%s", self._shutdown_message)\n',
   '        [ s.flush(zmq.POLLOUT) for s in self.shell_streams ]\n'],
  '/home/pasha/.local/lib/python3.4/site-packages/ipykernel/kernelbase.py'),
 {'_allow_stdin': True,
  '_darwin_app_nap': True,
  '_execute_sleep': 0.0005,
  '_parent_header': {'buffers': [],
   'content': {'allow_stdin': True,
    'code': 'gc.get_objects()',
    'silent': False,
    'stop_on_error': True,
    'store_history': True,
    'user_expressions': {}},
   'header': {'date': '2016-03-20T19:46:05.318327',
    'msg_id': 'BF3CEE6EC01944EEA25FA7825F7AD98A',
    'msg_type': 'execute_request',
    'session': '4CE6797D9E26478A800FA96DD84CCB50',
    'username': 'username',
    'version': '5.0'},
   'metadata': {},
   'msg_id': 'BF3CEE6EC01944EEA25FA7825F7AD98A',
   'msg_type': 'execute_request',
   'parent_header': {}},
  '_parent_ident': [b'4CE6797D9E26478A800FA96DD84CCB50'],
  '_poll_interval': 0.05,
  '_recorded_ports': {'control': 42492,
   'hb': 39269,
   'iopub': 54629,
   'shell': 39890,
   'stdin': 58359},
  '_sys_eval_input': None,
  '_sys_raw_input': <function input>,
  'aborted': set(),
  'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
  'control_stream': None,
  'eventloop': None,
  'help_links': [{'text': 'Python', 'url': 'http://docs.python.org/3.4'},
   {'text': 'IPython', 'url': 'http://ipython.org/documentation.html'},
   {'text': 'NumPy', 'url': 'http://docs.scipy.org/doc/numpy/reference/'},
   {'text': 'SciPy', 'url': 'http://docs.scipy.org/doc/scipy/reference/'},
   {'text': 'Matplotlib', 'url': 'http://matplotlib.org/contents.html'},
   {'text': 'SymPy', 'url': 'http://docs.sympy.org/latest/index.html'},
   {'text': 'pandas', 'url': 'http://pandas.pydata.org/pandas-docs/stable/'}],
  'ident': '60debbe5-9e37-44be-8878-88c400d6728c',
  'int_id': -1,
  'iopub_socket': <ipykernel.iostream.BackgroundSocket at 0x7f51c124bdd8>,
  'iopub_thread': <ipykernel.iostream.IOPubThread at 0x7f51c124be48>,
  'log': <logging.Logger at 0x7f51d2a1aba8>,
  'parent': <ipykernel.kernelapp.IPKernelApp at 0x7f51d2a1ac18>,
  'profile_dir': <IPython.core.profiledir.ProfileDir at 0x7f51c1221518>,
  'session': <jupyter_client.session.Session at 0x7f51c124be10>,
  'shell': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>,
  'shell_class': ipykernel.zmqshell.ZMQInteractiveShell,
  'shell_streams': [<zmq.eventloop.zmqstream.ZMQStream at 0x7f51c12216d8>,
   <zmq.eventloop.zmqstream.ZMQStream at 0x7f51c1221358>],
  'stdin_socket': <zmq.sugar.socket.Socket at 0x7f51c11ead08>,
  'user_module': None,
  'user_ns': None},
 (14435,
  1457880526.3519778,
  ['"""The IPython kernel implementation"""\n',
   '\n',
   'import getpass\n',
   'import sys\n',
   'import traceback\n',
   '\n',
   'from IPython.core import release\n',
   'from ipython_genutils.py3compat import builtin_mod, PY3\n',
   'from IPython.utils.tokenutil import token_at_cursor, line_at_cursor\n',
   'from traitlets import Instance, Type, Any, List\n',
   '\n',
   'from .comm import CommManager\n',
   'from .kernelbase import Kernel as KernelBase\n',
   'from .zmqshell import ZMQInteractiveShell\n',
   '\n',
   '\n',
   'class IPythonKernel(KernelBase):\n',
   "    shell = Instance('IPython.core.interactiveshell.InteractiveShellABC',\n",
   '                     allow_none=True)\n',
   '    shell_class = Type(ZMQInteractiveShell)\n',
   '\n',
   '    user_module = Any()\n',
   '    def _user_module_changed(self, name, old, new):\n',
   '        if self.shell is not None:\n',
   '            self.shell.user_module = new\n',
   '\n',
   '    user_ns = Instance(dict, args=None, allow_none=True)\n',
   '    def _user_ns_changed(self, name, old, new):\n',
   '        if self.shell is not None:\n',
   '            self.shell.user_ns = new\n',
   '            self.shell.init_user_ns()\n',
   '\n',
   "    # A reference to the Python builtin 'raw_input' function.\n",
   '    # (i.e., __builtin__.raw_input for Python 2.7, builtins.input for Python 3)\n',
   '    _sys_raw_input = Any()\n',
   '    _sys_eval_input = Any()\n',
   '\n',
   '    def __init__(self, **kwargs):\n',
   '        super(IPythonKernel, self).__init__(**kwargs)\n',
   '\n',
   '        # Initialize the InteractiveShell subclass\n',
   '        self.shell = self.shell_class.instance(parent=self,\n',
   '            profile_dir = self.profile_dir,\n',
   '            user_module = self.user_module,\n',
   '            user_ns     = self.user_ns,\n',
   '            kernel      = self,\n',
   '        )\n',
   '        self.shell.displayhook.session = self.session\n',
   '        self.shell.displayhook.pub_socket = self.iopub_socket\n',
   "        self.shell.displayhook.topic = self._topic('execute_result')\n",
   '        self.shell.display_pub.session = self.session\n',
   '        self.shell.display_pub.pub_socket = self.iopub_socket\n',
   '\n',
   '        # TMP - hack while developing\n',
   '        self.shell._reply_content = None\n',
   '\n',
   '        self.comm_manager = CommManager(shell=self.shell, parent=self,\n',
   '                                        kernel=self)\n',
   '\n',
   '        self.shell.configurables.append(self.comm_manager)\n',
   "        comm_msg_types = [ 'comm_open', 'comm_msg', 'comm_close' ]\n",
   '        for msg_type in comm_msg_types:\n',
   '            self.shell_handlers[msg_type] = getattr(self.comm_manager, msg_type)\n',
   '\n',
   '    help_links = List([\n',
   '        {\n',
   '            \'text\': "Python",\n',
   '            \'url\': "http://docs.python.org/%i.%i" % sys.version_info[:2],\n',
   '        },\n',
   '        {\n',
   '            \'text\': "IPython",\n',
   '            \'url\': "http://ipython.org/documentation.html",\n',
   '        },\n',
   '        {\n',
   '            \'text\': "NumPy",\n',
   '            \'url\': "http://docs.scipy.org/doc/numpy/reference/",\n',
   '        },\n',
   '        {\n',
   '            \'text\': "SciPy",\n',
   '            \'url\': "http://docs.scipy.org/doc/scipy/reference/",\n',
   '        },\n',
   '        {\n',
   '            \'text\': "Matplotlib",\n',
   '            \'url\': "http://matplotlib.org/contents.html",\n',
   '        },\n',
   '        {\n',
   '            \'text\': "SymPy",\n',
   '            \'url\': "http://docs.sympy.org/latest/index.html",\n',
   '        },\n',
   '        {\n',
   '            \'text\': "pandas",\n',
   '            \'url\': "http://pandas.pydata.org/pandas-docs/stable/",\n',
   '        },\n',
   '    ])\n',
   '\n',
   '    # Kernel info fields\n',
   "    implementation = 'ipython'\n",
   '    implementation_version = release.version\n',
   '    language_info = {\n',
   "                     'name': 'python',\n",
   "                     'version': sys.version.split()[0],\n",
   "                     'mimetype': 'text/x-python',\n",
   "                     'codemirror_mode': {'name': 'ipython',\n",
   "                                         'version': sys.version_info[0]},\n",
   "                     'pygments_lexer': 'ipython%d' % (3 if PY3 else 2),\n",
   "                     'nbconvert_exporter': 'python',\n",
   "                     'file_extension': '.py'\n",
   '                    }\n',
   '    @property\n',
   '    def banner(self):\n',
   '        return self.shell.banner\n',
   '\n',
   '    def start(self):\n',
   '        self.shell.exit_now = False\n',
   '        super(IPythonKernel, self).start()\n',
   '\n',
   '    def set_parent(self, ident, parent):\n',
   '        """Overridden from parent to tell the display hook and output streams\n',
   '        about the parent message.\n',
   '        """\n',
   '        super(IPythonKernel, self).set_parent(ident, parent)\n',
   '        self.shell.set_parent(parent)\n',
   '\n',
   '    def init_metadata(self, parent):\n',
   '        """Initialize metadata.\n',
   '        \n',
   '        Run at the beginning of each execution request.\n',
   '        """\n',
   '        md = super(IPythonKernel, self).init_metadata(parent)\n',
   '        # FIXME: remove deprecated ipyparallel-specific code\n',
   '        # This is required for ipyparallel < 5.0\n',
   '        md.update({\n',
   "            'dependencies_met' : True,\n",
   "            'engine' : self.ident,\n",
   '        })\n',
   '        return md\n',
   '    \n',
   '    def finish_metadata(self, parent, metadata, reply_content):\n',
   '        """Finish populating metadata.\n',
   '        \n',
   '        Run after completing an execution request.\n',
   '        """\n',
   '        # FIXME: remove deprecated ipyparallel-specific code\n',
   '        # This is required by ipyparallel < 5.0\n',
   "        metadata['status'] = reply_content['status']\n",
   "        if reply_content['status'] == 'error' and reply_content['ename'] == 'UnmetDependency':\n",
   "                metadata['dependencies_met'] = False\n",
   '\n',
   '        return metadata\n',
   '\n',
   '    def _forward_input(self, allow_stdin=False):\n',
   '        """Forward raw_input and getpass to the current frontend.\n',
   '\n',
   '        via input_request\n',
   '        """\n',
   '        self._allow_stdin = allow_stdin\n',
   '\n',
   '        if PY3:\n',
   '            self._sys_raw_input = builtin_mod.input\n',
   '            builtin_mod.input = self.raw_input\n',
   '        else:\n',
   '            self._sys_raw_input = builtin_mod.raw_input\n',
   '            self._sys_eval_input = builtin_mod.input\n',
   '            builtin_mod.raw_input = self.raw_input\n',
   "            builtin_mod.input = lambda prompt='': eval(self.raw_input(prompt))\n",
   '        self._save_getpass = getpass.getpass\n',
   '        getpass.getpass = self.getpass\n',
   '\n',
   '    def _restore_input(self):\n',
   '        """Restore raw_input, getpass"""\n',
   '        if PY3:\n',
   '            builtin_mod.input = self._sys_raw_input\n',
   '        else:\n',
   '            builtin_mod.raw_input = self._sys_raw_input\n',
   '            builtin_mod.input = self._sys_eval_input\n',
   '\n',
   '        getpass.getpass = self._save_getpass\n',
   '\n',
   '    @property\n',
   '    def execution_count(self):\n',
   '        return self.shell.execution_count\n',
   '\n',
   '    @execution_count.setter\n',
   '    def execution_count(self, value):\n',
   "        # Ignore the incrememnting done by KernelBase, in favour of our shell's\n",
   '        # execution counter.\n',
   '        pass\n',
   '\n',
   '    def do_execute(self, code, silent, store_history=True,\n',
   '                   user_expressions=None, allow_stdin=False):\n',
   "        shell = self.shell # we'll need this a lot here\n",
   '\n',
   '        self._forward_input(allow_stdin)\n',
   '\n',
   '        reply_content = {}\n',
   '        # FIXME: the shell calls the exception handler itself.\n',
   '        shell._reply_content = None\n',
   '        try:\n',
   '            shell.run_cell(code, store_history=store_history, silent=silent)\n',
   '        except:\n',
   "            status = u'error'\n",
   "            # FIXME: this code right now isn't being used yet by default,\n",
   '            # because the run_cell() call above directly fires off exception\n',
   '            # reporting.  This code, therefore, is only active in the scenario\n',
   '            # where runlines itself has an unhandled exception.  We need to\n',
   '            # uniformize this, for all exception construction to come from a\n',
   '            # single location in the codbase.\n',
   '            etype, evalue, tb = sys.exc_info()\n',
   '            tb_list = traceback.format_exception(etype, evalue, tb)\n',
   '            reply_content.update(shell._showtraceback(etype, evalue, tb_list))\n',
   '        else:\n',
   "            status = u'ok'\n",
   '        finally:\n',
   '            self._restore_input()\n',
   '\n',
   "        reply_content[u'status'] = status\n",
   '\n',
   '        # Return the execution counter so clients can display prompts\n',
   "        reply_content['execution_count'] = shell.execution_count - 1\n",
   '\n',
   '        # FIXME - fish exception info out of shell, possibly left there by\n',
   "        # runlines.  We'll need to clean up this logic later.\n",
   '        if shell._reply_content is not None:\n',
   '            reply_content.update(shell._reply_content)\n',
   '            # reset after use\n',
   '            shell._reply_content = None\n',
   '            # FIXME: deprecate piece for ipyparallel:\n',
   "            e_info = dict(engine_uuid=self.ident, engine_id=self.int_id, method='execute')\n",
   "            reply_content['engine_info'] = e_info\n",
   '\n',
   "        if 'traceback' in reply_content:\n",
   '            self.log.info("Exception in execute request:\\n%s", \'\\n\'.join(reply_content[\'traceback\']))\n',
   '\n',
   '\n',
   '        # At this point, we can tell whether the main code execution succeeded\n',
   '        # or not.  If it did, we proceed to evaluate user_expressions\n',
   "        if reply_content['status'] == 'ok':\n",
   "            reply_content[u'user_expressions'] = \\\n",
   '                         shell.user_expressions(user_expressions or {})\n',
   '        else:\n',
   "            # If there was an error, don't even try to compute expressions\n",
   "            reply_content[u'user_expressions'] = {}\n",
   '\n',
   '        # Payloads should be retrieved regardless of outcome, so we can both\n',
   '        # recover partial output (that could have been generated early in a\n',
   '        # block, before an error) and clear the payload system always.\n',
   "        reply_content[u'payload'] = shell.payload_manager.read_payload()\n",
   "        # Be agressive about clearing the payload because we don't want\n",
   '        # it to sit in memory until the next execute_request comes in.\n',
   '        shell.payload_manager.clear_payload()\n',
   '\n',
   '        return reply_content\n',
   '\n',
   '    def do_complete(self, code, cursor_pos):\n',
   '        # FIXME: IPython completers currently assume single line,\n',
   '        # but completion messages give multi-line context\n',
   '        # For now, extract line from cell, based on cursor_pos:\n',
   '        if cursor_pos is None:\n',
   '            cursor_pos = len(code)\n',
   '        line, offset = line_at_cursor(code, cursor_pos)\n',
   '        line_cursor = cursor_pos - offset\n',
   '\n',
   "        txt, matches = self.shell.complete('', line, line_cursor)\n",
   "        return {'matches' : matches,\n",
   "                'cursor_end' : cursor_pos,\n",
   "                'cursor_start' : cursor_pos - len(txt),\n",
   "                'metadata' : {},\n",
   "                'status' : 'ok'}\n",
   '\n',
   '    def do_inspect(self, code, cursor_pos, detail_level=0):\n',
   '        name = token_at_cursor(code, cursor_pos)\n',
   '        info = self.shell.object_inspect(name)\n',
   '\n',
   "        reply_content = {'status' : 'ok'}\n",
   "        reply_content['data'] = data = {}\n",
   "        reply_content['metadata'] = {}\n",
   "        reply_content['found'] = info['found']\n",
   "        if info['found']:\n",
   '            info_text = self.shell.object_inspect_text(\n',
   '                name,\n',
   '                detail_level=detail_level,\n',
   '            )\n',
   "            data['text/plain'] = info_text\n",
   '\n',
   '        return reply_content\n',
   '\n',
   '    def do_history(self, hist_access_type, output, raw, session=None, start=None,\n',
   '                   stop=None, n=None, pattern=None, unique=False):\n',
   "        if hist_access_type == 'tail':\n",
   '            hist = self.shell.history_manager.get_tail(n, raw=raw, output=output,\n',
   '                                                            include_latest=True)\n',
   '\n',
   "        elif hist_access_type == 'range':\n",
   '            hist = self.shell.history_manager.get_range(session, start, stop,\n',
   '                                                        raw=raw, output=output)\n',
   '\n',
   "        elif hist_access_type == 'search':\n",
   '            hist = self.shell.history_manager.search(\n',
   '                pattern, raw=raw, output=output, n=n, unique=unique)\n',
   '        else:\n',
   '            hist = []\n',
   '\n',
   "        return {'history' : list(hist)}\n",
   '\n',
   '    def do_shutdown(self, restart):\n',
   '        self.shell.exit_now = True\n',
   "        return dict(status='ok', restart=restart)\n",
   '\n',
   '    def do_is_complete(self, code):\n',
   '        status, indent_spaces = self.shell.input_transformer_manager.check_complete(code)\n',
   "        r = {'status': status}\n",
   "        if status == 'incomplete':\n",
   "            r['indent'] = ' ' * indent_spaces\n",
   '        return r\n',
   '\n',
   '    def do_apply(self, content, bufs, msg_id, reply_metadata):\n',
   '        from .serialize import serialize_object, unpack_apply_message\n',
   '        shell = self.shell\n',
   '        try:\n',
   '            working = shell.user_ns\n',
   '\n',
   '            prefix = "_"+str(msg_id).replace("-","")+"_"\n',
   '\n',
   '            f,args,kwargs = unpack_apply_message(bufs, working, copy=False)\n',
   '\n',
   "            fname = getattr(f, '__name__', 'f')\n",
   '\n',
   '            fname = prefix+"f"\n',
   '            argname = prefix+"args"\n',
   '            kwargname = prefix+"kwargs"\n',
   '            resultname = prefix+"result"\n',
   '\n',
   '            ns = { fname : f, argname : args, kwargname : kwargs , resultname : None }\n',
   '            # print ns\n',
   '            working.update(ns)\n',
   '            code = "%s = %s(*%s,**%s)" % (resultname, fname, argname, kwargname)\n',
   '            try:\n',
   '                exec(code, shell.user_global_ns, shell.user_ns)\n',
   '                result = working.get(resultname)\n',
   '            finally:\n',
   '                for key in ns:\n',
   '                    working.pop(key)\n',
   '\n',
   '            result_buf = serialize_object(result,\n',
   '                buffer_threshold=self.session.buffer_threshold,\n',
   '                item_threshold=self.session.item_threshold,\n',
   '            )\n',
   '\n',
   '        except:\n',
   '            # invoke IPython traceback formatting\n',
   '            shell.showtraceback()\n',
   '            # FIXME - fish exception info out of shell, possibly left there by\n',
   "            # run_code.  We'll need to clean up this logic later.\n",
   '            reply_content = {}\n',
   '            if shell._reply_content is not None:\n',
   '                reply_content.update(shell._reply_content)\n',
   '                # reset after use\n',
   '                shell._reply_content = None\n',
   '                \n',
   '                # FIXME: deprecate piece for ipyparallel:\n',
   "                e_info = dict(engine_uuid=self.ident, engine_id=self.int_id, method='apply')\n",
   "                reply_content['engine_info'] = e_info\n",
   '\n',
   "            self.send_response(self.iopub_socket, u'error', reply_content,\n",
   "                                ident=self._topic('error'))\n",
   '            self.log.info("Exception in apply request:\\n%s", \'\\n\'.join(reply_content[\'traceback\']))\n',
   '            result_buf = []\n',
   '        else:\n',
   "            reply_content = {'status' : 'ok'}\n",
   '\n',
   '        return reply_content, result_buf\n',
   '\n',
   '    def do_clear(self):\n',
   '        self.shell.reset(False)\n',
   "        return dict(status='ok')\n",
   '\n',
   '\n',
   '# This exists only for backwards compatibility - use IPythonKernel instead\n',
   '\n',
   'class Kernel(IPythonKernel):\n',
   '    def __init__(self, *args, **kwargs):\n',
   '        import warnings\n',
   "        warnings.warn('Kernel is a deprecated alias of ipykernel.ipkernel.IPythonKernel',\n",
   '                      DeprecationWarning)\n',
   '        super(Kernel, self).__init__(*args, **kwargs)\n'],
  '/home/pasha/.local/lib/python3.4/site-packages/ipykernel/ipkernel.py'),
 {'apply_request': <bound method IPythonKernel.apply_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
  'comm_close': <bound method CommManager.comm_close of <ipykernel.comm.manager.CommManager object at 0x7f51c0147940>>,
  'comm_info_request': <bound method IPythonKernel.comm_info_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
  'comm_msg': <bound method CommManager.comm_msg of <ipykernel.comm.manager.CommManager object at 0x7f51c0147940>>,
  'comm_open': <bound method CommManager.comm_open of <ipykernel.comm.manager.CommManager object at 0x7f51c0147940>>,
  'complete_request': <bound method IPythonKernel.complete_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
  'connect_request': <bound method IPythonKernel.connect_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
  'execute_request': <bound method IPythonKernel.execute_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
  'history_request': <bound method IPythonKernel.history_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
  'inspect_request': <bound method IPythonKernel.inspect_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
  'is_complete_request': <bound method IPythonKernel.is_complete_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
  'kernel_info_request': <bound method IPythonKernel.kernel_info_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
  'shutdown_request': <bound method IPythonKernel.shutdown_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>},
 <bound method IPythonKernel.complete_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
 <bound method IPythonKernel.inspect_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
 <bound method IPythonKernel.history_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
 <bound method IPythonKernel.comm_info_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
 <bound method IPythonKernel.kernel_info_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
 <bound method IPythonKernel.connect_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
 <bound method IPythonKernel.shutdown_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
 <bound method IPythonKernel.is_complete_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
 <bound method IPythonKernel.apply_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
 {'abort_request': <bound method IPythonKernel.abort_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
  'apply_request': <bound method IPythonKernel.apply_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
  'clear_request': <bound method IPythonKernel.clear_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
  'comm_info_request': <bound method IPythonKernel.comm_info_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
  'complete_request': <bound method IPythonKernel.complete_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
  'connect_request': <bound method IPythonKernel.connect_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
  'execute_request': <bound method IPythonKernel.execute_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
  'history_request': <bound method IPythonKernel.history_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
  'inspect_request': <bound method IPythonKernel.inspect_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
  'is_complete_request': <bound method IPythonKernel.is_complete_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
  'kernel_info_request': <bound method IPythonKernel.kernel_info_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
  'shutdown_request': <bound method IPythonKernel.shutdown_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>},
 <bound method IPythonKernel.complete_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
 <bound method IPythonKernel.inspect_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
 <bound method IPythonKernel.history_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
 <bound method IPythonKernel.comm_info_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
 <bound method IPythonKernel.kernel_info_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
 <bound method IPythonKernel.connect_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
 <bound method IPythonKernel.shutdown_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
 <bound method IPythonKernel.is_complete_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
 <bound method IPythonKernel.apply_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
 <bound method IPythonKernel.clear_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
 <bound method IPythonKernel.abort_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
 <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>,
 {'Completer': <IPython.core.completer.IPCompleter at 0x7f51c0186080>,
  'CustomTB': <bound method ZMQInteractiveShell.dummy_handler of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>,
  'InteractiveTB': <IPython.core.ultratb.AutoFormattedTB at 0x7f51c01130b8>,
  'SyntaxTB': <IPython.core.ultratb.SyntaxTB at 0x7f51c721ae48>,
  '_call_pdb': False,
  '_cross_validation_lock': False,
  '_last_input_line': 'gc.get_objects()',
  '_main_mod_cache': {},
  '_orig_sys_module_state': {'excepthook': <bound method IPKernelApp.excepthook of <ipykernel.kernelapp.IPKernelApp object at 0x7f51d2a1ac18>>,
   'stderr': <ipykernel.iostream.OutStream at 0x7f51c1221b38>,
   'stdin': <_io.TextIOWrapper name='<stdin>' mode='r' encoding='UTF-8'>,
   'stdout': <ipykernel.iostream.OutStream at 0x7f51c1221b70>},
  '_orig_sys_modules_main_mod': <module 'ipykernel.__main__' from '/home/pasha/.local/lib/python3.4/site-packages/ipykernel/__main__.py'>,
  '_orig_sys_modules_main_name': '__main__',
  '_reply_content': None,
  '_showtraceback': <bound method ZMQInteractiveShell._showtraceback of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>,
  '_trait_notifiers': {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]},
   'ipython_dir': {'change': [<traitlets.traitlets._CallbackWrapper at 0x7f51c01478d0>]}},
  '_trait_validators': {},
  '_trait_values': {'_post_execute': {},
   'alias_manager': <IPython.core.alias.AliasManager at 0x7f51c01137b8>,
   'ast_node_interactivity': 'last_expr',
   'ast_transformers': [],
   'autocall': 0,
   'autoindent': False,
   'automagic': True,
   'banner1': 'Python 3.4.3 (default, Jun 29 2015, 12:16:01) \nType "copyright", "credits" or "license" for more information.\n\nIPython 4.1.2 -- An enhanced Interactive Python.\n?         -> Introduction and overview of IPython\'s features.\n%quickref -> Quick reference.\nhelp      -> Python\'s own help system.\nobject?   -> Details about \'object\', use \'object??\' for extra details.\n',
   'banner2': '',
   'builtin_trap': <IPython.core.builtin_trap.BuiltinTrap at 0x7f51c016eef0>,
   'cache_size': 1000,
   'color_info': True,
   'colors': 'Linux',
   'colors_force': True,
   'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
   'data_pub_class': ipykernel.datapub.ZMQDataPublisher,
   'debug': False,
   'deep_reload': False,
   'disable_failing_post_execute': False,
   'display_formatter': <IPython.core.formatters.DisplayFormatter at 0x7f51c0113400>,
   'display_page': False,
   'display_pub_class': ipykernel.zmqshell.ZMQDisplayPublisher,
   'display_trap': <IPython.core.display_trap.DisplayTrap at 0x7f51c0113320>,
   'displayhook_class': ipykernel.displayhook.ZMQShellDisplayHook,
   'execution_count': 21,
   'exit_now': False,
   'exiter': <IPython.core.autocall.ZMQExitAutocall at 0x7f51c016ef98>,
   'extension_manager': <IPython.core.extensions.ExtensionManager at 0x7f51c0113eb8>,
   'filename': '<ipython console>',
   'history_length': 10000,
   'history_load_length': 1000,
   'history_manager': <IPython.core.history.HistoryManager at 0x7f51c1221710>,
   'input_transformer_manager': <IPython.core.inputsplitter.IPythonInputSplitter at 0x7f51c00d4be0>,
   'ipython_dir': '/home/pasha/.ipython',
   'kernel': <ipykernel.ipkernel.IPythonKernel at 0x7f51c1221278>,
   'logappend': '',
   'logfile': '',
   'logstart': False,
   'magics_manager': <IPython.core.magic.MagicsManager at 0x7f51c0113470>,
   'multiline_history': True,
   'object_info_string_level': 0,
   'parent': <ipykernel.ipkernel.IPythonKernel at 0x7f51c1221278>,
   'parent_header': {'buffers': [],
    'content': {'allow_stdin': True,
     'code': 'gc.get_objects()',
     'silent': False,
     'stop_on_error': True,
     'store_history': True,
     'user_expressions': {}},
    'header': {'date': '2016-03-20T19:46:05.318327',
     'msg_id': 'BF3CEE6EC01944EEA25FA7825F7AD98A',
     'msg_type': 'execute_request',
     'session': '4CE6797D9E26478A800FA96DD84CCB50',
     'username': 'username',
     'version': '5.0'},
    'metadata': {},
    'msg_id': 'BF3CEE6EC01944EEA25FA7825F7AD98A',
    'msg_type': 'execute_request',
    'parent_header': {}},
   'payload_manager': <IPython.core.payload.PayloadManager at 0x7f51c01476a0>,
   'pdb': False,
   'prefilter_manager': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
   'profile_dir': <IPython.core.profiledir.ProfileDir at 0x7f51c1221518>,
   'prompt_in1': 'In [\\#]: ',
   'prompt_in2': '   .\\D.: ',
   'prompt_out': 'Out[\\#]: ',
   'prompts_pad_left': True,
   'quiet': False,
   'readline_delims': '',
   'readline_remove_delims': '-/~',
   'readline_use': False,
   'separate_in': '\n',
   'separate_out': '',
   'separate_out2': '',
   'show_rewritten_input': True,
   'wildcards_case_sensitive': True,
   'xmode': 'Context'},
  'compile': <IPython.core.compilerop.CachingCompiler at 0x7f51c124b748>,
  'configurables': [<ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>,
   <IPython.core.history.HistoryManager at 0x7f51c1221710>,
   <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
   <IPython.core.completer.IPCompleter at 0x7f51c0186080>,
   <IPython.core.prompts.PromptManager at 0x7f51c01131d0>,
   <IPython.core.formatters.DisplayFormatter at 0x7f51c0113400>,
   <ipykernel.zmqshell.ZMQDisplayPublisher at 0x7f51c0113438>,
   <ipykernel.displayhook.ZMQShellDisplayHook at 0x7f51c0113278>,
   <IPython.core.magics.UserMagics at 0x7f51c01134a8>,
   <IPython.core.magic.MagicsManager at 0x7f51c0113470>,
   <IPython.core.magics.auto.AutoMagics at 0x7f51c0113a90>,
   <IPython.core.magics.basic.BasicMagics at 0x7f51c0113b00>,
   <IPython.core.magics.code.CodeMagics at 0x7f51c0113b38>,
   <IPython.core.magics.config.ConfigMagics at 0x7f51c0113b70>,
   <IPython.core.magics.deprecated.DeprecatedMagics at 0x7f51c0113ba8>,
   <IPython.core.magics.display.DisplayMagics at 0x7f51c0113be0>,
   <IPython.core.magics.execution.ExecutionMagics at 0x7f51c0113c18>,
   <IPython.core.magics.extension.ExtensionMagics at 0x7f51c0113c50>,
   <IPython.core.magics.history.HistoryMagics at 0x7f51c0113c88>,
   <IPython.core.magics.logging.LoggingMagics at 0x7f51c0113cc0>,
   <IPython.core.magics.namespace.NamespaceMagics at 0x7f51c0113cf8>,
   <IPython.core.magics.osm.OSMagics at 0x7f51c0113d30>,
   <IPython.core.magics.pylab.PylabMagics at 0x7f51c0113d68>,
   <IPython.core.magics.script.ScriptMagics at 0x7f51c0113da0>,
   <ipykernel.zmqshell.KernelMagics at 0x7f51c013b358>,
   <IPython.core.alias.AliasManager at 0x7f51c01137b8>,
   <IPython.core.extensions.ExtensionManager at 0x7f51c0113eb8>,
   <IPython.core.payload.PayloadManager at 0x7f51c01476a0>,
   <ipykernel.comm.manager.CommManager at 0x7f51c0147940>,
   <ipykernel.kernelapp.IPKernelApp at 0x7f51d2a1ac18>,
   <storemagic.StoreMagics at 0x7f51c01477b8>,
   <storemagic.StoreMagics at 0x7f51c01477b8>],
  'custom_exceptions': (),
  'db': PickleShareDB('/home/pasha/.ipython/profile_default/db'),
  'define_magic': <bound method MagicsManager.define_magic of <IPython.core.magic.MagicsManager object at 0x7f51c0113470>>,
  'dir_stack': [],
  'display_pub': <ipykernel.zmqshell.ZMQDisplayPublisher at 0x7f51c0113438>,
  'displayhook': <ipykernel.displayhook.ZMQShellDisplayHook at 0x7f51c0113278>,
  'events': <IPython.core.events.EventManager at 0x7f51c016ecc0>,
  'has_readline': False,
  'home_dir': '/home/pasha',
  'hooks': {'clipboard_get': <IPython.core.hooks.CommandChainDispatcher at 0x7f51c016eeb8>,
   'editor': <IPython.core.hooks.CommandChainDispatcher at 0x7f51c016ecf8>,
   'fix_error_editor': <IPython.core.hooks.CommandChainDispatcher at 0x7f51c016ed30>,
   'late_startup_hook': <IPython.core.hooks.CommandChainDispatcher at 0x7f51c016edd8>,
   'pre_prompt_hook': <IPython.core.hooks.CommandChainDispatcher at 0x7f51c016ee48>,
   'pre_run_code_hook': <IPython.core.hooks.CommandChainDispatcher at 0x7f51c016ee80>,
   'show_in_pager': <IPython.core.hooks.CommandChainDispatcher at 0x7f51c016ee10>,
   'shutdown_hook': <IPython.core.hooks.CommandChainDispatcher at 0x7f51c016eda0>,
   'synchronize_with_editor': <IPython.core.hooks.CommandChainDispatcher at 0x7f51c016ed68>},
  'indent_current_nsp': 0,
  'inspector': <IPython.core.oinspect.Inspector at 0x7f51c016ef60>,
  'logger': <IPython.core.logger.Logger at 0x7f51c016ef28>,
  'meta': {},
  'more': False,
  'ns_table': {'builtin': {'ArithmeticError': ArithmeticError,
    'AssertionError': AssertionError,
    'AttributeError': AttributeError,
    'BaseException': BaseException,
    'BlockingIOError': BlockingIOError,
    'BrokenPipeError': BrokenPipeError,
    'BufferError': BufferError,
    'BytesWarning': BytesWarning,
    'ChildProcessError': ChildProcessError,
    'ConnectionAbortedError': ConnectionAbortedError,
    'ConnectionError': ConnectionError,
    'ConnectionRefusedError': ConnectionRefusedError,
    'ConnectionResetError': ConnectionResetError,
    'DeprecationWarning': DeprecationWarning,
    'EOFError': EOFError,
    'Ellipsis': Ellipsis,
    'EnvironmentError': OSError,
    'Exception': Exception,
    'False': False,
    'FileExistsError': FileExistsError,
    'FileNotFoundError': FileNotFoundError,
    'FloatingPointError': FloatingPointError,
    'FutureWarning': FutureWarning,
    'GeneratorExit': GeneratorExit,
    'IOError': OSError,
    'ImportError': ImportError,
    'ImportWarning': ImportWarning,
    'IndentationError': IndentationError,
    'IndexError': IndexError,
    'InterruptedError': InterruptedError,
    'IsADirectoryError': IsADirectoryError,
    'KeyError': KeyError,
    'KeyboardInterrupt': KeyboardInterrupt,
    'LookupError': LookupError,
    'MemoryError': MemoryError,
    'NameError': NameError,
    'None': None,
    'NotADirectoryError': NotADirectoryError,
    'NotImplemented': NotImplemented,
    'NotImplementedError': NotImplementedError,
    'OSError': OSError,
    'OverflowError': OverflowError,
    'PendingDeprecationWarning': PendingDeprecationWarning,
    'PermissionError': PermissionError,
    'ProcessLookupError': ProcessLookupError,
    'ReferenceError': ReferenceError,
    'ResourceWarning': ResourceWarning,
    'RuntimeError': RuntimeError,
    'RuntimeWarning': RuntimeWarning,
    'StopIteration': StopIteration,
    'SyntaxError': SyntaxError,
    'SyntaxWarning': SyntaxWarning,
    'SystemError': SystemError,
    'SystemExit': SystemExit,
    'TabError': TabError,
    'TimeoutError': TimeoutError,
    'True': True,
    'TypeError': TypeError,
    'UnboundLocalError': UnboundLocalError,
    'UnicodeDecodeError': UnicodeDecodeError,
    'UnicodeEncodeError': UnicodeEncodeError,
    'UnicodeError': UnicodeError,
    'UnicodeTranslateError': UnicodeTranslateError,
    'UnicodeWarning': UnicodeWarning,
    'UserWarning': UserWarning,
    'ValueError': ValueError,
    'Warning': Warning,
    'ZeroDivisionError': ZeroDivisionError,
    '__IPYTHON__': True,
    '__IPYTHON__active': 'Deprecated, check for __IPYTHON__',
    '__build_class__': <function __build_class__>,
    '__debug__': True,
    '__doc__': "Built-in functions, exceptions, and other objects.\n\nNoteworthy: None is the `nil' object; Ellipsis represents `...' in slices.",
    '__import__': <function __import__>,
    '__loader__': _frozen_importlib.BuiltinImporter,
    '__name__': 'builtins',
    '__package__': '',
    '__spec__': ModuleSpec(name='builtins', loader=<class '_frozen_importlib.BuiltinImporter'>),
    'abs': <function abs>,
    'all': <function all>,
    'any': <function any>,
    'ascii': <function ascii>,
    'bin': <function bin>,
    'bool': bool,
    'bytearray': bytearray,
    'bytes': bytes,
    'callable': <function callable>,
    'chr': <function chr>,
    'classmethod': classmethod,
    'compile': <function compile>,
    'complex': complex,
    'copyright': Copyright (c) 2001-2015 Python Software Foundation.
    All Rights Reserved.
    
    Copyright (c) 2000 BeOpen.com.
    All Rights Reserved.
    
    Copyright (c) 1995-2001 Corporation for National Research Initiatives.
    All Rights Reserved.
    
    Copyright (c) 1991-1995 Stichting Mathematisch Centrum, Amsterdam.
    All Rights Reserved.,
    'credits':     Thanks to CWI, CNRI, BeOpen.com, Zope Corporation and a cast of thousands
        for supporting Python development.  See www.python.org for more information.,
    'delattr': <function delattr>,
    'dict': dict,
    'dir': <function dir>,
    'divmod': <function divmod>,
    'dreload': <function IPython.lib.deepreload._dreload>,
    'enumerate': enumerate,
    'eval': <function eval>,
    'exec': <function exec>,
    'filter': filter,
    'float': float,
    'format': <function format>,
    'frozenset': frozenset,
    'get_ipython': <bound method ZMQInteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>,
    'getattr': <function getattr>,
    'globals': <function globals>,
    'hasattr': <function hasattr>,
    'hash': <function hash>,
    'help': Type help() for interactive help, or help(object) for help about object.,
    'hex': <function hex>,
    'id': <function id>,
    'input': <bound method IPythonKernel.raw_input of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
    'int': int,
    'isinstance': <function isinstance>,
    'issubclass': <function issubclass>,
    'iter': <function iter>,
    'len': <function len>,
    'license': See https://www.python.org/psf/license/,
    'list': list,
    'locals': <function locals>,
    'map': map,
    'max': <function max>,
    'memoryview': memoryview,
    'min': <function min>,
    'next': <function next>,
    'object': object,
    'oct': <function oct>,
    'open': <function io.open>,
    'ord': <function ord>,
    'pow': <function pow>,
    'print': <function print>,
    'property': property,
    'range': range,
    'repr': <function repr>,
    'reversed': reversed,
    'round': <function round>,
    'set': set,
    'setattr': <function setattr>,
    'slice': slice,
    'sorted': <function sorted>,
    'staticmethod': staticmethod,
    'str': str,
    'sum': <function sum>,
    'super': super,
    'tuple': tuple,
    'type': type,
    'vars': <function vars>,
    'zip': zip},
   'user_global': {'In': ['',
     'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
     'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
     'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
     "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
     "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
     "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
     "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
     "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
     "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
     "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
     "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
     'def pick(l: list, index: int) -> int:\n    return l[index]',
     'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
     'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
     'pick([1, 2, 3], 2)',
     "pick([1, 2, 3], '2')",
     'import gc',
     'import gc\nпс',
     'import gc\ngc',
     'import gc\ngc.garbage',
     'gc.get_objects()'],
    'Out': {14: 3, 15: 3, 19: <module 'gc' (built-in)>, 20: []},
    '_': [],
    '_14': 3,
    '_15': 3,
    '_19': <module 'gc' (built-in)>,
    '_20': [],
    '__': <module 'gc' (built-in)>,
    '___': 3,
    '__builtin__': <module 'builtins' (built-in)>,
    '__builtins__': <module 'builtins' (built-in)>,
    '__doc__': 'Automatically created module for IPython interactive environment',
    '__loader__': None,
    '__name__': '__main__',
    '__package__': None,
    '__spec__': None,
    '_dh': ['/home/pasha/machine-learning.coursera/LearnInProgress/final.assignment/Kaggle'],
    '_i': 'import gc\ngc.garbage',
    '_i1': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
    '_i10': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    '_i11': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    '_i12': 'def pick(l: list, index: int) -> int:\n    return l[index]',
    '_i13': 'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
    '_i14': 'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
    '_i15': 'pick([1, 2, 3], 2)',
    '_i16': "pick([1, 2, 3], '2')",
    '_i17': 'import gc',
    '_i18': 'import gc\nпс',
    '_i19': 'import gc\ngc',
    '_i2': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
    '_i20': 'import gc\ngc.garbage',
    '_i21': 'gc.get_objects()',
    '_i3': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
    '_i4': "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    '_i5': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    '_i6': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    '_i7': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    '_i8': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    '_i9': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    '_ih': ['',
     'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
     'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
     'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
     "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
     "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
     "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
     "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
     "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
     "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
     "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
     "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
     'def pick(l: list, index: int) -> int:\n    return l[index]',
     'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
     'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
     'pick([1, 2, 3], 2)',
     "pick([1, 2, 3], '2')",
     'import gc',
     'import gc\nпс',
     'import gc\ngc',
     'import gc\ngc.garbage',
     'gc.get_objects()'],
    '_ii': 'import gc\ngc',
    '_iii': 'import gc\nпс',
    '_oh': {14: 3, 15: 3, 19: <module 'gc' (built-in)>, 20: []},
    '_sh': <module 'IPython.core.shadowns' from '/home/pasha/.local/lib/python3.4/site-packages/IPython/core/shadowns.py'>,
    'exit': <IPython.core.autocall.ZMQExitAutocall at 0x7f51c016ef98>,
    'gc': <module 'gc' (built-in)>,
    'get_ipython': <bound method ZMQInteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>,
    'pick': <function __main__.pick>,
    'quit': <IPython.core.autocall.ZMQExitAutocall at 0x7f51c016ef98>,
    'v': 3,
    'x': {1: False, 3: True}},
   'user_local': {'In': ['',
     'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
     'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
     'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
     "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
     "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
     "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
     "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
     "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
     "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
     "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
     "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
     'def pick(l: list, index: int) -> int:\n    return l[index]',
     'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
     'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
     'pick([1, 2, 3], 2)',
     "pick([1, 2, 3], '2')",
     'import gc',
     'import gc\nпс',
     'import gc\ngc',
     'import gc\ngc.garbage',
     'gc.get_objects()'],
    'Out': {14: 3, 15: 3, 19: <module 'gc' (built-in)>, 20: []},
    '_': [],
    '_14': 3,
    '_15': 3,
    '_19': <module 'gc' (built-in)>,
    '_20': [],
    '__': <module 'gc' (built-in)>,
    '___': 3,
    '__builtin__': <module 'builtins' (built-in)>,
    '__builtins__': <module 'builtins' (built-in)>,
    '__doc__': 'Automatically created module for IPython interactive environment',
    '__loader__': None,
    '__name__': '__main__',
    '__package__': None,
    '__spec__': None,
    '_dh': ['/home/pasha/machine-learning.coursera/LearnInProgress/final.assignment/Kaggle'],
    '_i': 'import gc\ngc.garbage',
    '_i1': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
    '_i10': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    '_i11': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    '_i12': 'def pick(l: list, index: int) -> int:\n    return l[index]',
    '_i13': 'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
    '_i14': 'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
    '_i15': 'pick([1, 2, 3], 2)',
    '_i16': "pick([1, 2, 3], '2')",
    '_i17': 'import gc',
    '_i18': 'import gc\nпс',
    '_i19': 'import gc\ngc',
    '_i2': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
    '_i20': 'import gc\ngc.garbage',
    '_i21': 'gc.get_objects()',
    '_i3': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
    '_i4': "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    '_i5': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    '_i6': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    '_i7': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    '_i8': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    '_i9': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    '_ih': ['',
     'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
     'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
     'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
     "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
     "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
     "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
     "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
     "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
     "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
     "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
     "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
     'def pick(l: list, index: int) -> int:\n    return l[index]',
     'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
     'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
     'pick([1, 2, 3], 2)',
     "pick([1, 2, 3], '2')",
     'import gc',
     'import gc\nпс',
     'import gc\ngc',
     'import gc\ngc.garbage',
     'gc.get_objects()'],
    '_ii': 'import gc\ngc',
    '_iii': 'import gc\nпс',
    '_oh': {14: 3, 15: 3, 19: <module 'gc' (built-in)>, 20: []},
    '_sh': <module 'IPython.core.shadowns' from '/home/pasha/.local/lib/python3.4/site-packages/IPython/core/shadowns.py'>,
    'exit': <IPython.core.autocall.ZMQExitAutocall at 0x7f51c016ef98>,
    'gc': <module 'gc' (built-in)>,
    'get_ipython': <bound method ZMQInteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>,
    'pick': <function __main__.pick>,
    'quit': <IPython.core.autocall.ZMQExitAutocall at 0x7f51c016ef98>,
    'v': 3,
    'x': {1: False, 3: True}}},
  'prefilter': <bound method PrefilterManager.prefilter_lines of <IPython.core.prefilter.PrefilterManager object at 0x7f51c016e908>>,
  'prompt_manager': <IPython.core.prompts.PromptManager at 0x7f51c01131d0>,
  'pycolorize': <function IPython.core.interactiveshell.InteractiveShell.init_syntax_highlighting.<locals>.<lambda>>,
  'raw_input_original': <function input>,
  'readline': None,
  'readline_no_record': <IPython.utils.contexts.NoOpContext at 0x7f51c0186048>,
  'register_magics': <bound method MagicsManager.register of <IPython.core.magic.MagicsManager object at 0x7f51c0113470>>,
  'set_custom_completer': <function IPython.core.interactiveshell.no_op>,
  'set_readline_completer': <function IPython.core.interactiveshell.no_op>,
  'starting_dir': '/home/pasha/machine-learning.coursera/LearnInProgress/final.assignment/Kaggle',
  'stdin_encoding': 'UTF-8',
  'strdispatchers': {'complete_command': <Strdispatch {'%run': <IPython.core.hooks.CommandChainDispatcher object at 0x7f51c0186fd0>, 'from': <IPython.core.hooks.CommandChainDispatcher object at 0x7f51c0186e80>, '%reset': <IPython.core.hooks.CommandChainDispatcher object at 0x7f51c01863c8>, '%aimport': <IPython.core.hooks.CommandChainDispatcher object at 0x7f51c0186f28>, 'import': <IPython.core.hooks.CommandChainDispatcher object at 0x7f51c0186e48>, '%cd': <IPython.core.hooks.CommandChainDispatcher object at 0x7f51c0186358>}, {}>},
  'sys_excepthook': <bound method IPKernelApp.excepthook of <ipykernel.kernelapp.IPKernelApp object at 0x7f51d2a1ac18>>,
  'tempdirs': [],
  'tempfiles': [],
  'user_module': <module '__main__'>,
  'user_ns': {'In': ['',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
    "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    'def pick(l: list, index: int) -> int:\n    return l[index]',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
    'pick([1, 2, 3], 2)',
    "pick([1, 2, 3], '2')",
    'import gc',
    'import gc\nпс',
    'import gc\ngc',
    'import gc\ngc.garbage',
    'gc.get_objects()'],
   'Out': {14: 3, 15: 3, 19: <module 'gc' (built-in)>, 20: []},
   '_': [],
   '_14': 3,
   '_15': 3,
   '_19': <module 'gc' (built-in)>,
   '_20': [],
   '__': <module 'gc' (built-in)>,
   '___': 3,
   '__builtin__': <module 'builtins' (built-in)>,
   '__builtins__': <module 'builtins' (built-in)>,
   '__doc__': 'Automatically created module for IPython interactive environment',
   '__loader__': None,
   '__name__': '__main__',
   '__package__': None,
   '__spec__': None,
   '_dh': ['/home/pasha/machine-learning.coursera/LearnInProgress/final.assignment/Kaggle'],
   '_i': 'import gc\ngc.garbage',
   '_i1': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
   '_i10': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_i11': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   '_i12': 'def pick(l: list, index: int) -> int:\n    return l[index]',
   '_i13': 'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
   '_i14': 'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
   '_i15': 'pick([1, 2, 3], 2)',
   '_i16': "pick([1, 2, 3], '2')",
   '_i17': 'import gc',
   '_i18': 'import gc\nпс',
   '_i19': 'import gc\ngc',
   '_i2': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
   '_i20': 'import gc\ngc.garbage',
   '_i21': 'gc.get_objects()',
   '_i3': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
   '_i4': "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   '_i5': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   '_i6': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_i7': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_i8': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_i9': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_ih': ['',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
    "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    'def pick(l: list, index: int) -> int:\n    return l[index]',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
    'pick([1, 2, 3], 2)',
    "pick([1, 2, 3], '2')",
    'import gc',
    'import gc\nпс',
    'import gc\ngc',
    'import gc\ngc.garbage',
    'gc.get_objects()'],
   '_ii': 'import gc\ngc',
   '_iii': 'import gc\nпс',
   '_oh': {14: 3, 15: 3, 19: <module 'gc' (built-in)>, 20: []},
   '_sh': <module 'IPython.core.shadowns' from '/home/pasha/.local/lib/python3.4/site-packages/IPython/core/shadowns.py'>,
   'exit': <IPython.core.autocall.ZMQExitAutocall at 0x7f51c016ef98>,
   'gc': <module 'gc' (built-in)>,
   'get_ipython': <bound method ZMQInteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>,
   'pick': <function __main__.pick>,
   'quit': <IPython.core.autocall.ZMQExitAutocall at 0x7f51c016ef98>,
   'v': 3,
   'x': {1: False, 3: True}},
  'user_ns_hidden': {'In': ['',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
    "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    'def pick(l: list, index: int) -> int:\n    return l[index]',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
    'pick([1, 2, 3], 2)',
    "pick([1, 2, 3], '2')",
    'import gc',
    'import gc\nпс',
    'import gc\ngc',
    'import gc\ngc.garbage',
    'gc.get_objects()'],
   'Out': {14: 3, 15: 3, 19: <module 'gc' (built-in)>, 20: []},
   '_': [],
   '_14': 3,
   '_15': 3,
   '_19': <module 'gc' (built-in)>,
   '_20': [],
   '__': <module 'gc' (built-in)>,
   '___': 3,
   '__builtin__': <module 'builtins' (built-in)>,
   '__builtins__': <module 'builtins' (built-in)>,
   '__doc__': 'Automatically created module for IPython interactive environment',
   '__loader__': None,
   '__name__': '__main__',
   '__package__': None,
   '__spec__': None,
   '_dh': ['/home/pasha/machine-learning.coursera/LearnInProgress/final.assignment/Kaggle'],
   '_i': 'import gc\ngc.garbage',
   '_i1': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
   '_i10': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_i11': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   '_i12': 'def pick(l: list, index: int) -> int:\n    return l[index]',
   '_i13': 'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
   '_i14': 'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
   '_i15': 'pick([1, 2, 3], 2)',
   '_i16': "pick([1, 2, 3], '2')",
   '_i17': 'import gc',
   '_i18': 'import gc\nпс',
   '_i19': 'import gc\ngc',
   '_i2': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
   '_i20': 'import gc\ngc.garbage',
   '_i21': 'gc.get_objects()',
   '_i3': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
   '_i4': "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   '_i5': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   '_i6': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_i7': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_i8': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_i9': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_ih': ['',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
    "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    'def pick(l: list, index: int) -> int:\n    return l[index]',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
    'pick([1, 2, 3], 2)',
    "pick([1, 2, 3], '2')",
    'import gc',
    'import gc\nпс',
    'import gc\ngc',
    'import gc\ngc.garbage',
    'gc.get_objects()'],
   '_ii': 'import gc\ngc',
   '_iii': 'import gc\nпс',
   '_oh': {14: 3, 15: 3, 19: <module 'gc' (built-in)>, 20: []},
   '_sh': <module 'IPython.core.shadowns' from '/home/pasha/.local/lib/python3.4/site-packages/IPython/core/shadowns.py'>,
   'exit': <IPython.core.autocall.ZMQExitAutocall at 0x7f51c016ef98>,
   'get_ipython': <bound method ZMQInteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>,
   'quit': <IPython.core.autocall.ZMQExitAutocall at 0x7f51c016ef98>}},
 {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]},
  'ipython_dir': {'change': [<traitlets.traitlets._CallbackWrapper at 0x7f51c01478d0>]}},
 (18642,
  1457880526.353978,
  ['"""A ZMQ-based subclass of InteractiveShell.\n',
   '\n',
   'This code is meant to ease the refactoring of the base InteractiveShell into\n',
   'something with a cleaner architecture for 2-process use, without actually\n',
   "breaking InteractiveShell itself.  So we're doing something a bit ugly, where\n",
   'we subclass and override what we want to fix.  Once this is working well, we\n',
   'can go back to the base class and refactor the code for a cleaner inheritance\n',
   "implementation that doesn't rely on so much monkeypatching.\n",
   '\n',
   'But this lets us maintain a fully working IPython as we develop the new\n',
   'machinery.  This should thus be thought of as scaffolding.\n',
   '"""\n',
   '\n',
   '# Copyright (c) IPython Development Team.\n',
   '# Distributed under the terms of the Modified BSD License.\n',
   '\n',
   'from __future__ import print_function\n',
   '\n',
   'import os\n',
   'import sys\n',
   'import time\n',
   'import warnings\n',
   '\n',
   'from zmq.eventloop import ioloop\n',
   '\n',
   'from IPython.core.interactiveshell import (\n',
   '    InteractiveShell, InteractiveShellABC\n',
   ')\n',
   'from IPython.core import page\n',
   'from IPython.core.autocall import ZMQExitAutocall\n',
   'from IPython.core.displaypub import DisplayPublisher\n',
   'from IPython.core.error import UsageError\n',
   'from IPython.core.magics import MacroToEdit, CodeMagics\n',
   'from IPython.core.magic import magics_class, line_magic, Magics\n',
   'from IPython.core import payloadpage\n',
   'from IPython.core.usage import default_banner\n',
   'from IPython.display import display, Javascript\n',
   'from ipykernel import (\n',
   '    get_connection_file, get_connection_info, connect_qtconsole\n',
   ')\n',
   'from IPython.utils import openpy\n',
   'from ipykernel.jsonutil import json_clean, encode_images\n',
   'from IPython.utils.process import arg_split\n',
   'from ipython_genutils import py3compat\n',
   'from ipython_genutils.py3compat import unicode_type\n',
   'from traitlets import Instance, Type, Dict, CBool, CBytes, Any\n',
   'from IPython.utils.warn import error\n',
   'from ipykernel.displayhook import ZMQShellDisplayHook\n',
   'from jupyter_client.session import extract_header\n',
   'from jupyter_client.session import Session\n',
   '\n',
   '#-----------------------------------------------------------------------------\n',
   '# Functions and classes\n',
   '#-----------------------------------------------------------------------------\n',
   '\n',
   'class ZMQDisplayPublisher(DisplayPublisher):\n',
   '    """A display publisher that publishes data using a ZeroMQ PUB socket."""\n',
   '\n',
   '    session = Instance(Session, allow_none=True)\n',
   '    pub_socket = Any(allow_none=True)\n',
   '    parent_header = Dict({})\n',
   "    topic = CBytes(b'display_data')\n",
   '\n',
   '    def set_parent(self, parent):\n',
   '        """Set the parent for outbound messages."""\n',
   '        self.parent_header = extract_header(parent)\n',
   '\n',
   '    def _flush_streams(self):\n',
   '        """flush IO Streams prior to display"""\n',
   '        sys.stdout.flush()\n',
   '        sys.stderr.flush()\n',
   '\n',
   '    def publish(self, data, metadata=None, source=None):\n',
   '        self._flush_streams()\n',
   '        if metadata is None:\n',
   '            metadata = {}\n',
   '        self._validate_data(data, metadata)\n',
   '        content = {}\n',
   "        content['data'] = encode_images(data)\n",
   "        content['metadata'] = metadata\n",
   '        self.session.send(\n',
   "            self.pub_socket, u'display_data', json_clean(content),\n",
   '            parent=self.parent_header, ident=self.topic,\n',
   '        )\n',
   '\n',
   '    def clear_output(self, wait=False):\n',
   '        content = dict(wait=wait)\n',
   '        self._flush_streams()\n',
   '        self.session.send(\n',
   "            self.pub_socket, u'clear_output', content,\n",
   '            parent=self.parent_header, ident=self.topic,\n',
   '        )\n',
   '\n',
   '@magics_class\n',
   'class KernelMagics(Magics):\n',
   '    #------------------------------------------------------------------------\n',
   '    # Magic overrides\n',
   '    #------------------------------------------------------------------------\n',
   '    # Once the base class stops inheriting from magic, this code needs to be\n',
   '    # moved into a separate machinery as well.  For now, at least isolate here\n',
   '    # the magics which this class needs to implement differently from the base\n',
   '    # class, or that are unique to it.\n',
   '\n',
   '    _find_edit_target = CodeMagics._find_edit_target\n',
   '\n',
   '    @line_magic\n',
   "    def edit(self, parameter_s='', last_call=['','']):\n",
   '        """Bring up an editor and execute the resulting code.\n',
   '\n',
   '        Usage:\n',
   '          %edit [options] [args]\n',
   '\n',
   '        %edit runs an external text editor. You will need to set the command for\n',
   '        this editor via the ``TerminalInteractiveShell.editor`` option in your\n',
   '        configuration file before it will work.\n',
   '\n',
   '        This command allows you to conveniently edit multi-line code right in\n',
   '        your IPython session.\n',
   '\n',
   '        If called without arguments, %edit opens up an empty editor with a\n',
   '        temporary file and will execute the contents of this file when you\n',
   "        close it (don't forget to save it!).\n",
   '\n',
   '        Options:\n',
   '\n',
   '        -n <number>\n',
   '          Open the editor at a specified line number. By default, the IPython\n',
   "          editor hook uses the unix syntax 'editor +N filename', but you can\n",
   '          configure this by providing your own modified hook if your favorite\n',
   '          editor supports line-number specifications with a different syntax.\n',
   '\n',
   '        -p\n',
   '          Call the editor with the same data as the previous time it was used,\n',
   '          regardless of how long ago (in your current session) it was.\n',
   '\n',
   '        -r\n',
   "          Use 'raw' input. This option only applies to input taken from the\n",
   "          user's history.  By default, the 'processed' history is used, so that\n",
   '          magics are loaded in their transformed version to valid Python.  If\n',
   '          this option is given, the raw input as typed as the command line is\n',
   '          used instead.  When you exit the editor, it will be executed by\n',
   "          IPython's own processor.\n",
   '\n',
   '        Arguments:\n',
   '\n',
   '        If arguments are given, the following possibilites exist:\n',
   '\n',
   '        - The arguments are numbers or pairs of colon-separated numbers (like\n',
   '          1 4:8 9). These are interpreted as lines of previous input to be\n',
   '          loaded into the editor. The syntax is the same of the %macro command.\n',
   '\n',
   "        - If the argument doesn't start with a number, it is evaluated as a\n",
   '          variable and its contents loaded into the editor. You can thus edit\n',
   '          any string which contains python code (including the result of\n',
   '          previous edits).\n',
   '\n',
   '        - If the argument is the name of an object (other than a string),\n',
   '          IPython will try to locate the file where it was defined and open the\n',
   '          editor at the point where it is defined. You can use ``%edit function``\n',
   "          to load an editor exactly at the point where 'function' is defined,\n",
   '          edit it and have the file be executed automatically.\n',
   '\n',
   '          If the object is a macro (see %macro for details), this opens up your\n',
   "          specified editor with a temporary file containing the macro's data.\n",
   '          Upon exit, the macro is reloaded with the contents of the file.\n',
   '\n',
   '          Note: opening at an exact line is only supported under Unix, and some\n',
   '          editors (like kedit and gedit up to Gnome 2.8) do not understand the\n',
   "          '+NUMBER' parameter necessary for this feature. Good editors like\n",
   '          (X)Emacs, vi, jed, pico and joe all do.\n',
   '\n',
   '        - If the argument is not found as a variable, IPython will look for a\n',
   '          file with that name (adding .py if necessary) and load it into the\n',
   '          editor. It will execute its contents with execfile() when you exit,\n',
   '          loading any code in the file into your interactive namespace.\n',
   '\n',
   '        Unlike in the terminal, this is designed to use a GUI editor, and we do\n',
   '        not know when it has closed. So the file you edit will not be\n',
   '        automatically executed or printed.\n',
   '\n',
   '        Note that %edit is also available through the alias %ed.\n',
   '        """\n',
   '\n',
   "        opts,args = self.parse_options(parameter_s,'prn:')\n",
   '\n',
   '        try:\n',
   '            filename, lineno, _ = CodeMagics._find_edit_target(self.shell, args, opts, last_call)\n',
   '        except MacroToEdit as e:\n',
   '            # TODO: Implement macro editing over 2 processes.\n',
   '            print("Macro editing not yet implemented in 2-process model.")\n',
   '            return\n',
   '\n',
   '        # Make sure we send to the client an absolute path, in case the working\n',
   "        # directory of client and kernel don't match\n",
   '        filename = os.path.abspath(filename)\n',
   '\n',
   '        payload = {\n',
   "            'source' : 'edit_magic',\n",
   "            'filename' : filename,\n",
   "            'line_number' : lineno\n",
   '        }\n',
   '        self.shell.payload_manager.write_payload(payload)\n',
   '\n',
   '    # A few magics that are adapted to the specifics of using pexpect and a\n',
   '    # remote terminal\n',
   '\n',
   '    @line_magic\n',
   '    def clear(self, arg_s):\n',
   '        """Clear the terminal."""\n',
   "        if os.name == 'posix':\n",
   '            self.shell.system("clear")\n',
   '        else:\n',
   '            self.shell.system("cls")\n',
   '\n',
   "    if os.name == 'nt':\n",
   '        # This is the usual name in windows\n',
   "        cls = line_magic('cls')(clear)\n",
   '\n',
   "    # Terminal pagers won't work over pexpect, but we do have our own pager\n",
   '\n',
   '    @line_magic\n',
   '    def less(self, arg_s):\n',
   '        """Show a file through the pager.\n',
   '\n',
   '        Files ending in .py are syntax-highlighted."""\n',
   '        if not arg_s:\n',
   "            raise UsageError('Missing filename.')\n",
   '\n',
   "        if arg_s.endswith('.py'):\n",
   '            cont = self.shell.pycolorize(openpy.read_py_file(arg_s, skip_encoding_cookie=False))\n',
   '        else:\n',
   '            cont = open(arg_s).read()\n',
   '        page.page(cont)\n',
   '\n',
   "    more = line_magic('more')(less)\n",
   '\n',
   '    # Man calls a pager, so we also need to redefine it\n',
   "    if os.name == 'posix':\n",
   '        @line_magic\n',
   '        def man(self, arg_s):\n',
   '            """Find the man page for the given command and display in pager."""\n',
   "            page.page(self.shell.getoutput('man %s | col -b' % arg_s,\n",
   '                                           split=False))\n',
   '\n',
   '    @line_magic\n',
   '    def connect_info(self, arg_s):\n',
   '        """Print information for connecting other clients to this kernel\n',
   '\n',
   "        It will print the contents of this session's connection file, as well as\n",
   '        shortcuts for local clients.\n',
   '\n',
   '        In the simplest case, when called from the most recently launched kernel,\n',
   '        secondary clients can be connected, simply with:\n',
   '\n',
   '        $> ipython <app> --existing\n',
   '\n',
   '        """\n',
   '\n',
   '        from IPython.core.application import BaseIPythonApplication as BaseIPApp\n',
   '\n',
   '        if BaseIPApp.initialized():\n',
   '            app = BaseIPApp.instance()\n',
   '            security_dir = app.profile_dir.security_dir\n',
   '            profile = app.profile\n',
   '        else:\n',
   "            profile = 'default'\n",
   "            security_dir = ''\n",
   '\n',
   '        try:\n',
   '            connection_file = get_connection_file()\n',
   '            info = get_connection_info(unpack=False)\n',
   '        except Exception as e:\n',
   '            error("Could not get connection info: %r" % e)\n',
   '            return\n',
   '\n',
   '        # add profile flag for non-default profile\n',
   '        profile_flag = "--profile %s" % profile if profile != \'default\' else ""\n',
   '\n',
   "        # if it's in the security dir, truncate to basename\n",
   '        if security_dir == os.path.dirname(connection_file):\n',
   '            connection_file = os.path.basename(connection_file)\n',
   '\n',
   '\n',
   "        print (info + '\\n')\n",
   '        print ("Paste the above JSON into a file, and connect with:\\n"\n',
   '            "    $> ipython <app> --existing <file>\\n"\n',
   '            "or, if you are local, you can connect with just:\\n"\n',
   '            "    $> ipython <app> --existing {0} {1}\\n"\n',
   '            "or even just:\\n"\n',
   '            "    $> ipython <app> --existing {1}\\n"\n',
   '            "if this is the most recent IPython session you have started.".format(\n',
   '            connection_file, profile_flag\n',
   '            )\n',
   '        )\n',
   '\n',
   '    @line_magic\n',
   '    def qtconsole(self, arg_s):\n',
   '        """Open a qtconsole connected to this kernel.\n',
   '\n',
   '        Useful for connecting a qtconsole to running notebooks, for better\n',
   '        debugging.\n',
   '        """\n',
   '\n',
   '        # %qtconsole should imply bind_kernel for engines:\n',
   '        # FIXME: move to ipyparallel Kernel subclass\n',
   "        if 'ipyparallel' in sys.modules:\n",
   '            from ipyparallel import bind_kernel\n',
   '            bind_kernel()\n',
   '\n',
   '        try:\n',
   "            p = connect_qtconsole(argv=arg_split(arg_s, os.name=='posix'))\n",
   '        except Exception as e:\n',
   '            error("Could not start qtconsole: %r" % e)\n',
   '            return\n',
   '\n',
   '    @line_magic\n',
   '    def autosave(self, arg_s):\n',
   '        """Set the autosave interval in the notebook (in seconds).\n',
   '\n',
   '        The default value is 120, or two minutes.\n',
   '        ``%autosave 0`` will disable autosave.\n',
   '\n',
   '        This magic only has an effect when called from the notebook interface.\n',
   '        It has no effect when called in a startup file.\n',
   '        """\n',
   '\n',
   '        try:\n',
   '            interval = int(arg_s)\n',
   '        except ValueError:\n',
   '            raise UsageError("%%autosave requires an integer, got %r" % arg_s)\n',
   '\n',
   '        # javascript wants milliseconds\n',
   '        milliseconds = 1000 * interval\n',
   '        display(Javascript("IPython.notebook.set_autosave_interval(%i)" % milliseconds),\n',
   "            include=['application/javascript']\n",
   '        )\n',
   '        if interval:\n',
   '            print("Autosaving every %i seconds" % interval)\n',
   '        else:\n',
   '            print("Autosave disabled")\n',
   '\n',
   '\n',
   'class ZMQInteractiveShell(InteractiveShell):\n',
   '    """A subclass of InteractiveShell for ZMQ."""\n',
   '\n',
   '    displayhook_class = Type(ZMQShellDisplayHook)\n',
   '    display_pub_class = Type(ZMQDisplayPublisher)\n',
   "    data_pub_class = Type('ipykernel.datapub.ZMQDataPublisher')\n",
   '    kernel = Any()\n',
   '    parent_header = Any()\n',
   '\n',
   '    def _banner1_default(self):\n',
   '        return default_banner\n',
   '\n',
   "    # Override the traitlet in the parent class, because there's no point using\n",
   '    # readline for the kernel. Can be removed when the readline code is moved\n',
   '    # to the terminal frontend.\n',
   '    colors_force = CBool(True)\n',
   '    readline_use = CBool(False)\n',
   '    # autoindent has no meaning in a zmqshell, and attempting to enable it\n',
   '    # will print a warning in the absence of readline.\n',
   '    autoindent = CBool(False)\n',
   '\n',
   '    exiter = Instance(ZMQExitAutocall)\n',
   '    def _exiter_default(self):\n',
   '        return ZMQExitAutocall(self)\n',
   '\n',
   '    def _exit_now_changed(self, name, old, new):\n',
   '        """stop eventloop when exit_now fires"""\n',
   '        if new:\n',
   '            loop = ioloop.IOLoop.instance()\n',
   '            loop.add_timeout(time.time()+0.1, loop.stop)\n',
   '\n',
   '    keepkernel_on_exit = None\n',
   '\n',
   "    # Over ZeroMQ, GUI control isn't done with PyOS_InputHook as there is no\n",
   '    # interactive input being read; we provide event loop support in ipkernel\n',
   '    @staticmethod\n',
   '    def enable_gui(gui):\n',
   '        from .eventloops import enable_gui as real_enable_gui\n',
   '        try:\n',
   '            real_enable_gui(gui)\n',
   '        except ValueError as e:\n',
   '            raise UsageError("%s" % e)\n',
   '\n',
   '    def init_environment(self):\n',
   '        """Configure the user\'s environment."""\n',
   '        env = os.environ\n',
   "        # These two ensure 'ls' produces nice coloring on BSD-derived systems\n",
   "        env['TERM'] = 'xterm-color'\n",
   "        env['CLICOLOR'] = '1'\n",
   "        # Since normal pagers don't work at all (over pexpect we don't have\n",
   '        # single-key control of the subprocess), try to disable paging in\n',
   '        # subprocesses as much as possible.\n',
   "        env['PAGER'] = 'cat'\n",
   "        env['GIT_PAGER'] = 'cat'\n",
   '\n',
   '    def init_hooks(self):\n',
   '        super(ZMQInteractiveShell, self).init_hooks()\n',
   "        self.set_hook('show_in_pager', page.as_hook(payloadpage.page), 99)\n",
   '    \n',
   '    def init_data_pub(self):\n',
   '        """Delay datapub init until request, for deprecation warnings"""\n',
   '        pass\n',
   '    \n',
   '    @property\n',
   '    def data_pub(self):\n',
   "        if not hasattr(self, '_data_pub'):\n",
   '            warnings.warn("InteractiveShell.data_pub is deprecated outside IPython parallel.", \n',
   '                DeprecationWarning, stacklevel=2)\n',
   '            \n',
   '            self._data_pub = self.data_pub_class(parent=self)\n',
   '            self._data_pub.session = self.display_pub.session\n',
   '            self._data_pub.pub_socket = self.display_pub.pub_socket\n',
   '        return self._data_pub\n',
   '    \n',
   '    @data_pub.setter\n',
   '    def data_pub(self, pub):\n',
   '        self._data_pub = pub\n',
   '\n',
   '    def ask_exit(self):\n',
   '        """Engage the exit actions."""\n',
   '        self.exit_now = (not self.keepkernel_on_exit)\n',
   '        payload = dict(\n',
   "            source='ask_exit',\n",
   '            keepkernel=self.keepkernel_on_exit,\n',
   '            )\n',
   '        self.payload_manager.write_payload(payload)\n',
   '\n',
   '    def _showtraceback(self, etype, evalue, stb):\n',
   '        # try to preserve ordering of tracebacks and print statements\n',
   '        sys.stdout.flush()\n',
   '        sys.stderr.flush()\n',
   '\n',
   '        exc_content = {\n',
   "            u'traceback' : stb,\n",
   "            u'ename' : unicode_type(etype.__name__),\n",
   "            u'evalue' : py3compat.safe_unicode(evalue),\n",
   '        }\n',
   '\n',
   '        dh = self.displayhook\n',
   '        # Send exception info over pub socket for other clients than the caller\n',
   '        # to pick up\n',
   '        topic = None\n',
   '        if dh.topic:\n',
   "            topic = dh.topic.replace(b'execute_result', b'error')\n",
   '\n',
   "        exc_msg = dh.session.send(dh.pub_socket, u'error', json_clean(exc_content), dh.parent_header, ident=topic)\n",
   '\n',
   '        # FIXME - Hack: store exception info in shell object.  Right now, the\n',
   '        # caller is reading this info after the fact, we need to fix this logic\n',
   '        # to remove this hack.  Even uglier, we need to store the error status\n',
   '        # here, because in the main loop, the logic that sets it is being\n',
   '        # skipped because runlines swallows the exceptions.\n',
   "        exc_content[u'status'] = u'error'\n",
   '        self._reply_content = exc_content\n',
   '        # /FIXME\n',
   '\n',
   '        return exc_content\n',
   '\n',
   '    def set_next_input(self, text, replace=False):\n',
   '        """Send the specified text to the frontend to be presented at the next\n',
   '        input cell."""\n',
   '        payload = dict(\n',
   "            source='set_next_input',\n",
   '            text=text,\n',
   '            replace=replace,\n',
   '        )\n',
   '        self.payload_manager.write_payload(payload)\n',
   '\n',
   '    def set_parent(self, parent):\n',
   '        """Set the parent header for associating output with its triggering input"""\n',
   '        self.parent_header = parent\n',
   '        self.displayhook.set_parent(parent)\n',
   '        self.display_pub.set_parent(parent)\n',
   "        if hasattr(self, '_data_pub'):\n",
   '            self.data_pub.set_parent(parent)\n',
   '        try:\n',
   '            sys.stdout.set_parent(parent)\n',
   '        except AttributeError:\n',
   '            pass\n',
   '        try:\n',
   '            sys.stderr.set_parent(parent)\n',
   '        except AttributeError:\n',
   '            pass\n',
   '\n',
   '    def get_parent(self):\n',
   '        return self.parent_header\n',
   '\n',
   '    #-------------------------------------------------------------------------\n',
   '    # Things related to magics\n',
   '    #-------------------------------------------------------------------------\n',
   '\n',
   '    def init_magics(self):\n',
   '        super(ZMQInteractiveShell, self).init_magics()\n',
   '        self.register_magics(KernelMagics)\n',
   "        self.magics_manager.register_alias('ed', 'edit')\n",
   '\n',
   '\n',
   'InteractiveShellABC.register(ZMQInteractiveShell)\n'],
  '/home/pasha/.local/lib/python3.4/site-packages/ipykernel/zmqshell.py'),
 <module 'ipykernel.datapub' from '/home/pasha/.local/lib/python3.4/site-packages/ipykernel/datapub.py'>,
 {'Any': traitlets.traitlets.Any,
  'CBytes': traitlets.traitlets.CBytes,
  'Configurable': traitlets.config.configurable.Configurable,
  'Dict': traitlets.traitlets.Dict,
  'Instance': traitlets.traitlets.Instance,
  'Session': jupyter_client.session.Session,
  'ZMQDataPublisher': ipykernel.datapub.ZMQDataPublisher,
  '__builtins__': {'ArithmeticError': ArithmeticError,
   'AssertionError': AssertionError,
   'AttributeError': AttributeError,
   'BaseException': BaseException,
   'BlockingIOError': BlockingIOError,
   'BrokenPipeError': BrokenPipeError,
   'BufferError': BufferError,
   'BytesWarning': BytesWarning,
   'ChildProcessError': ChildProcessError,
   'ConnectionAbortedError': ConnectionAbortedError,
   'ConnectionError': ConnectionError,
   'ConnectionRefusedError': ConnectionRefusedError,
   'ConnectionResetError': ConnectionResetError,
   'DeprecationWarning': DeprecationWarning,
   'EOFError': EOFError,
   'Ellipsis': Ellipsis,
   'EnvironmentError': OSError,
   'Exception': Exception,
   'False': False,
   'FileExistsError': FileExistsError,
   'FileNotFoundError': FileNotFoundError,
   'FloatingPointError': FloatingPointError,
   'FutureWarning': FutureWarning,
   'GeneratorExit': GeneratorExit,
   'IOError': OSError,
   'ImportError': ImportError,
   'ImportWarning': ImportWarning,
   'IndentationError': IndentationError,
   'IndexError': IndexError,
   'InterruptedError': InterruptedError,
   'IsADirectoryError': IsADirectoryError,
   'KeyError': KeyError,
   'KeyboardInterrupt': KeyboardInterrupt,
   'LookupError': LookupError,
   'MemoryError': MemoryError,
   'NameError': NameError,
   'None': None,
   'NotADirectoryError': NotADirectoryError,
   'NotImplemented': NotImplemented,
   'NotImplementedError': NotImplementedError,
   'OSError': OSError,
   'OverflowError': OverflowError,
   'PendingDeprecationWarning': PendingDeprecationWarning,
   'PermissionError': PermissionError,
   'ProcessLookupError': ProcessLookupError,
   'ReferenceError': ReferenceError,
   'ResourceWarning': ResourceWarning,
   'RuntimeError': RuntimeError,
   'RuntimeWarning': RuntimeWarning,
   'StopIteration': StopIteration,
   'SyntaxError': SyntaxError,
   'SyntaxWarning': SyntaxWarning,
   'SystemError': SystemError,
   'SystemExit': SystemExit,
   'TabError': TabError,
   'TimeoutError': TimeoutError,
   'True': True,
   'TypeError': TypeError,
   'UnboundLocalError': UnboundLocalError,
   'UnicodeDecodeError': UnicodeDecodeError,
   'UnicodeEncodeError': UnicodeEncodeError,
   'UnicodeError': UnicodeError,
   'UnicodeTranslateError': UnicodeTranslateError,
   'UnicodeWarning': UnicodeWarning,
   'UserWarning': UserWarning,
   'ValueError': ValueError,
   'Warning': Warning,
   'ZeroDivisionError': ZeroDivisionError,
   '__IPYTHON__': True,
   '__IPYTHON__active': 'Deprecated, check for __IPYTHON__',
   '__build_class__': <function __build_class__>,
   '__debug__': True,
   '__doc__': "Built-in functions, exceptions, and other objects.\n\nNoteworthy: None is the `nil' object; Ellipsis represents `...' in slices.",
   '__import__': <function __import__>,
   '__loader__': _frozen_importlib.BuiltinImporter,
   '__name__': 'builtins',
   '__package__': '',
   '__spec__': ModuleSpec(name='builtins', loader=<class '_frozen_importlib.BuiltinImporter'>),
   'abs': <function abs>,
   'all': <function all>,
   'any': <function any>,
   'ascii': <function ascii>,
   'bin': <function bin>,
   'bool': bool,
   'bytearray': bytearray,
   'bytes': bytes,
   'callable': <function callable>,
   'chr': <function chr>,
   'classmethod': classmethod,
   'compile': <function compile>,
   'complex': complex,
   'copyright': Copyright (c) 2001-2015 Python Software Foundation.
   All Rights Reserved.
   
   Copyright (c) 2000 BeOpen.com.
   All Rights Reserved.
   
   Copyright (c) 1995-2001 Corporation for National Research Initiatives.
   All Rights Reserved.
   
   Copyright (c) 1991-1995 Stichting Mathematisch Centrum, Amsterdam.
   All Rights Reserved.,
   'credits':     Thanks to CWI, CNRI, BeOpen.com, Zope Corporation and a cast of thousands
       for supporting Python development.  See www.python.org for more information.,
   'delattr': <function delattr>,
   'dict': dict,
   'dir': <function dir>,
   'divmod': <function divmod>,
   'dreload': <function IPython.lib.deepreload._dreload>,
   'enumerate': enumerate,
   'eval': <function eval>,
   'exec': <function exec>,
   'filter': filter,
   'float': float,
   'format': <function format>,
   'frozenset': frozenset,
   'get_ipython': <bound method ZMQInteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>,
   'getattr': <function getattr>,
   'globals': <function globals>,
   'hasattr': <function hasattr>,
   'hash': <function hash>,
   'help': Type help() for interactive help, or help(object) for help about object.,
   'hex': <function hex>,
   'id': <function id>,
   'input': <bound method IPythonKernel.raw_input of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
   'int': int,
   'isinstance': <function isinstance>,
   'issubclass': <function issubclass>,
   'iter': <function iter>,
   'len': <function len>,
   'license': See https://www.python.org/psf/license/,
   'list': list,
   'locals': <function locals>,
   'map': map,
   'max': <function max>,
   'memoryview': memoryview,
   'min': <function min>,
   'next': <function next>,
   'object': object,
   'oct': <function oct>,
   'open': <function io.open>,
   'ord': <function ord>,
   'pow': <function pow>,
   'print': <function print>,
   'property': property,
   'range': range,
   'repr': <function repr>,
   'reversed': reversed,
   'round': <function round>,
   'set': set,
   'setattr': <function setattr>,
   'slice': slice,
   'sorted': <function sorted>,
   'staticmethod': staticmethod,
   'str': str,
   'sum': <function sum>,
   'super': super,
   'tuple': tuple,
   'type': type,
   'vars': <function vars>,
   'zip': zip},
  '__cached__': '/home/pasha/.local/lib/python3.4/site-packages/ipykernel/__pycache__/datapub.cpython-34.pyc',
  '__doc__': 'Publishing native (typically pickled) objects.\n',
  '__file__': '/home/pasha/.local/lib/python3.4/site-packages/ipykernel/datapub.py',
  '__loader__': <_frozen_importlib.SourceFileLoader at 0x7f51c124b780>,
  '__name__': 'ipykernel.datapub',
  '__package__': 'ipykernel',
  '__spec__': ModuleSpec(name='ipykernel.datapub', loader=<_frozen_importlib.SourceFileLoader object at 0x7f51c124b780>, origin='/home/pasha/.local/lib/python3.4/site-packages/ipykernel/datapub.py'),
  '__warningregistry__': {'version': 4,
   ('ipykernel.datapub is deprecated. It has moved to ipyparallel.datapub',
    DeprecationWarning,
    5): True},
  'extract_header': <function jupyter_client.session.extract_header>,
  'json_clean': <function ipykernel.jsonutil.json_clean>,
  'publish_data': <function ipykernel.datapub.publish_data>,
  'serialize_object': <function ipykernel.serialize.serialize_object>,
  'warnings': <module 'warnings' from '/usr/lib64/python3.4/warnings.py'>},
 ('publish a data_message on the IOPub channel\n\n    Parameters\n    ----------\n\n    data : dict\n        The data to be published. Think of it as a namespace.\n    ',
  'ipykernel.datapub is deprecated. It has moved to ipyparallel.datapub',
  0,
  ('ZMQInteractiveShell',),
  None),
 {'version': 4,
  ('ipykernel.datapub is deprecated. It has moved to ipyparallel.datapub',
   DeprecationWarning,
   5): True},
 <module 'ipykernel.serialize' from '/home/pasha/.local/lib/python3.4/site-packages/ipykernel/serialize.py'>,
 {'CannedObject': ipykernel.pickleutil.CannedObject,
  'MAX_BYTES': 1024,
  'MAX_ITEMS': 64,
  'PICKLE_PROTOCOL': 3,
  'PY3': True,
  '__builtins__': {'ArithmeticError': ArithmeticError,
   'AssertionError': AssertionError,
   'AttributeError': AttributeError,
   'BaseException': BaseException,
   'BlockingIOError': BlockingIOError,
   'BrokenPipeError': BrokenPipeError,
   'BufferError': BufferError,
   'BytesWarning': BytesWarning,
   'ChildProcessError': ChildProcessError,
   'ConnectionAbortedError': ConnectionAbortedError,
   'ConnectionError': ConnectionError,
   'ConnectionRefusedError': ConnectionRefusedError,
   'ConnectionResetError': ConnectionResetError,
   'DeprecationWarning': DeprecationWarning,
   'EOFError': EOFError,
   'Ellipsis': Ellipsis,
   'EnvironmentError': OSError,
   'Exception': Exception,
   'False': False,
   'FileExistsError': FileExistsError,
   'FileNotFoundError': FileNotFoundError,
   'FloatingPointError': FloatingPointError,
   'FutureWarning': FutureWarning,
   'GeneratorExit': GeneratorExit,
   'IOError': OSError,
   'ImportError': ImportError,
   'ImportWarning': ImportWarning,
   'IndentationError': IndentationError,
   'IndexError': IndexError,
   'InterruptedError': InterruptedError,
   'IsADirectoryError': IsADirectoryError,
   'KeyError': KeyError,
   'KeyboardInterrupt': KeyboardInterrupt,
   'LookupError': LookupError,
   'MemoryError': MemoryError,
   'NameError': NameError,
   'None': None,
   'NotADirectoryError': NotADirectoryError,
   'NotImplemented': NotImplemented,
   'NotImplementedError': NotImplementedError,
   'OSError': OSError,
   'OverflowError': OverflowError,
   'PendingDeprecationWarning': PendingDeprecationWarning,
   'PermissionError': PermissionError,
   'ProcessLookupError': ProcessLookupError,
   'ReferenceError': ReferenceError,
   'ResourceWarning': ResourceWarning,
   'RuntimeError': RuntimeError,
   'RuntimeWarning': RuntimeWarning,
   'StopIteration': StopIteration,
   'SyntaxError': SyntaxError,
   'SyntaxWarning': SyntaxWarning,
   'SystemError': SystemError,
   'SystemExit': SystemExit,
   'TabError': TabError,
   'TimeoutError': TimeoutError,
   'True': True,
   'TypeError': TypeError,
   'UnboundLocalError': UnboundLocalError,
   'UnicodeDecodeError': UnicodeDecodeError,
   'UnicodeEncodeError': UnicodeEncodeError,
   'UnicodeError': UnicodeError,
   'UnicodeTranslateError': UnicodeTranslateError,
   'UnicodeWarning': UnicodeWarning,
   'UserWarning': UserWarning,
   'ValueError': ValueError,
   'Warning': Warning,
   'ZeroDivisionError': ZeroDivisionError,
   '__IPYTHON__': True,
   '__IPYTHON__active': 'Deprecated, check for __IPYTHON__',
   '__build_class__': <function __build_class__>,
   '__debug__': True,
   '__doc__': "Built-in functions, exceptions, and other objects.\n\nNoteworthy: None is the `nil' object; Ellipsis represents `...' in slices.",
   '__import__': <function __import__>,
   '__loader__': _frozen_importlib.BuiltinImporter,
   '__name__': 'builtins',
   '__package__': '',
   '__spec__': ModuleSpec(name='builtins', loader=<class '_frozen_importlib.BuiltinImporter'>),
   'abs': <function abs>,
   'all': <function all>,
   'any': <function any>,
   'ascii': <function ascii>,
   'bin': <function bin>,
   'bool': bool,
   'bytearray': bytearray,
   'bytes': bytes,
   'callable': <function callable>,
   'chr': <function chr>,
   'classmethod': classmethod,
   'compile': <function compile>,
   'complex': complex,
   'copyright': Copyright (c) 2001-2015 Python Software Foundation.
   All Rights Reserved.
   
   Copyright (c) 2000 BeOpen.com.
   All Rights Reserved.
   
   Copyright (c) 1995-2001 Corporation for National Research Initiatives.
   All Rights Reserved.
   
   Copyright (c) 1991-1995 Stichting Mathematisch Centrum, Amsterdam.
   All Rights Reserved.,
   'credits':     Thanks to CWI, CNRI, BeOpen.com, Zope Corporation and a cast of thousands
       for supporting Python development.  See www.python.org for more information.,
   'delattr': <function delattr>,
   'dict': dict,
   'dir': <function dir>,
   'divmod': <function divmod>,
   'dreload': <function IPython.lib.deepreload._dreload>,
   'enumerate': enumerate,
   'eval': <function eval>,
   'exec': <function exec>,
   'filter': filter,
   'float': float,
   'format': <function format>,
   'frozenset': frozenset,
   'get_ipython': <bound method ZMQInteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>,
   'getattr': <function getattr>,
   'globals': <function globals>,
   'hasattr': <function hasattr>,
   'hash': <function hash>,
   'help': Type help() for interactive help, or help(object) for help about object.,
   'hex': <function hex>,
   'id': <function id>,
   'input': <bound method IPythonKernel.raw_input of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
   'int': int,
   'isinstance': <function isinstance>,
   'issubclass': <function issubclass>,
   'iter': <function iter>,
   'len': <function len>,
   'license': See https://www.python.org/psf/license/,
   'list': list,
   'locals': <function locals>,
   'map': map,
   'max': <function max>,
   'memoryview': memoryview,
   'min': <function min>,
   'next': <function next>,
   'object': object,
   'oct': <function oct>,
   'open': <function io.open>,
   'ord': <function ord>,
   'pow': <function pow>,
   'print': <function print>,
   'property': property,
   'range': range,
   'repr': <function repr>,
   'reversed': reversed,
   'round': <function round>,
   'set': set,
   'setattr': <function setattr>,
   'slice': slice,
   'sorted': <function sorted>,
   'staticmethod': staticmethod,
   'str': str,
   'sum': <function sum>,
   'super': super,
   'tuple': tuple,
   'type': type,
   'vars': <function vars>,
   'zip': zip},
  '__cached__': '/home/pasha/.local/lib/python3.4/site-packages/ipykernel/__pycache__/serialize.cpython-34.pyc',
  '__doc__': 'serialization utilities for apply messages',
  '__file__': '/home/pasha/.local/lib/python3.4/site-packages/ipykernel/serialize.py',
  '__loader__': <_frozen_importlib.SourceFileLoader at 0x7f51c124b4a8>,
  '__name__': 'ipykernel.serialize',
  '__package__': 'ipykernel',
  '__spec__': ModuleSpec(name='ipykernel.serialize', loader=<_frozen_importlib.SourceFileLoader object at 0x7f51c124b4a8>, origin='/home/pasha/.local/lib/python3.4/site-packages/ipykernel/serialize.py'),
  '__warningregistry__': {'version': 4,
   ('ipykernel.serialize is deprecated. It has moved to ipyparallel.serialize',
    DeprecationWarning,
    7): True},
  '_extract_buffers': <function ipykernel.serialize._extract_buffers>,
  '_restore_buffers': <function ipykernel.serialize._restore_buffers>,
  'buffer': memoryview,
  'buffer_to_bytes_py2': <function ipython_genutils.py3compat.no_code>,
  'cPickle': None,
  'can': <function ipykernel.pickleutil.can>,
  'can_sequence': <function ipykernel.pickleutil.can_sequence>,
  'chain': itertools.chain,
  'deserialize_object': <function ipykernel.serialize.deserialize_object>,
  'istype': <function ipykernel.pickleutil.istype>,
  'pack_apply_message': <function ipykernel.serialize.pack_apply_message>,
  'pickle': <module 'pickle' from '/usr/lib64/python3.4/pickle.py'>,
  'sequence_types': (list, tuple, set),
  'serialize_object': <function ipykernel.serialize.serialize_object>,
  'uncan': <function ipykernel.pickleutil.uncan>,
  'uncan_sequence': <function ipykernel.pickleutil.uncan_sequence>,
  'unpack_apply_message': <function ipykernel.serialize.unpack_apply_message>,
  'warnings': <module 'warnings' from '/usr/lib64/python3.4/warnings.py'>},
 {'version': 4,
  ('ipykernel.serialize is deprecated. It has moved to ipyparallel.serialize',
   DeprecationWarning,
   7): True},
 <module 'ipykernel.pickleutil' from '/home/pasha/.local/lib/python3.4/site-packages/ipykernel/pickleutil.py'>,
 {'Application': traitlets.config.application.Application,
  'CannedArray': ipykernel.pickleutil.CannedArray,
  'CannedBuffer': ipykernel.pickleutil.CannedBuffer,
  'CannedBytes': ipykernel.pickleutil.CannedBytes,
  'CannedCell': ipykernel.pickleutil.CannedCell,
  'CannedClass': ipykernel.pickleutil.CannedClass,
  'CannedFunction': ipykernel.pickleutil.CannedFunction,
  'CannedMemoryView': ipykernel.pickleutil.CannedMemoryView,
  'CannedObject': ipykernel.pickleutil.CannedObject,
  'FunctionType': function,
  'PICKLE_PROTOCOL': 3,
  'Reference': ipykernel.pickleutil.Reference,
  '__builtins__': {'ArithmeticError': ArithmeticError,
   'AssertionError': AssertionError,
   'AttributeError': AttributeError,
   'BaseException': BaseException,
   'BlockingIOError': BlockingIOError,
   'BrokenPipeError': BrokenPipeError,
   'BufferError': BufferError,
   'BytesWarning': BytesWarning,
   'ChildProcessError': ChildProcessError,
   'ConnectionAbortedError': ConnectionAbortedError,
   'ConnectionError': ConnectionError,
   'ConnectionRefusedError': ConnectionRefusedError,
   'ConnectionResetError': ConnectionResetError,
   'DeprecationWarning': DeprecationWarning,
   'EOFError': EOFError,
   'Ellipsis': Ellipsis,
   'EnvironmentError': OSError,
   'Exception': Exception,
   'False': False,
   'FileExistsError': FileExistsError,
   'FileNotFoundError': FileNotFoundError,
   'FloatingPointError': FloatingPointError,
   'FutureWarning': FutureWarning,
   'GeneratorExit': GeneratorExit,
   'IOError': OSError,
   'ImportError': ImportError,
   'ImportWarning': ImportWarning,
   'IndentationError': IndentationError,
   'IndexError': IndexError,
   'InterruptedError': InterruptedError,
   'IsADirectoryError': IsADirectoryError,
   'KeyError': KeyError,
   'KeyboardInterrupt': KeyboardInterrupt,
   'LookupError': LookupError,
   'MemoryError': MemoryError,
   'NameError': NameError,
   'None': None,
   'NotADirectoryError': NotADirectoryError,
   'NotImplemented': NotImplemented,
   'NotImplementedError': NotImplementedError,
   'OSError': OSError,
   'OverflowError': OverflowError,
   'PendingDeprecationWarning': PendingDeprecationWarning,
   'PermissionError': PermissionError,
   'ProcessLookupError': ProcessLookupError,
   'ReferenceError': ReferenceError,
   'ResourceWarning': ResourceWarning,
   'RuntimeError': RuntimeError,
   'RuntimeWarning': RuntimeWarning,
   'StopIteration': StopIteration,
   'SyntaxError': SyntaxError,
   'SyntaxWarning': SyntaxWarning,
   'SystemError': SystemError,
   'SystemExit': SystemExit,
   'TabError': TabError,
   'TimeoutError': TimeoutError,
   'True': True,
   'TypeError': TypeError,
   'UnboundLocalError': UnboundLocalError,
   'UnicodeDecodeError': UnicodeDecodeError,
   'UnicodeEncodeError': UnicodeEncodeError,
   'UnicodeError': UnicodeError,
   'UnicodeTranslateError': UnicodeTranslateError,
   'UnicodeWarning': UnicodeWarning,
   'UserWarning': UserWarning,
   'ValueError': ValueError,
   'Warning': Warning,
   'ZeroDivisionError': ZeroDivisionError,
   '__IPYTHON__': True,
   '__IPYTHON__active': 'Deprecated, check for __IPYTHON__',
   '__build_class__': <function __build_class__>,
   '__debug__': True,
   '__doc__': "Built-in functions, exceptions, and other objects.\n\nNoteworthy: None is the `nil' object; Ellipsis represents `...' in slices.",
   '__import__': <function __import__>,
   '__loader__': _frozen_importlib.BuiltinImporter,
   '__name__': 'builtins',
   '__package__': '',
   '__spec__': ModuleSpec(name='builtins', loader=<class '_frozen_importlib.BuiltinImporter'>),
   'abs': <function abs>,
   'all': <function all>,
   'any': <function any>,
   'ascii': <function ascii>,
   'bin': <function bin>,
   'bool': bool,
   'bytearray': bytearray,
   'bytes': bytes,
   'callable': <function callable>,
   'chr': <function chr>,
   'classmethod': classmethod,
   'compile': <function compile>,
   'complex': complex,
   'copyright': Copyright (c) 2001-2015 Python Software Foundation.
   All Rights Reserved.
   
   Copyright (c) 2000 BeOpen.com.
   All Rights Reserved.
   
   Copyright (c) 1995-2001 Corporation for National Research Initiatives.
   All Rights Reserved.
   
   Copyright (c) 1991-1995 Stichting Mathematisch Centrum, Amsterdam.
   All Rights Reserved.,
   'credits':     Thanks to CWI, CNRI, BeOpen.com, Zope Corporation and a cast of thousands
       for supporting Python development.  See www.python.org for more information.,
   'delattr': <function delattr>,
   'dict': dict,
   'dir': <function dir>,
   'divmod': <function divmod>,
   'dreload': <function IPython.lib.deepreload._dreload>,
   'enumerate': enumerate,
   'eval': <function eval>,
   'exec': <function exec>,
   'filter': filter,
   'float': float,
   'format': <function format>,
   'frozenset': frozenset,
   'get_ipython': <bound method ZMQInteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>,
   'getattr': <function getattr>,
   'globals': <function globals>,
   'hasattr': <function hasattr>,
   'hash': <function hash>,
   'help': Type help() for interactive help, or help(object) for help about object.,
   'hex': <function hex>,
   'id': <function id>,
   'input': <bound method IPythonKernel.raw_input of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
   'int': int,
   'isinstance': <function isinstance>,
   'issubclass': <function issubclass>,
   'iter': <function iter>,
   'len': <function len>,
   'license': See https://www.python.org/psf/license/,
   'list': list,
   'locals': <function locals>,
   'map': map,
   'max': <function max>,
   'memoryview': memoryview,
   'min': <function min>,
   'next': <function next>,
   'object': object,
   'oct': <function oct>,
   'open': <function io.open>,
   'ord': <function ord>,
   'pow': <function pow>,
   'print': <function print>,
   'property': property,
   'range': range,
   'repr': <function repr>,
   'reversed': reversed,
   'round': <function round>,
   'set': set,
   'setattr': <function setattr>,
   'slice': slice,
   'sorted': <function sorted>,
   'staticmethod': staticmethod,
   'str': str,
   'sum': <function sum>,
   'super': super,
   'tuple': tuple,
   'type': type,
   'vars': <function vars>,
   'zip': zip},
  '__cached__': '/home/pasha/.local/lib/python3.4/site-packages/ipykernel/__pycache__/pickleutil.cpython-34.pyc',
  '__doc__': "Pickle related utilities. Perhaps this should be called 'can'.",
  '__file__': '/home/pasha/.local/lib/python3.4/site-packages/ipykernel/pickleutil.py',
  '__loader__': <_frozen_importlib.SourceFileLoader at 0x7f51c124b4e0>,
  '__name__': 'ipykernel.pickleutil',
  '__package__': 'ipykernel',
  '__spec__': ModuleSpec(name='ipykernel.pickleutil', loader=<_frozen_importlib.SourceFileLoader object at 0x7f51c124b4e0>, origin='/home/pasha/.local/lib/python3.4/site-packages/ipykernel/pickleutil.py'),
  '__warningregistry__': {'version': 4,
   ('ipykernel.pickleutil is deprecated. It has moved to ipyparallel.',
    DeprecationWarning,
    8): True},
  '_get_cell_type': <function ipykernel.pickleutil._get_cell_type>,
  '_import_mapping': <function ipykernel.pickleutil._import_mapping>,
  '_original_can_map': {'numpy.ndarray': ipykernel.pickleutil.CannedArray,
   function: ipykernel.pickleutil.CannedFunction,
   type: <function ipykernel.pickleutil.can_class>,
   cell: ipykernel.pickleutil.CannedCell,
   bytes: ipykernel.pickleutil.CannedBytes,
   memoryview: ipykernel.pickleutil.CannedMemoryView},
  '_original_uncan_map': {ipykernel.pickleutil.CannedObject: <function ipykernel.pickleutil.<lambda>>,
   dict: <function ipykernel.pickleutil.uncan_dict>},
  'buffer': memoryview,
  'buffer_to_bytes': <function ipython_genutils.py3compat.buffer_to_bytes>,
  'buffer_to_bytes_py2': <function ipython_genutils.py3compat.no_code>,
  'can': <function ipykernel.pickleutil.can>,
  'can_class': <function ipykernel.pickleutil.can_class>,
  'can_dict': <function ipykernel.pickleutil.can_dict>,
  'can_map': {'numpy.ndarray': ipykernel.pickleutil.CannedArray,
   function: ipykernel.pickleutil.CannedFunction,
   type: <function ipykernel.pickleutil.can_class>,
   cell: ipykernel.pickleutil.CannedCell,
   bytes: ipykernel.pickleutil.CannedBytes,
   memoryview: ipykernel.pickleutil.CannedMemoryView},
  'can_sequence': <function ipykernel.pickleutil.can_sequence>,
  'cell_type': cell,
  'class_type': type,
  'codeutil': <module 'ipykernel.codeutil' from '/home/pasha/.local/lib/python3.4/site-packages/ipykernel/codeutil.py'>,
  'copy': <module 'copy' from '/usr/lib64/python3.4/copy.py'>,
  'get_logger': <function traitlets.log.get_logger>,
  'import_item': <function ipython_genutils.importstring.import_item>,
  'interactive': <function ipykernel.pickleutil.interactive>,
  'istype': <function ipykernel.pickleutil.istype>,
  'iteritems': <function ipython_genutils.py3compat.iteritems>,
  'logging': <module 'logging' from '/usr/lib64/python3.4/logging/__init__.py'>,
  'pickle': <module 'pickle' from '/usr/lib64/python3.4/pickle.py'>,
  'py3compat': <module 'ipython_genutils.py3compat' from '/home/pasha/.local/lib/python3.4/site-packages/ipython_genutils/py3compat.py'>,
  'sequence_types': (list, tuple, set),
  'string_types': (str,),
  'sys': <module 'sys' (built-in)>,
  'uncan': <function ipykernel.pickleutil.uncan>,
  'uncan_dict': <function ipykernel.pickleutil.uncan_dict>,
  'uncan_map': {ipykernel.pickleutil.CannedObject: <function ipykernel.pickleutil.<lambda>>,
   dict: <function ipykernel.pickleutil.uncan_dict>},
  'uncan_sequence': <function ipykernel.pickleutil.uncan_sequence>,
  'use_cloudpickle': <function ipykernel.pickleutil.use_cloudpickle>,
  'use_dill': <function ipykernel.pickleutil.use_dill>,
  'warnings': <module 'warnings' from '/usr/lib64/python3.4/warnings.py'>},
 ('use dill to expand serialization support\n    \n    adds support for object methods and closures to serialization.\n    ',
  0,
  None,
  ('serialize',)),
 ('use cloudpickle to expand serialization support\n    \n    adds support for object methods and closures to serialization.\n    ',
  0,
  None,
  ('serialize',)),
 (None,
  '__weakref__',
  '__dict__',
  <code object <listcomp> at 0x7f51c01a2540, file "/home/pasha/.local/lib/python3.4/site-packages/ipykernel/pickleutil.py", line 250>,
  'CannedClass.__init__.<locals>.<listcomp>',
  1,
  ('__weakref__', '__dict__')),
 (None,
  0,
  ('ascontiguousarray',),
  False,
  True,
  'O',
  <code object <genexpr> at 0x7f51c01a28a0, file "/home/pasha/.local/lib/python3.4/site-packages/ipykernel/pickleutil.py", line 271>,
  'CannedArray.__init__.<locals>.<genexpr>',
  'dtype'),
 (None, 0, ('frombuffer',), 'dtype'),
 {'version': 4,
  ('ipykernel.pickleutil is deprecated. It has moved to ipyparallel.',
   DeprecationWarning,
   8): True},
 <module 'ipykernel.codeutil' from '/home/pasha/.local/lib/python3.4/site-packages/ipykernel/codeutil.py'>,
 {'__builtins__': {'ArithmeticError': ArithmeticError,
   'AssertionError': AssertionError,
   'AttributeError': AttributeError,
   'BaseException': BaseException,
   'BlockingIOError': BlockingIOError,
   'BrokenPipeError': BrokenPipeError,
   'BufferError': BufferError,
   'BytesWarning': BytesWarning,
   'ChildProcessError': ChildProcessError,
   'ConnectionAbortedError': ConnectionAbortedError,
   'ConnectionError': ConnectionError,
   'ConnectionRefusedError': ConnectionRefusedError,
   'ConnectionResetError': ConnectionResetError,
   'DeprecationWarning': DeprecationWarning,
   'EOFError': EOFError,
   'Ellipsis': Ellipsis,
   'EnvironmentError': OSError,
   'Exception': Exception,
   'False': False,
   'FileExistsError': FileExistsError,
   'FileNotFoundError': FileNotFoundError,
   'FloatingPointError': FloatingPointError,
   'FutureWarning': FutureWarning,
   'GeneratorExit': GeneratorExit,
   'IOError': OSError,
   'ImportError': ImportError,
   'ImportWarning': ImportWarning,
   'IndentationError': IndentationError,
   'IndexError': IndexError,
   'InterruptedError': InterruptedError,
   'IsADirectoryError': IsADirectoryError,
   'KeyError': KeyError,
   'KeyboardInterrupt': KeyboardInterrupt,
   'LookupError': LookupError,
   'MemoryError': MemoryError,
   'NameError': NameError,
   'None': None,
   'NotADirectoryError': NotADirectoryError,
   'NotImplemented': NotImplemented,
   'NotImplementedError': NotImplementedError,
   'OSError': OSError,
   'OverflowError': OverflowError,
   'PendingDeprecationWarning': PendingDeprecationWarning,
   'PermissionError': PermissionError,
   'ProcessLookupError': ProcessLookupError,
   'ReferenceError': ReferenceError,
   'ResourceWarning': ResourceWarning,
   'RuntimeError': RuntimeError,
   'RuntimeWarning': RuntimeWarning,
   'StopIteration': StopIteration,
   'SyntaxError': SyntaxError,
   'SyntaxWarning': SyntaxWarning,
   'SystemError': SystemError,
   'SystemExit': SystemExit,
   'TabError': TabError,
   'TimeoutError': TimeoutError,
   'True': True,
   'TypeError': TypeError,
   'UnboundLocalError': UnboundLocalError,
   'UnicodeDecodeError': UnicodeDecodeError,
   'UnicodeEncodeError': UnicodeEncodeError,
   'UnicodeError': UnicodeError,
   'UnicodeTranslateError': UnicodeTranslateError,
   'UnicodeWarning': UnicodeWarning,
   'UserWarning': UserWarning,
   'ValueError': ValueError,
   'Warning': Warning,
   'ZeroDivisionError': ZeroDivisionError,
   '__IPYTHON__': True,
   '__IPYTHON__active': 'Deprecated, check for __IPYTHON__',
   '__build_class__': <function __build_class__>,
   '__debug__': True,
   '__doc__': "Built-in functions, exceptions, and other objects.\n\nNoteworthy: None is the `nil' object; Ellipsis represents `...' in slices.",
   '__import__': <function __import__>,
   '__loader__': _frozen_importlib.BuiltinImporter,
   '__name__': 'builtins',
   '__package__': '',
   '__spec__': ModuleSpec(name='builtins', loader=<class '_frozen_importlib.BuiltinImporter'>),
   'abs': <function abs>,
   'all': <function all>,
   'any': <function any>,
   'ascii': <function ascii>,
   'bin': <function bin>,
   'bool': bool,
   'bytearray': bytearray,
   'bytes': bytes,
   'callable': <function callable>,
   'chr': <function chr>,
   'classmethod': classmethod,
   'compile': <function compile>,
   'complex': complex,
   'copyright': Copyright (c) 2001-2015 Python Software Foundation.
   All Rights Reserved.
   
   Copyright (c) 2000 BeOpen.com.
   All Rights Reserved.
   
   Copyright (c) 1995-2001 Corporation for National Research Initiatives.
   All Rights Reserved.
   
   Copyright (c) 1991-1995 Stichting Mathematisch Centrum, Amsterdam.
   All Rights Reserved.,
   'credits':     Thanks to CWI, CNRI, BeOpen.com, Zope Corporation and a cast of thousands
       for supporting Python development.  See www.python.org for more information.,
   'delattr': <function delattr>,
   'dict': dict,
   'dir': <function dir>,
   'divmod': <function divmod>,
   'dreload': <function IPython.lib.deepreload._dreload>,
   'enumerate': enumerate,
   'eval': <function eval>,
   'exec': <function exec>,
   'filter': filter,
   'float': float,
   'format': <function format>,
   'frozenset': frozenset,
   'get_ipython': <bound method ZMQInteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>,
   'getattr': <function getattr>,
   'globals': <function globals>,
   'hasattr': <function hasattr>,
   'hash': <function hash>,
   'help': Type help() for interactive help, or help(object) for help about object.,
   'hex': <function hex>,
   'id': <function id>,
   'input': <bound method IPythonKernel.raw_input of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
   'int': int,
   'isinstance': <function isinstance>,
   'issubclass': <function issubclass>,
   'iter': <function iter>,
   'len': <function len>,
   'license': See https://www.python.org/psf/license/,
   'list': list,
   'locals': <function locals>,
   'map': map,
   'max': <function max>,
   'memoryview': memoryview,
   'min': <function min>,
   'next': <function next>,
   'object': object,
   'oct': <function oct>,
   'open': <function io.open>,
   'ord': <function ord>,
   'pow': <function pow>,
   'print': <function print>,
   'property': property,
   'range': range,
   'repr': <function repr>,
   'reversed': reversed,
   'round': <function round>,
   'set': set,
   'setattr': <function setattr>,
   'slice': slice,
   'sorted': <function sorted>,
   'staticmethod': staticmethod,
   'str': str,
   'sum': <function sum>,
   'super': super,
   'tuple': tuple,
   'type': type,
   'vars': <function vars>,
   'zip': zip},
  '__cached__': '/home/pasha/.local/lib/python3.4/site-packages/ipykernel/__pycache__/codeutil.cpython-34.pyc',
  '__doc__': 'Utilities to enable code objects to be pickled.\n\nAny process that import this module will be able to pickle code objects.  This\nincludes the func_code attribute of any function.  Once unpickled, new\nfunctions can be built using new.function(code, globals()).  Eventually\nwe need to automate all of this so that functions themselves can be pickled.\n\nReference: A. Tremols, P Cogolo, "Python Cookbook," p 302-305\n',
  '__file__': '/home/pasha/.local/lib/python3.4/site-packages/ipykernel/codeutil.py',
  '__loader__': <_frozen_importlib.SourceFileLoader at 0x7f51c01a6278>,
  '__name__': 'ipykernel.codeutil',
  '__package__': 'ipykernel',
  '__spec__': ModuleSpec(name='ipykernel.codeutil', loader=<_frozen_importlib.SourceFileLoader object at 0x7f51c01a6278>, origin='/home/pasha/.local/lib/python3.4/site-packages/ipykernel/codeutil.py'),
  '__warningregistry__': {'version': 4,
   ('ipykernel.codeutil is deprecated. It has moved to ipyparallel.serialize',
    DeprecationWarning,
    17): True},
  'code_ctor': <function ipykernel.codeutil.code_ctor>,
  'copyreg': <module 'copyreg' from '/usr/lib64/python3.4/copyreg.py'>,
  'reduce_code': <function ipykernel.codeutil.reduce_code>,
  'sys': <module 'sys' (built-in)>,
  'types': <module 'types' from '/usr/lib64/python3.4/types.py'>,
  'warnings': <module 'warnings' from '/usr/lib64/python3.4/warnings.py'>},
 {'version': 4,
  ('ipykernel.codeutil is deprecated. It has moved to ipyparallel.serialize',
   DeprecationWarning,
   17): True},
 <function ipykernel.codeutil.code_ctor>,
 <function ipykernel.codeutil.reduce_code>,
 <function ipykernel.pickleutil._get_cell_type>,
 <function ipykernel.pickleutil.interactive>,
 <function ipykernel.pickleutil.use_dill>,
 <function ipykernel.pickleutil.use_cloudpickle>,
 ipykernel.pickleutil.CannedObject,
 (ipykernel.pickleutil.CannedObject, object),
 <weakref at 0x7f51c0199b88; to 'type' at 0x55b8f537ad28 (CannedObject)>,
 ipykernel.pickleutil.Reference,
 (ipykernel.pickleutil.Reference, ipykernel.pickleutil.CannedObject, object),
 {94252876411256: <weakref at 0x7f51c0199c28; to 'type' at 0x55b8f537b178 (Reference)>,
  94252876412296: <weakref at 0x7f51c0199c78; to 'type' at 0x55b8f537b588 (CannedCell)>,
  94252876413192: <weakref at 0x7f51c0199cc8; to 'type' at 0x55b8f537b908 (CannedFunction)>,
  94252876414232: <weakref at 0x7f51c0199d18; to 'type' at 0x55b8f537bd18 (CannedClass)>,
  94252876415512: <weakref at 0x7f51c0199d68; to 'type' at 0x55b8f537c218 (CannedArray)>,
  94252876416792: <weakref at 0x7f51c0199db8; to 'type' at 0x55b8f537c718 (CannedBytes)>},
 ipykernel.pickleutil.CannedCell,
 (ipykernel.pickleutil.CannedCell, ipykernel.pickleutil.CannedObject, object),
 <weakref at 0x7f51c0199c78; to 'type' at 0x55b8f537b588 (CannedCell)>,
 ipykernel.pickleutil.CannedFunction,
 (ipykernel.pickleutil.CannedFunction,
  ipykernel.pickleutil.CannedObject,
  object),
 <weakref at 0x7f51c0199cc8; to 'type' at 0x55b8f537b908 (CannedFunction)>,
 ipykernel.pickleutil.CannedClass,
 (ipykernel.pickleutil.CannedClass, ipykernel.pickleutil.CannedObject, object),
 <weakref at 0x7f51c0199d18; to 'type' at 0x55b8f537bd18 (CannedClass)>,
 ipykernel.pickleutil.CannedArray,
 (ipykernel.pickleutil.CannedArray, ipykernel.pickleutil.CannedObject, object),
 <weakref at 0x7f51c0199d68; to 'type' at 0x55b8f537c218 (CannedArray)>,
 ipykernel.pickleutil.CannedBytes,
 (ipykernel.pickleutil.CannedBytes, ipykernel.pickleutil.CannedObject, object),
 <weakref at 0x7f51c0199db8; to 'type' at 0x55b8f537c718 (CannedBytes)>,
 ipykernel.pickleutil.CannedBuffer,
 (ipykernel.pickleutil.CannedBuffer,
  ipykernel.pickleutil.CannedBytes,
  ipykernel.pickleutil.CannedObject,
  object),
 {94252876418120: <weakref at 0x7f51c0199e08; to 'type' at 0x55b8f537cc48 (CannedBuffer)>,
  94252876419640: <weakref at 0x7f51c0199ea8; to 'type' at 0x55b8f537d238 (CannedMemoryView)>},
 ipykernel.pickleutil.CannedMemoryView,
 (ipykernel.pickleutil.CannedMemoryView,
  ipykernel.pickleutil.CannedBytes,
  ipykernel.pickleutil.CannedObject,
  object),
 <weakref at 0x7f51c0199ea8; to 'type' at 0x55b8f537d238 (CannedMemoryView)>,
 <function ipykernel.pickleutil._import_mapping>,
 <function ipykernel.pickleutil.istype>,
 <function ipykernel.pickleutil.can>,
 <function ipykernel.pickleutil.can_class>,
 <function ipykernel.pickleutil.can_dict>,
 <function ipykernel.pickleutil.can_sequence>,
 <function ipykernel.pickleutil.uncan>,
 <function ipykernel.pickleutil.uncan_dict>,
 <function ipykernel.pickleutil.uncan_sequence>,
 {'numpy.ndarray': ipykernel.pickleutil.CannedArray,
  function: ipykernel.pickleutil.CannedFunction,
  type: <function ipykernel.pickleutil.can_class>,
  cell: ipykernel.pickleutil.CannedCell,
  bytes: ipykernel.pickleutil.CannedBytes,
  memoryview: ipykernel.pickleutil.CannedMemoryView},
 {ipykernel.pickleutil.CannedObject: <function ipykernel.pickleutil.<lambda>>,
  dict: <function ipykernel.pickleutil.uncan_dict>},
 {'numpy.ndarray': ipykernel.pickleutil.CannedArray,
  function: ipykernel.pickleutil.CannedFunction,
  type: <function ipykernel.pickleutil.can_class>,
  cell: ipykernel.pickleutil.CannedCell,
  bytes: ipykernel.pickleutil.CannedBytes,
  memoryview: ipykernel.pickleutil.CannedMemoryView},
 {ipykernel.pickleutil.CannedObject: <function ipykernel.pickleutil.<lambda>>,
  dict: <function ipykernel.pickleutil.uncan_dict>},
 <function ipykernel.serialize._extract_buffers>,
 <function ipykernel.serialize._restore_buffers>,
 <function ipykernel.serialize.serialize_object>,
 <function ipykernel.serialize.deserialize_object>,
 <function ipykernel.serialize.pack_apply_message>,
 <function ipykernel.serialize.unpack_apply_message>,
 ipykernel.datapub.ZMQDataPublisher,
 (ipykernel.datapub.ZMQDataPublisher,
  traitlets.config.configurable.Configurable,
  traitlets.traitlets.HasTraits,
  traitlets.traitlets._NewBase,
  traitlets.traitlets.HasDescriptors,
  traitlets.traitlets._NewBase,
  object),
 <weakref at 0x7f51c0199228; to 'MetaHasTraits' at 0x55b8f537ebd8 (ZMQDataPublisher)>,
 <function ipykernel.datapub.publish_data>,
 {'_post_execute': {},
  'alias_manager': <IPython.core.alias.AliasManager at 0x7f51c01137b8>,
  'ast_node_interactivity': 'last_expr',
  'ast_transformers': [],
  'autocall': 0,
  'autoindent': False,
  'automagic': True,
  'banner1': 'Python 3.4.3 (default, Jun 29 2015, 12:16:01) \nType "copyright", "credits" or "license" for more information.\n\nIPython 4.1.2 -- An enhanced Interactive Python.\n?         -> Introduction and overview of IPython\'s features.\n%quickref -> Quick reference.\nhelp      -> Python\'s own help system.\nobject?   -> Details about \'object\', use \'object??\' for extra details.\n',
  'banner2': '',
  'builtin_trap': <IPython.core.builtin_trap.BuiltinTrap at 0x7f51c016eef0>,
  'cache_size': 1000,
  'color_info': True,
  'colors': 'Linux',
  'colors_force': True,
  'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
  'data_pub_class': ipykernel.datapub.ZMQDataPublisher,
  'debug': False,
  'deep_reload': False,
  'disable_failing_post_execute': False,
  'display_formatter': <IPython.core.formatters.DisplayFormatter at 0x7f51c0113400>,
  'display_page': False,
  'display_pub_class': ipykernel.zmqshell.ZMQDisplayPublisher,
  'display_trap': <IPython.core.display_trap.DisplayTrap at 0x7f51c0113320>,
  'displayhook_class': ipykernel.displayhook.ZMQShellDisplayHook,
  'execution_count': 21,
  'exit_now': False,
  'exiter': <IPython.core.autocall.ZMQExitAutocall at 0x7f51c016ef98>,
  'extension_manager': <IPython.core.extensions.ExtensionManager at 0x7f51c0113eb8>,
  'filename': '<ipython console>',
  'history_length': 10000,
  'history_load_length': 1000,
  'history_manager': <IPython.core.history.HistoryManager at 0x7f51c1221710>,
  'input_transformer_manager': <IPython.core.inputsplitter.IPythonInputSplitter at 0x7f51c00d4be0>,
  'ipython_dir': '/home/pasha/.ipython',
  'kernel': <ipykernel.ipkernel.IPythonKernel at 0x7f51c1221278>,
  'logappend': '',
  'logfile': '',
  'logstart': False,
  'magics_manager': <IPython.core.magic.MagicsManager at 0x7f51c0113470>,
  'multiline_history': True,
  'object_info_string_level': 0,
  'parent': <ipykernel.ipkernel.IPythonKernel at 0x7f51c1221278>,
  'parent_header': {'buffers': [],
   'content': {'allow_stdin': True,
    'code': 'gc.get_objects()',
    'silent': False,
    'stop_on_error': True,
    'store_history': True,
    'user_expressions': {}},
   'header': {'date': '2016-03-20T19:46:05.318327',
    'msg_id': 'BF3CEE6EC01944EEA25FA7825F7AD98A',
    'msg_type': 'execute_request',
    'session': '4CE6797D9E26478A800FA96DD84CCB50',
    'username': 'username',
    'version': '5.0'},
   'metadata': {},
   'msg_id': 'BF3CEE6EC01944EEA25FA7825F7AD98A',
   'msg_type': 'execute_request',
   'parent_header': {}},
  'payload_manager': <IPython.core.payload.PayloadManager at 0x7f51c01476a0>,
  'pdb': False,
  'prefilter_manager': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
  'profile_dir': <IPython.core.profiledir.ProfileDir at 0x7f51c1221518>,
  'prompt_in1': 'In [\\#]: ',
  'prompt_in2': '   .\\D.: ',
  'prompt_out': 'Out[\\#]: ',
  'prompts_pad_left': True,
  'quiet': False,
  'readline_delims': '',
  'readline_remove_delims': '-/~',
  'readline_use': False,
  'separate_in': '\n',
  'separate_out': '',
  'separate_out2': '',
  'show_rewritten_input': True,
  'wildcards_case_sensitive': True,
  'xmode': 'Context'},
 [<ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>,
  <IPython.core.history.HistoryManager at 0x7f51c1221710>,
  <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
  <IPython.core.completer.IPCompleter at 0x7f51c0186080>,
  <IPython.core.prompts.PromptManager at 0x7f51c01131d0>,
  <IPython.core.formatters.DisplayFormatter at 0x7f51c0113400>,
  <ipykernel.zmqshell.ZMQDisplayPublisher at 0x7f51c0113438>,
  <ipykernel.displayhook.ZMQShellDisplayHook at 0x7f51c0113278>,
  <IPython.core.magics.UserMagics at 0x7f51c01134a8>,
  <IPython.core.magic.MagicsManager at 0x7f51c0113470>,
  <IPython.core.magics.auto.AutoMagics at 0x7f51c0113a90>,
  <IPython.core.magics.basic.BasicMagics at 0x7f51c0113b00>,
  <IPython.core.magics.code.CodeMagics at 0x7f51c0113b38>,
  <IPython.core.magics.config.ConfigMagics at 0x7f51c0113b70>,
  <IPython.core.magics.deprecated.DeprecatedMagics at 0x7f51c0113ba8>,
  <IPython.core.magics.display.DisplayMagics at 0x7f51c0113be0>,
  <IPython.core.magics.execution.ExecutionMagics at 0x7f51c0113c18>,
  <IPython.core.magics.extension.ExtensionMagics at 0x7f51c0113c50>,
  <IPython.core.magics.history.HistoryMagics at 0x7f51c0113c88>,
  <IPython.core.magics.logging.LoggingMagics at 0x7f51c0113cc0>,
  <IPython.core.magics.namespace.NamespaceMagics at 0x7f51c0113cf8>,
  <IPython.core.magics.osm.OSMagics at 0x7f51c0113d30>,
  <IPython.core.magics.pylab.PylabMagics at 0x7f51c0113d68>,
  <IPython.core.magics.script.ScriptMagics at 0x7f51c0113da0>,
  <ipykernel.zmqshell.KernelMagics at 0x7f51c013b358>,
  <IPython.core.alias.AliasManager at 0x7f51c01137b8>,
  <IPython.core.extensions.ExtensionManager at 0x7f51c0113eb8>,
  <IPython.core.payload.PayloadManager at 0x7f51c01476a0>,
  <ipykernel.comm.manager.CommManager at 0x7f51c0147940>,
  <ipykernel.kernelapp.IPKernelApp at 0x7f51d2a1ac18>,
  <storemagic.StoreMagics at 0x7f51c01477b8>,
  <storemagic.StoreMagics at 0x7f51c01477b8>],
 (132557,
  1457880499.8382401,
  ['# -*- coding: utf-8 -*-\n',
   '"""Main IPython class."""\n',
   '\n',
   '#-----------------------------------------------------------------------------\n',
   '#  Copyright (C) 2001 Janko Hauser <jhauser@zscout.de>\n',
   '#  Copyright (C) 2001-2007 Fernando Perez. <fperez@colorado.edu>\n',
   '#  Copyright (C) 2008-2011  The IPython Development Team\n',
   '#\n',
   '#  Distributed under the terms of the BSD License.  The full license is in\n',
   '#  the file COPYING, distributed as part of this software.\n',
   '#-----------------------------------------------------------------------------\n',
   '\n',
   'from __future__ import absolute_import, print_function\n',
   '\n',
   'import __future__\n',
   'import abc\n',
   'import ast\n',
   'import atexit\n',
   'import functools\n',
   'import os\n',
   'import re\n',
   'import runpy\n',
   'import sys\n',
   'import tempfile\n',
   'import traceback\n',
   'import types\n',
   'import subprocess\n',
   'import warnings\n',
   'from io import open as io_open\n',
   '\n',
   'from pickleshare import PickleShareDB\n',
   '\n',
   'from traitlets.config.configurable import SingletonConfigurable\n',
   'from IPython.core import debugger, oinspect\n',
   'from IPython.core import magic\n',
   'from IPython.core import page\n',
   'from IPython.core import prefilter\n',
   'from IPython.core import shadowns\n',
   'from IPython.core import ultratb\n',
   'from IPython.core.alias import Alias, AliasManager\n',
   'from IPython.core.autocall import ExitAutocall\n',
   'from IPython.core.builtin_trap import BuiltinTrap\n',
   'from IPython.core.events import EventManager, available_events\n',
   'from IPython.core.compilerop import CachingCompiler, check_linecache_ipython\n',
   'from IPython.core.display_trap import DisplayTrap\n',
   'from IPython.core.displayhook import DisplayHook\n',
   'from IPython.core.displaypub import DisplayPublisher\n',
   'from IPython.core.error import InputRejected, UsageError\n',
   'from IPython.core.extensions import ExtensionManager\n',
   'from IPython.core.formatters import DisplayFormatter\n',
   'from IPython.core.history import HistoryManager\n',
   'from IPython.core.inputsplitter import IPythonInputSplitter, ESC_MAGIC, ESC_MAGIC2\n',
   'from IPython.core.logger import Logger\n',
   'from IPython.core.macro import Macro\n',
   'from IPython.core.payload import PayloadManager\n',
   'from IPython.core.prefilter import PrefilterManager\n',
   'from IPython.core.profiledir import ProfileDir\n',
   'from IPython.core.prompts import PromptManager\n',
   'from IPython.core.usage import default_banner\n',
   'from IPython.testing.skipdoctest import skip_doctest\n',
   'from IPython.utils import PyColorize\n',
   'from IPython.utils import io\n',
   'from IPython.utils import py3compat\n',
   'from IPython.utils import openpy\n',
   'from IPython.utils.contexts import NoOpContext\n',
   'from IPython.utils.decorators import undoc\n',
   'from IPython.utils.io import ask_yes_no\n',
   'from IPython.utils.ipstruct import Struct\n',
   'from IPython.paths import get_ipython_dir\n',
   'from IPython.utils.path import get_home_dir, get_py_filename, unquote_filename, ensure_dir_exists\n',
   'from IPython.utils.process import system, getoutput\n',
   'from IPython.utils.py3compat import (builtin_mod, unicode_type, string_types,\n',
   '                                     with_metaclass, iteritems)\n',
   'from IPython.utils.strdispatch import StrDispatch\n',
   'from IPython.utils.syspathcontext import prepended_to_syspath\n',
   'from IPython.utils.text import (format_screen, LSString, SList,\n',
   '                                DollarFormatter)\n',
   'from traitlets import (Integer, Bool, CBool, CaselessStrEnum, Enum,\n',
   '                                     List, Dict, Unicode, Instance, Type)\n',
   'from IPython.utils.warn import warn, error\n',
   'import IPython.core.hooks\n',
   '\n',
   '#-----------------------------------------------------------------------------\n',
   '# Globals\n',
   '#-----------------------------------------------------------------------------\n',
   '\n',
   '# compiled regexps for autoindent management\n',
   "dedent_re = re.compile(r'^\\s+raise|^\\s+return|^\\s+pass')\n",
   '\n',
   '#-----------------------------------------------------------------------------\n',
   '# Utilities\n',
   '#-----------------------------------------------------------------------------\n',
   '\n',
   '@undoc\n',
   'def softspace(file, newvalue):\n',
   '    """Copied from code.py, to remove the dependency"""\n',
   '\n',
   '    oldvalue = 0\n',
   '    try:\n',
   '        oldvalue = file.softspace\n',
   '    except AttributeError:\n',
   '        pass\n',
   '    try:\n',
   '        file.softspace = newvalue\n',
   '    except (AttributeError, TypeError):\n',
   '        # "attribute-less object" or "read-only attributes"\n',
   '        pass\n',
   '    return oldvalue\n',
   '\n',
   '@undoc\n',
   'def no_op(*a, **kw): pass\n',
   '\n',
   '\n',
   'class SpaceInInput(Exception): pass\n',
   '\n',
   '@undoc\n',
   'class Bunch: pass\n',
   '\n',
   '\n',
   'def get_default_colors():\n',
   "    if sys.platform=='darwin':\n",
   '        return "LightBG"\n',
   "    elif os.name=='nt':\n",
   "        return 'Linux'\n",
   '    else:\n',
   "        return 'Linux'\n",
   '\n',
   '\n',
   'class SeparateUnicode(Unicode):\n',
   '    r"""A Unicode subclass to validate separate_in, separate_out, etc.\n',
   '\n',
   "    This is a Unicode based trait that converts '0'->'' and ``'\\\\n'->'\\n'``.\n",
   '    """\n',
   '\n',
   '    def validate(self, obj, value):\n',
   "        if value == '0': value = ''\n",
   "        value = value.replace('\\\\n','\\n')\n",
   '        return super(SeparateUnicode, self).validate(obj, value)\n',
   '\n',
   '\n',
   '@undoc\n',
   'class DummyMod(object):\n',
   '    """A dummy module used for IPython\'s interactive module when\n',
   '    a namespace must be assigned to the module\'s __dict__."""\n',
   '    pass\n',
   '\n',
   '\n',
   'class ExecutionResult(object):\n',
   '    """The result of a call to :meth:`InteractiveShell.run_cell`\n',
   '\n',
   '    Stores information about what took place.\n',
   '    """\n',
   '    execution_count = None\n',
   '    error_before_exec = None\n',
   '    error_in_exec = None\n',
   '    result = None\n',
   '\n',
   '    @property\n',
   '    def success(self):\n',
   '        return (self.error_before_exec is None) and (self.error_in_exec is None)\n',
   '\n',
   '    def raise_error(self):\n',
   '        """Reraises error if `success` is `False`, otherwise does nothing"""\n',
   '        if self.error_before_exec is not None:\n',
   '            raise self.error_before_exec\n',
   '        if self.error_in_exec is not None:\n',
   '            raise self.error_in_exec\n',
   '\n',
   '\n',
   'class InteractiveShell(SingletonConfigurable):\n',
   '    """An enhanced, interactive shell for Python."""\n',
   '\n',
   '    _instance = None\n',
   '    \n',
   '    ast_transformers = List([], config=True, help=\n',
   '        """\n',
   '        A list of ast.NodeTransformer subclass instances, which will be applied\n',
   '        to user input before code is run.\n',
   '        """\n',
   '    )\n',
   '\n',
   '    autocall = Enum((0,1,2), default_value=0, config=True, help=\n',
   '        """\n',
   "        Make IPython automatically call any callable object even if you didn't\n",
   "        type explicit parentheses. For example, 'str 43' becomes 'str(43)'\n",
   "        automatically. The value can be '0' to disable the feature, '1' for\n",
   "        'smart' autocall, where it is not applied if there are no more\n",
   "        arguments on the line, and '2' for 'full' autocall, where all callable\n",
   '        objects are automatically called (even if no arguments are present).\n',
   '        """\n',
   '    )\n',
   '    # TODO: remove all autoindent logic and put into frontends.\n',
   "    # We can't do this yet because even runlines uses the autoindent.\n",
   '    autoindent = CBool(True, config=True, help=\n',
   '        """\n',
   '        Autoindent IPython code entered interactively.\n',
   '        """\n',
   '    )\n',
   '    automagic = CBool(True, config=True, help=\n',
   '        """\n',
   '        Enable magic commands to be called without the leading %.\n',
   '        """\n',
   '    )\n',
   '    \n',
   '    banner1 = Unicode(default_banner, config=True,\n',
   '        help="""The part of the banner to be printed before the profile"""\n',
   '    )\n',
   "    banner2 = Unicode('', config=True,\n",
   '        help="""The part of the banner to be printed after the profile"""\n',
   '    )\n',
   '\n',
   '    cache_size = Integer(1000, config=True, help=\n',
   '        """\n',
   '        Set the size of the output cache.  The default is 1000, you can\n',
   '        change it permanently in your config file.  Setting it to 0 completely\n',
   '        disables the caching system, and the minimum value accepted is 20 (if\n',
   '        you provide a value less than 20, it is reset to 0 and a warning is\n',
   "        issued).  This limit is defined because otherwise you'll spend more\n",
   '        time re-flushing a too small cache than working\n',
   '        """\n',
   '    )\n',
   '    color_info = CBool(True, config=True, help=\n',
   '        """\n',
   '        Use colors for displaying information about objects. Because this\n',
   "        information is passed through a pager (like 'less'), and some pagers\n",
   '        get confused with color codes, this capability can be turned off.\n',
   '        """\n',
   '    )\n',
   "    colors = CaselessStrEnum(('NoColor','LightBG','Linux'),\n",
   '                             default_value=get_default_colors(), config=True,\n',
   '        help="Set the color scheme (NoColor, Linux, or LightBG)."\n',
   '    )\n',
   '    colors_force = CBool(False, help=\n',
   '        """\n',
   '        Force use of ANSI color codes, regardless of OS and readline\n',
   '        availability.\n',
   '        """\n',
   '        # FIXME: This is essentially a hack to allow ZMQShell to show colors\n',
   '        # without readline on Win32. When the ZMQ formatting system is\n',
   '        # refactored, this should be removed.\n',
   '    )\n',
   '    debug = CBool(False, config=True)\n',
   '    deep_reload = CBool(False, config=True, help=\n',
   '        """\n',
   '        **Deprecated**\n',
   '\n',
   '        Will be removed in IPython 6.0\n',
   '\n',
   '        Enable deep (recursive) reloading by default. IPython can use the\n',
   '        deep_reload module which reloads changes in modules recursively (it\n',
   "        replaces the reload() function, so you don't need to change anything to\n",
   '        use it). `deep_reload` forces a full reload of modules whose code may\n',
   '        have changed, which the default reload() function does not.  When\n',
   '        deep_reload is off, IPython will use the normal reload(), but\n',
   '        deep_reload will still be available as dreload().\n',
   '        """\n',
   '    )\n',
   '    disable_failing_post_execute = CBool(False, config=True,\n',
   '        help="Don\'t call post-execute functions that have failed in the past."\n',
   '    )\n',
   '    display_formatter = Instance(DisplayFormatter, allow_none=True)\n',
   '    displayhook_class = Type(DisplayHook)\n',
   '    display_pub_class = Type(DisplayPublisher)\n',
   '    data_pub_class = None\n',
   '\n',
   '    exit_now = CBool(False)\n',
   '    exiter = Instance(ExitAutocall)\n',
   '    def _exiter_default(self):\n',
   '        return ExitAutocall(self)\n',
   '    # Monotonically increasing execution counter\n',
   '    execution_count = Integer(1)\n',
   '    filename = Unicode("<ipython console>")\n',
   "    ipython_dir= Unicode('', config=True) # Set to get_ipython_dir() in __init__\n",
   '\n',
   '    # Input splitter, to transform input line by line and detect when a block\n',
   '    # is ready to be executed.\n',
   "    input_splitter = Instance('IPython.core.inputsplitter.IPythonInputSplitter',\n",
   "                              (), {'line_input_checker': True})\n",
   '    \n',
   '    # This InputSplitter instance is used to transform completed cells before\n',
   '    # running them. It allows cell magics to contain blank lines.\n',
   "    input_transformer_manager = Instance('IPython.core.inputsplitter.IPythonInputSplitter',\n",
   "                                         (), {'line_input_checker': False})\n",
   '    \n',
   '    logstart = CBool(False, config=True, help=\n',
   '        """\n',
   '        Start logging to the default log file in overwrite mode.\n',
   '        Use `logappend` to specify a log file to **append** logs to.\n',
   '        """\n',
   '    )\n',
   "    logfile = Unicode('', config=True, help=\n",
   '        """\n',
   '        The name of the logfile to use.\n',
   '        """\n',
   '    )\n',
   "    logappend = Unicode('', config=True, help=\n",
   '        """\n',
   '        Start logging to the given file in append mode.\n',
   '        Use `logfile` to specify a log file to **overwrite** logs to.\n',
   '        """\n',
   '    )\n',
   '    object_info_string_level = Enum((0,1,2), default_value=0,\n',
   '                                    config=True)\n',
   '    pdb = CBool(False, config=True, help=\n',
   '        """\n',
   '        Automatically call the pdb debugger after every exception.\n',
   '        """\n',
   '    )\n',
   "    multiline_history = CBool(sys.platform != 'win32', config=True,\n",
   '        help="Save multi-line entries as one entry in readline history"\n',
   '    )\n',
   '    display_page = Bool(False, config=True,\n',
   '        help="""If True, anything that would be passed to the pager\n',
   '        will be displayed as regular output instead."""\n',
   '    )\n',
   '\n',
   '    # deprecated prompt traits:\n',
   '    \n',
   "    prompt_in1 = Unicode('In [\\\\#]: ', config=True,\n",
   '        help="Deprecated, will be removed in IPython 5.0, use PromptManager.in_template")\n',
   "    prompt_in2 = Unicode('   .\\\\D.: ', config=True,\n",
   '        help="Deprecated, will be removed in IPython 5.0, use PromptManager.in2_template")\n',
   "    prompt_out = Unicode('Out[\\\\#]: ', config=True,\n",
   '        help="Deprecated, will be removed in IPython 5.0, use PromptManager.out_template")\n',
   '    prompts_pad_left = CBool(True, config=True,\n',
   '        help="Deprecated, will be removed in IPython 5.0, use PromptManager.justify")\n',
   '    \n',
   '    def _prompt_trait_changed(self, name, old, new):\n',
   '        table = {\n',
   "            'prompt_in1' : 'in_template',\n",
   "            'prompt_in2' : 'in2_template',\n",
   "            'prompt_out' : 'out_template',\n",
   "            'prompts_pad_left' : 'justify',\n",
   '        }\n',
   '        warn("InteractiveShell.{name} is deprecated, use PromptManager.{newname}".format(\n',
   '                name=name, newname=table[name])\n',
   '        )\n',
   '        # protect against weird cases where self.config may not exist:\n',
   '        if self.config is not None:\n',
   '            # propagate to corresponding PromptManager trait\n',
   '            setattr(self.config.PromptManager, table[name], new)\n',
   '    \n',
   '    _prompt_in1_changed = _prompt_trait_changed\n',
   '    _prompt_in2_changed = _prompt_trait_changed\n',
   '    _prompt_out_changed = _prompt_trait_changed\n',
   '    _prompt_pad_left_changed = _prompt_trait_changed\n',
   '    \n',
   '    show_rewritten_input = CBool(True, config=True,\n',
   '        help="Show rewritten input, e.g. for autocall."\n',
   '    )\n',
   '    \n',
   '    quiet = CBool(False, config=True)\n',
   '\n',
   '    history_length = Integer(10000, config=True)\n',
   '\n',
   '    history_load_length = Integer(1000, config=True, help=\n',
   '        """\n',
   '        The number of saved history entries to be loaded\n',
   '        into the readline buffer at startup.\n',
   '        """\n',
   '    )\n',
   '\n',
   '    # The readline stuff will eventually be moved to the terminal subclass\n',
   "    # but for now, we can't do that as readline is welded in everywhere.\n",
   '    readline_use = CBool(True, config=True)\n',
   "    readline_remove_delims = Unicode('-/~', config=True)\n",
   '    readline_delims = Unicode() # set by init_readline()\n',
   "    # don't use \\M- bindings by default, because they\n",
   '    # conflict with 8-bit encodings. See gh-58,gh-88\n',
   '    readline_parse_and_bind = List([\n',
   "            'tab: complete',\n",
   '            \'"\\C-l": clear-screen\',\n',
   "            'set show-all-if-ambiguous on',\n",
   '            \'"\\C-o": tab-insert\',\n',
   '            \'"\\C-r": reverse-search-history\',\n',
   '            \'"\\C-s": forward-search-history\',\n',
   '            \'"\\C-p": history-search-backward\',\n',
   '            \'"\\C-n": history-search-forward\',\n',
   '            \'"\\e[A": history-search-backward\',\n',
   '            \'"\\e[B": history-search-forward\',\n',
   '            \'"\\C-k": kill-line\',\n',
   '            \'"\\C-u": unix-line-discard\',\n',
   '        ], config=True)\n',
   '    \n',
   '    _custom_readline_config = False\n',
   '    \n',
   '    def _readline_parse_and_bind_changed(self, name, old, new):\n',
   '        # notice that readline config is customized\n',
   '        # indicates that it should have higher priority than inputrc\n',
   '        self._custom_readline_config = True\n',
   '    \n',
   "    ast_node_interactivity = Enum(['all', 'last', 'last_expr', 'none'],\n",
   "                                  default_value='last_expr', config=True, \n",
   '                                  help="""\n',
   "        'all', 'last', 'last_expr' or 'none', specifying which nodes should be\n",
   '        run interactively (displaying output from expressions).""")\n',
   '\n',
   '    # TODO: this part of prompt management should be moved to the frontends.\n',
   "    # Use custom TraitTypes that convert '0'->'' and '\\\\n'->'\\n'\n",
   "    separate_in = SeparateUnicode('\\n', config=True)\n",
   "    separate_out = SeparateUnicode('', config=True)\n",
   "    separate_out2 = SeparateUnicode('', config=True)\n",
   '    wildcards_case_sensitive = CBool(True, config=True)\n',
   "    xmode = CaselessStrEnum(('Context','Plain', 'Verbose'),\n",
   "                            default_value='Context', config=True)\n",
   '\n',
   '    # Subcomponents of InteractiveShell\n',
   "    alias_manager = Instance('IPython.core.alias.AliasManager', allow_none=True)\n",
   "    prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager', allow_none=True)\n",
   "    builtin_trap = Instance('IPython.core.builtin_trap.BuiltinTrap', allow_none=True)\n",
   "    display_trap = Instance('IPython.core.display_trap.DisplayTrap', allow_none=True)\n",
   "    extension_manager = Instance('IPython.core.extensions.ExtensionManager', allow_none=True)\n",
   "    payload_manager = Instance('IPython.core.payload.PayloadManager', allow_none=True)\n",
   "    history_manager = Instance('IPython.core.history.HistoryAccessorBase', allow_none=True)\n",
   "    magics_manager = Instance('IPython.core.magic.MagicsManager', allow_none=True)\n",
   '\n',
   "    profile_dir = Instance('IPython.core.application.ProfileDir', allow_none=True)\n",
   '    @property\n',
   '    def profile(self):\n',
   '        if self.profile_dir is not None:\n',
   '            name = os.path.basename(self.profile_dir.location)\n',
   "            return name.replace('profile_','')\n",
   '\n',
   '\n',
   '    # Private interface\n',
   '    _post_execute = Dict()\n',
   '\n',
   '    # Tracks any GUI loop loaded for pylab\n',
   '    pylab_gui_select = None\n',
   '\n',
   '    def __init__(self, ipython_dir=None, profile_dir=None,\n',
   '                 user_module=None, user_ns=None,\n',
   '                 custom_exceptions=((), None), **kwargs):\n',
   '\n',
   '        # This is where traits with a config_key argument are updated\n',
   '        # from the values on config.\n',
   '        super(InteractiveShell, self).__init__(**kwargs)\n',
   '        self.configurables = [self]\n',
   '\n',
   '        # These are relatively independent and stateless\n',
   '        self.init_ipython_dir(ipython_dir)\n',
   '        self.init_profile_dir(profile_dir)\n',
   '        self.init_instance_attrs()\n',
   '        self.init_environment()\n',
   '        \n',
   "        # Check if we're in a virtualenv, and set up sys.path.\n",
   '        self.init_virtualenv()\n',
   '\n',
   '        # Create namespaces (user_ns, user_global_ns, etc.)\n',
   '        self.init_create_namespaces(user_module, user_ns)\n',
   '        # This has to be done after init_create_namespaces because it uses\n',
   '        # something in self.user_ns, but before init_sys_modules, which\n',
   '        # is the first thing to modify sys.\n',
   '        # TODO: When we override sys.stdout and sys.stderr before this class\n',
   '        # is created, we are saving the overridden ones here. Not sure if this\n',
   '        # is what we want to do.\n',
   '        self.save_sys_module_state()\n',
   '        self.init_sys_modules()\n',
   '\n',
   "        # While we're trying to have each part of the code directly access what\n",
   '        # it needs without keeping redundant references to objects, we have too\n',
   '        # much legacy code that expects ip.db to exist.\n',
   "        self.db = PickleShareDB(os.path.join(self.profile_dir.location, 'db'))\n",
   '\n',
   '        self.init_history()\n',
   '        self.init_encoding()\n',
   '        self.init_prefilter()\n',
   '\n',
   '        self.init_syntax_highlighting()\n',
   '        self.init_hooks()\n',
   '        self.init_events()\n',
   '        self.init_pushd_popd_magic()\n',
   '        # self.init_traceback_handlers use to be here, but we moved it below\n',
   '        # because it and init_io have to come after init_readline.\n',
   '        self.init_user_ns()\n',
   '        self.init_logger()\n',
   '        self.init_builtins()\n',
   '\n',
   '        # The following was in post_config_initialization\n',
   '        self.init_inspector()\n',
   '        # init_readline() must come before init_io(), because init_io uses\n',
   '        # readline related things.\n',
   '        self.init_readline()\n',
   '        # We save this here in case user code replaces raw_input, but it needs\n',
   "        # to be after init_readline(), because PyPy's readline works by replacing\n",
   '        # raw_input.\n',
   '        if py3compat.PY3:\n',
   '            self.raw_input_original = input\n',
   '        else:\n',
   '            self.raw_input_original = raw_input\n',
   '        # init_completer must come after init_readline, because it needs to\n',
   '        # know whether readline is present or not system-wide to configure the\n',
   '        # completers, since the completion machinery can now operate\n',
   '        # independently of readline (e.g. over the network)\n',
   '        self.init_completer()\n',
   '        # TODO: init_io() needs to happen before init_traceback handlers\n',
   '        # because the traceback handlers hardcode the stdout/stderr streams.\n',
   '        # This logic in in debugger.Pdb and should eventually be changed.\n',
   '        self.init_io()\n',
   '        self.init_traceback_handlers(custom_exceptions)\n',
   '        self.init_prompts()\n',
   '        self.init_display_formatter()\n',
   '        self.init_display_pub()\n',
   '        self.init_data_pub()\n',
   '        self.init_displayhook()\n',
   '        self.init_magics()\n',
   '        self.init_alias()\n',
   '        self.init_logstart()\n',
   '        self.init_pdb()\n',
   '        self.init_extension_manager()\n',
   '        self.init_payload()\n',
   '        self.init_deprecation_warnings()\n',
   '        self.hooks.late_startup_hook()\n',
   "        self.events.trigger('shell_initialized', self)\n",
   '        atexit.register(self.atexit_operations)\n',
   '\n',
   '    def get_ipython(self):\n',
   '        """Return the currently running IPython instance."""\n',
   '        return self\n',
   '\n',
   '    #-------------------------------------------------------------------------\n',
   '    # Trait changed handlers\n',
   '    #-------------------------------------------------------------------------\n',
   '\n',
   '    def _ipython_dir_changed(self, name, new):\n',
   '        ensure_dir_exists(new)\n',
   '\n',
   '    def set_autoindent(self,value=None):\n',
   '        """Set the autoindent flag, checking for readline support.\n',
   '\n',
   '        If called with no arguments, it acts as a toggle."""\n',
   '\n',
   '        if value != 0 and not self.has_readline:\n',
   "            if os.name == 'posix':\n",
   '                warn("The auto-indent feature requires the readline library")\n',
   '            self.autoindent = 0\n',
   '            return\n',
   '        if value is None:\n',
   '            self.autoindent = not self.autoindent\n',
   '        else:\n',
   '            self.autoindent = value\n',
   '\n',
   '    #-------------------------------------------------------------------------\n',
   '    # init_* methods called by __init__\n',
   '    #-------------------------------------------------------------------------\n',
   '\n',
   '    def init_ipython_dir(self, ipython_dir):\n',
   '        if ipython_dir is not None:\n',
   '            self.ipython_dir = ipython_dir\n',
   '            return\n',
   '\n',
   '        self.ipython_dir = get_ipython_dir()\n',
   '\n',
   '    def init_profile_dir(self, profile_dir):\n',
   '        if profile_dir is not None:\n',
   '            self.profile_dir = profile_dir\n',
   '            return\n',
   '        self.profile_dir =\\\n',
   "            ProfileDir.create_profile_dir_by_name(self.ipython_dir, 'default')\n",
   '\n',
   '    def init_instance_attrs(self):\n',
   '        self.more = False\n',
   '\n',
   '        # command compiler\n',
   '        self.compile = CachingCompiler()\n',
   '\n',
   '        # Make an empty namespace, which extension writers can rely on both\n',
   '        # existing and NEVER being used by ipython itself.  This gives them a\n',
   '        # convenient location for storing additional information and state\n',
   '        # their extensions may require, without fear of collisions with other\n',
   '        # ipython names that may develop later.\n',
   '        self.meta = Struct()\n',
   '\n',
   '        # Temporary files used for various purposes.  Deleted at exit.\n',
   '        self.tempfiles = []\n',
   '        self.tempdirs = []\n',
   '\n',
   '        # Keep track of readline usage (later set by init_readline)\n',
   '        self.has_readline = False\n',
   '\n',
   '        # keep track of where we started running (mainly for crash post-mortem)\n',
   '        # This is not being used anywhere currently.\n',
   '        self.starting_dir = py3compat.getcwd()\n',
   '\n',
   '        # Indentation management\n',
   '        self.indent_current_nsp = 0\n',
   '\n',
   '        # Dict to track post-execution functions that have been registered\n',
   '        self._post_execute = {}\n',
   '\n',
   '    def init_environment(self):\n',
   '        """Any changes we need to make to the user\'s environment."""\n',
   '        pass\n',
   '\n',
   '    def init_encoding(self):\n',
   '        # Get system encoding at startup time.  Certain terminals (like Emacs\n',
   '        # under Win32 have it set to None, and we need to have a known valid\n',
   '        # encoding to use in the raw_input() method\n',
   '        try:\n',
   "            self.stdin_encoding = sys.stdin.encoding or 'ascii'\n",
   '        except AttributeError:\n',
   "            self.stdin_encoding = 'ascii'\n",
   '\n',
   '    def init_syntax_highlighting(self):\n',
   '        # Python source parser/formatter for syntax highlighting\n',
   '        pyformat = PyColorize.Parser().format\n',
   "        self.pycolorize = lambda src: pyformat(src,'str',self.colors)\n",
   '\n',
   '    def init_pushd_popd_magic(self):\n',
   '        # for pushd/popd management\n',
   '        self.home_dir = get_home_dir()\n',
   '\n',
   '        self.dir_stack = []\n',
   '\n',
   '    def init_logger(self):\n',
   "        self.logger = Logger(self.home_dir, logfname='ipython_log.py',\n",
   "                             logmode='rotate')\n",
   '\n',
   '    def init_logstart(self):\n',
   '        """Initialize logging in case it was requested at the command line.\n',
   '        """\n',
   '        if self.logappend:\n',
   "            self.magic('logstart %s append' % self.logappend)\n",
   '        elif self.logfile:\n',
   "            self.magic('logstart %s' % self.logfile)\n",
   '        elif self.logstart:\n',
   "            self.magic('logstart')\n",
   '\n',
   '    def init_deprecation_warnings(self):\n',
   '        """\n',
   '        register default filter for deprecation warning.\n',
   '\n',
   '        This will allow deprecation warning of function used interactively to show\n',
   '        warning to users, and still hide deprecation warning from libraries import.\n',
   '        """\n',
   '        warnings.filterwarnings("default", category=DeprecationWarning, module=self.user_ns.get("__name__"))\n',
   '\n',
   '    def init_builtins(self):\n',
   '        # A single, static flag that we set to True.  Its presence indicates\n',
   '        # that an IPython shell has been created, and we make no attempts at\n',
   '        # removing on exit or representing the existence of more than one\n',
   '        # IPython at a time.\n',
   "        builtin_mod.__dict__['__IPYTHON__'] = True\n",
   '\n',
   "        # In 0.11 we introduced '__IPYTHON__active' as an integer we'd try to\n",
   "        # manage on enter/exit, but with all our shells it's virtually\n",
   "        # impossible to get all the cases right.  We're leaving the name in for\n",
   '        # those who adapted their codes to check for this flag, but will\n',
   '        # eventually remove it after a few more releases.\n',
   "        builtin_mod.__dict__['__IPYTHON__active'] = \\\n",
   "                                          'Deprecated, check for __IPYTHON__'\n",
   '\n',
   '        self.builtin_trap = BuiltinTrap(shell=self)\n',
   '\n',
   '    def init_inspector(self):\n',
   '        # Object inspector\n',
   '        self.inspector = oinspect.Inspector(oinspect.InspectColors,\n',
   '                                            PyColorize.ANSICodeColors,\n',
   "                                            'NoColor',\n",
   '                                            self.object_info_string_level)\n',
   '\n',
   '    def init_io(self):\n',
   '        # This will just use sys.stdout and sys.stderr. If you want to\n',
   '        # override sys.stdout and sys.stderr themselves, you need to do that\n',
   '        # *before* instantiating this class, because io holds onto\n',
   '        # references to the underlying streams.\n',
   "        if (sys.platform == 'win32' or sys.platform == 'cli') and self.has_readline:\n",
   '            io.stdout = io.stderr = io.IOStream(self.readline._outputfile)\n',
   '        else:\n',
   '            io.stdout = io.IOStream(sys.stdout)\n',
   '            io.stderr = io.IOStream(sys.stderr)\n',
   '\n',
   '    def init_prompts(self):\n',
   '        self.prompt_manager = PromptManager(shell=self, parent=self)\n',
   '        self.configurables.append(self.prompt_manager)\n',
   '        # Set system prompts, so that scripts can decide if they are running\n',
   '        # interactively.\n',
   "        sys.ps1 = 'In : '\n",
   "        sys.ps2 = '...: '\n",
   "        sys.ps3 = 'Out: '\n",
   '\n',
   '    def init_display_formatter(self):\n',
   '        self.display_formatter = DisplayFormatter(parent=self)\n',
   '        self.configurables.append(self.display_formatter)\n',
   '\n',
   '    def init_display_pub(self):\n',
   '        self.display_pub = self.display_pub_class(parent=self)\n',
   '        self.configurables.append(self.display_pub)\n',
   '\n',
   '    def init_data_pub(self):\n',
   '        if not self.data_pub_class:\n',
   '            self.data_pub = None\n',
   '            return\n',
   '        self.data_pub = self.data_pub_class(parent=self)\n',
   '        self.configurables.append(self.data_pub)\n',
   '\n',
   '    def init_displayhook(self):\n',
   '        # Initialize displayhook, set in/out prompts and printing system\n',
   '        self.displayhook = self.displayhook_class(\n',
   '            parent=self,\n',
   '            shell=self,\n',
   '            cache_size=self.cache_size,\n',
   '        )\n',
   '        self.configurables.append(self.displayhook)\n',
   '        # This is a context manager that installs/revmoes the displayhook at\n',
   '        # the appropriate time.\n',
   '        self.display_trap = DisplayTrap(hook=self.displayhook)\n',
   '\n',
   '    def init_virtualenv(self):\n',
   '        """Add a virtualenv to sys.path so the user can import modules from it.\n',
   "        This isn't perfect: it doesn't use the Python interpreter with which the\n",
   '        virtualenv was built, and it ignores the --no-site-packages option. A\n',
   '        warning will appear suggesting the user installs IPython in the\n',
   '        virtualenv, but for many cases, it probably works well enough.\n',
   '        \n',
   '        Adapted from code snippets online.\n',
   '        \n',
   '        http://blog.ufsoft.org/2009/1/29/ipython-and-virtualenv\n',
   '        """\n',
   "        if 'VIRTUAL_ENV' not in os.environ:\n",
   '            # Not in a virtualenv\n',
   '            return\n',
   '        \n',
   '        # venv detection:\n',
   "        # stdlib venv may symlink sys.executable, so we can't use realpath.\n",
   "        # but others can symlink *to* the venv Python, so we can't just use sys.executable.\n",
   '        # So we just check every item in the symlink tree (generally <= 3)\n',
   '        p = os.path.normcase(sys.executable)\n',
   '        paths = [p]\n',
   '        while os.path.islink(p):\n',
   '            p = os.path.normcase(os.path.join(os.path.dirname(p), os.readlink(p)))\n',
   '            paths.append(p)\n',
   "        p_venv = os.path.normcase(os.environ['VIRTUAL_ENV'])\n",
   '        if any(p.startswith(p_venv) for p in paths):\n',
   "            # Running properly in the virtualenv, don't need to do anything\n",
   '            return\n',
   '        \n',
   '        warn("Attempting to work in a virtualenv. If you encounter problems, please "\n',
   '             "install IPython inside the virtualenv.")\n',
   '        if sys.platform == "win32":\n',
   "            virtual_env = os.path.join(os.environ['VIRTUAL_ENV'], 'Lib', 'site-packages') \n",
   '        else:\n',
   "            virtual_env = os.path.join(os.environ['VIRTUAL_ENV'], 'lib',\n",
   "                       'python%d.%d' % sys.version_info[:2], 'site-packages')\n",
   '        \n',
   '        import site\n',
   '        sys.path.insert(0, virtual_env)\n',
   '        site.addsitedir(virtual_env)\n',
   '\n',
   '    #-------------------------------------------------------------------------\n',
   '    # Things related to injections into the sys module\n',
   '    #-------------------------------------------------------------------------\n',
   '\n',
   '    def save_sys_module_state(self):\n',
   '        """Save the state of hooks in the sys module.\n',
   '\n',
   '        This has to be called after self.user_module is created.\n',
   '        """\n',
   "        self._orig_sys_module_state = {'stdin': sys.stdin,\n",
   "                                       'stdout': sys.stdout,\n",
   "                                       'stderr': sys.stderr,\n",
   "                                       'excepthook': sys.excepthook}\n",
   '        self._orig_sys_modules_main_name = self.user_module.__name__\n',
   '        self._orig_sys_modules_main_mod = sys.modules.get(self.user_module.__name__)\n',
   '\n',
   '    def restore_sys_module_state(self):\n',
   '        """Restore the state of the sys module."""\n',
   '        try:\n',
   '            for k, v in iteritems(self._orig_sys_module_state):\n',
   '                setattr(sys, k, v)\n',
   '        except AttributeError:\n',
   '            pass\n',
   '        # Reset what what done in self.init_sys_modules\n',
   '        if self._orig_sys_modules_main_mod is not None:\n',
   '            sys.modules[self._orig_sys_modules_main_name] = self._orig_sys_modules_main_mod\n',
   '\n',
   '    #-------------------------------------------------------------------------\n',
   '    # Things related to the banner\n',
   '    #-------------------------------------------------------------------------\n',
   '    \n',
   '    @property\n',
   '    def banner(self):\n',
   '        banner = self.banner1\n',
   "        if self.profile and self.profile != 'default':\n",
   "            banner += '\\nIPython profile: %s\\n' % self.profile\n",
   '        if self.banner2:\n',
   "            banner += '\\n' + self.banner2\n",
   '        return banner\n',
   '\n',
   '    def show_banner(self, banner=None):\n',
   '        if banner is None:\n',
   '            banner = self.banner\n',
   '        self.write(banner)\n',
   '    \n',
   '    #-------------------------------------------------------------------------\n',
   '    # Things related to hooks\n',
   '    #-------------------------------------------------------------------------\n',
   '\n',
   '    def init_hooks(self):\n',
   '        # hooks holds pointers used for user-side customizations\n',
   '        self.hooks = Struct()\n',
   '\n',
   '        self.strdispatchers = {}\n',
   '\n',
   '        # Set all default hooks, defined in the IPython.hooks module.\n',
   '        hooks = IPython.core.hooks\n',
   '        for hook_name in hooks.__all__:\n',
   '            # default hooks have priority 100, i.e. low; user hooks should have\n',
   '            # 0-100 priority\n',
   '            self.set_hook(hook_name,getattr(hooks,hook_name), 100, _warn_deprecated=False)\n',
   '        \n',
   '        if self.display_page:\n',
   "            self.set_hook('show_in_pager', page.as_hook(page.display_page), 90)\n",
   '    \n',
   '    def set_hook(self,name,hook, priority=50, str_key=None, re_key=None,\n',
   '                 _warn_deprecated=True):\n',
   '        """set_hook(name,hook) -> sets an internal IPython hook.\n',
   '\n',
   '        IPython exposes some of its internal API as user-modifiable hooks.  By\n',
   "        adding your function to one of these hooks, you can modify IPython's\n",
   '        behavior to call at runtime your own routines."""\n',
   '\n',
   '        # At some point in the future, this should validate the hook before it\n',
   '        # accepts it.  Probably at least check that the hook takes the number\n',
   "        # of args it's supposed to.\n",
   '\n',
   '        f = types.MethodType(hook,self)\n',
   '\n',
   '        # check if the hook is for strdispatcher first\n',
   '        if str_key is not None:\n',
   '            sdp = self.strdispatchers.get(name, StrDispatch())\n',
   '            sdp.add_s(str_key, f, priority )\n',
   '            self.strdispatchers[name] = sdp\n',
   '            return\n',
   '        if re_key is not None:\n',
   '            sdp = self.strdispatchers.get(name, StrDispatch())\n',
   '            sdp.add_re(re.compile(re_key), f, priority )\n',
   '            self.strdispatchers[name] = sdp\n',
   '            return\n',
   '\n',
   '        dp = getattr(self.hooks, name, None)\n',
   '        if name not in IPython.core.hooks.__all__:\n',
   '            print("Warning! Hook \'%s\' is not one of %s" % \\\n',
   '                  (name, IPython.core.hooks.__all__ ))\n',
   '\n',
   '        if _warn_deprecated and (name in IPython.core.hooks.deprecated):\n',
   '            alternative = IPython.core.hooks.deprecated[name]\n',
   '            warn("Hook {} is deprecated. Use {} instead.".format(name, alternative))\n',
   '\n',
   '        if not dp:\n',
   '            dp = IPython.core.hooks.CommandChainDispatcher()\n',
   '\n',
   '        try:\n',
   '            dp.add(f,priority)\n',
   '        except AttributeError:\n',
   '            # it was not commandchain, plain old func - replace\n',
   '            dp = f\n',
   '\n',
   '        setattr(self.hooks,name, dp)\n',
   '\n',
   '    #-------------------------------------------------------------------------\n',
   '    # Things related to events\n',
   '    #-------------------------------------------------------------------------\n',
   '\n',
   '    def init_events(self):\n',
   '        self.events = EventManager(self, available_events)\n',
   '\n',
   '        self.events.register("pre_execute", self._clear_warning_registry)\n',
   '\n',
   '    def register_post_execute(self, func):\n',
   '        """DEPRECATED: Use ip.events.register(\'post_run_cell\', func)\n',
   '        \n',
   '        Register a function for calling after code execution.\n',
   '        """\n',
   '        warn("ip.register_post_execute is deprecated, use "\n',
   '             "ip.events.register(\'post_run_cell\', func) instead.")\n',
   "        self.events.register('post_run_cell', func)\n",
   '    \n',
   '    def _clear_warning_registry(self):\n',
   '        # clear the warning registry, so that different code blocks with\n',
   "        # overlapping line number ranges don't cause spurious suppression of\n",
   '        # warnings (see gh-6611 for details)\n',
   '        if "__warningregistry__" in self.user_global_ns:\n',
   '            del self.user_global_ns["__warningregistry__"]\n',
   '\n',
   '    #-------------------------------------------------------------------------\n',
   '    # Things related to the "main" module\n',
   '    #-------------------------------------------------------------------------\n',
   '\n',
   '    def new_main_mod(self, filename, modname):\n',
   '        """Return a new \'main\' module object for user code execution.\n',
   '        \n',
   '        ``filename`` should be the path of the script which will be run in the\n',
   '        module. Requests with the same filename will get the same module, with\n',
   '        its namespace cleared.\n',
   '        \n',
   "        ``modname`` should be the module name - normally either '__main__' or\n",
   '        the basename of the file without the extension.\n',
   '        \n',
   '        When scripts are executed via %run, we must keep a reference to their\n',
   "        __main__ module around so that Python doesn't\n",
   '        clear it, rendering references to module globals useless.\n',
   '\n',
   '        This method keeps said reference in a private dict, keyed by the\n',
   '        absolute path of the script. This way, for multiple executions of the\n',
   '        same script we only keep one copy of the namespace (the last one),\n',
   '        thus preventing memory leaks from old references while allowing the\n',
   '        objects from the last execution to be accessible.\n',
   '        """\n',
   '        filename = os.path.abspath(filename)\n',
   '        try:\n',
   '            main_mod = self._main_mod_cache[filename]\n',
   '        except KeyError:\n',
   '            main_mod = self._main_mod_cache[filename] = types.ModuleType(\n',
   '                        py3compat.cast_bytes_py2(modname),\n',
   '                        doc="Module created for script run in IPython")\n',
   '        else:\n',
   '            main_mod.__dict__.clear()\n',
   '            main_mod.__name__ = modname\n',
   '        \n',
   '        main_mod.__file__ = filename\n',
   '        # It seems pydoc (and perhaps others) needs any module instance to\n',
   '        # implement a __nonzero__ method\n',
   '        main_mod.__nonzero__ = lambda : True\n',
   '        \n',
   '        return main_mod\n',
   '\n',
   '    def clear_main_mod_cache(self):\n',
   '        """Clear the cache of main modules.\n',
   '\n',
   '        Mainly for use by utilities like %reset.\n',
   '\n',
   '        Examples\n',
   '        --------\n',
   '\n',
   '        In [15]: import IPython\n',
   '\n',
   "        In [16]: m = _ip.new_main_mod(IPython.__file__, 'IPython')\n",
   '\n',
   '        In [17]: len(_ip._main_mod_cache) > 0\n',
   '        Out[17]: True\n',
   '\n',
   '        In [18]: _ip.clear_main_mod_cache()\n',
   '\n',
   '        In [19]: len(_ip._main_mod_cache) == 0\n',
   '        Out[19]: True\n',
   '        """\n',
   '        self._main_mod_cache.clear()\n',
   '\n',
   '    #-------------------------------------------------------------------------\n',
   '    # Things related to debugging\n',
   '    #-------------------------------------------------------------------------\n',
   '\n',
   '    def init_pdb(self):\n',
   '        # Set calling of pdb on exceptions\n',
   '        # self.call_pdb is a property\n',
   '        self.call_pdb = self.pdb\n',
   '\n',
   '    def _get_call_pdb(self):\n',
   '        return self._call_pdb\n',
   '\n',
   '    def _set_call_pdb(self,val):\n',
   '\n',
   '        if val not in (0,1,False,True):\n',
   "            raise ValueError('new call_pdb value must be boolean')\n",
   '\n',
   '        # store value in instance\n',
   '        self._call_pdb = val\n',
   '\n',
   '        # notify the actual exception handlers\n',
   '        self.InteractiveTB.call_pdb = val\n',
   '\n',
   '    call_pdb = property(_get_call_pdb,_set_call_pdb,None,\n',
   "                        'Control auto-activation of pdb at exceptions')\n",
   '\n',
   '    def debugger(self,force=False):\n',
   '        """Call the pydb/pdb debugger.\n',
   '\n',
   '        Keywords:\n',
   '\n',
   '          - force(False): by default, this routine checks the instance call_pdb\n',
   '            flag and does not actually invoke the debugger if the flag is false.\n',
   "            The 'force' option forces the debugger to activate even if the flag\n",
   '            is false.\n',
   '        """\n',
   '\n',
   '        if not (force or self.call_pdb):\n',
   '            return\n',
   '\n',
   "        if not hasattr(sys,'last_traceback'):\n",
   "            error('No traceback has been produced, nothing to debug.')\n",
   '            return\n',
   '\n',
   '        # use pydb if available\n',
   '        if debugger.has_pydb:\n',
   '            from pydb import pm\n',
   '        else:\n',
   '            # fallback to our internal debugger\n',
   '            pm = lambda : self.InteractiveTB.debugger(force=True)\n',
   '\n',
   ...],
  '/home/pasha/.local/lib/python3.4/site-packages/IPython/core/interactiveshell.py'),
 <IPython.core.compilerop.CachingCompiler at 0x7f51c124b748>,
 {},
 [],
 [],
 <module '__main__'>,
 {'In': ['',
   'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
   'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
   'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
   "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   'def pick(l: list, index: int) -> int:\n    return l[index]',
   'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
   'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
   'pick([1, 2, 3], 2)',
   "pick([1, 2, 3], '2')",
   'import gc',
   'import gc\nпс',
   'import gc\ngc',
   'import gc\ngc.garbage',
   'gc.get_objects()'],
  'Out': {14: 3, 15: 3, 19: <module 'gc' (built-in)>, 20: []},
  '_': [],
  '_14': 3,
  '_15': 3,
  '_19': <module 'gc' (built-in)>,
  '_20': [],
  '__': <module 'gc' (built-in)>,
  '___': 3,
  '__builtin__': <module 'builtins' (built-in)>,
  '__builtins__': <module 'builtins' (built-in)>,
  '__doc__': 'Automatically created module for IPython interactive environment',
  '__loader__': None,
  '__name__': '__main__',
  '__package__': None,
  '__spec__': None,
  '_dh': ['/home/pasha/machine-learning.coursera/LearnInProgress/final.assignment/Kaggle'],
  '_i': 'import gc\ngc.garbage',
  '_i1': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
  '_i10': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
  '_i11': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
  '_i12': 'def pick(l: list, index: int) -> int:\n    return l[index]',
  '_i13': 'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
  '_i14': 'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
  '_i15': 'pick([1, 2, 3], 2)',
  '_i16': "pick([1, 2, 3], '2')",
  '_i17': 'import gc',
  '_i18': 'import gc\nпс',
  '_i19': 'import gc\ngc',
  '_i2': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
  '_i20': 'import gc\ngc.garbage',
  '_i21': 'gc.get_objects()',
  '_i3': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
  '_i4': "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
  '_i5': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
  '_i6': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
  '_i7': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
  '_i8': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
  '_i9': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
  '_ih': ['',
   'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
   'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
   'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
   "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   'def pick(l: list, index: int) -> int:\n    return l[index]',
   'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
   'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
   'pick([1, 2, 3], 2)',
   "pick([1, 2, 3], '2')",
   'import gc',
   'import gc\nпс',
   'import gc\ngc',
   'import gc\ngc.garbage',
   'gc.get_objects()'],
  '_ii': 'import gc\ngc',
  '_iii': 'import gc\nпс',
  '_oh': {14: 3, 15: 3, 19: <module 'gc' (built-in)>, 20: []},
  '_sh': <module 'IPython.core.shadowns' from '/home/pasha/.local/lib/python3.4/site-packages/IPython/core/shadowns.py'>,
  'exit': <IPython.core.autocall.ZMQExitAutocall at 0x7f51c016ef98>,
  'gc': <module 'gc' (built-in)>,
  'get_ipython': <bound method ZMQInteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>,
  'pick': <function __main__.pick>,
  'quit': <IPython.core.autocall.ZMQExitAutocall at 0x7f51c016ef98>,
  'v': 3,
  'x': {1: False, 3: True}},
 {'builtin': {'ArithmeticError': ArithmeticError,
   'AssertionError': AssertionError,
   'AttributeError': AttributeError,
   'BaseException': BaseException,
   'BlockingIOError': BlockingIOError,
   'BrokenPipeError': BrokenPipeError,
   'BufferError': BufferError,
   'BytesWarning': BytesWarning,
   'ChildProcessError': ChildProcessError,
   'ConnectionAbortedError': ConnectionAbortedError,
   'ConnectionError': ConnectionError,
   'ConnectionRefusedError': ConnectionRefusedError,
   'ConnectionResetError': ConnectionResetError,
   'DeprecationWarning': DeprecationWarning,
   'EOFError': EOFError,
   'Ellipsis': Ellipsis,
   'EnvironmentError': OSError,
   'Exception': Exception,
   'False': False,
   'FileExistsError': FileExistsError,
   'FileNotFoundError': FileNotFoundError,
   'FloatingPointError': FloatingPointError,
   'FutureWarning': FutureWarning,
   'GeneratorExit': GeneratorExit,
   'IOError': OSError,
   'ImportError': ImportError,
   'ImportWarning': ImportWarning,
   'IndentationError': IndentationError,
   'IndexError': IndexError,
   'InterruptedError': InterruptedError,
   'IsADirectoryError': IsADirectoryError,
   'KeyError': KeyError,
   'KeyboardInterrupt': KeyboardInterrupt,
   'LookupError': LookupError,
   'MemoryError': MemoryError,
   'NameError': NameError,
   'None': None,
   'NotADirectoryError': NotADirectoryError,
   'NotImplemented': NotImplemented,
   'NotImplementedError': NotImplementedError,
   'OSError': OSError,
   'OverflowError': OverflowError,
   'PendingDeprecationWarning': PendingDeprecationWarning,
   'PermissionError': PermissionError,
   'ProcessLookupError': ProcessLookupError,
   'ReferenceError': ReferenceError,
   'ResourceWarning': ResourceWarning,
   'RuntimeError': RuntimeError,
   'RuntimeWarning': RuntimeWarning,
   'StopIteration': StopIteration,
   'SyntaxError': SyntaxError,
   'SyntaxWarning': SyntaxWarning,
   'SystemError': SystemError,
   'SystemExit': SystemExit,
   'TabError': TabError,
   'TimeoutError': TimeoutError,
   'True': True,
   'TypeError': TypeError,
   'UnboundLocalError': UnboundLocalError,
   'UnicodeDecodeError': UnicodeDecodeError,
   'UnicodeEncodeError': UnicodeEncodeError,
   'UnicodeError': UnicodeError,
   'UnicodeTranslateError': UnicodeTranslateError,
   'UnicodeWarning': UnicodeWarning,
   'UserWarning': UserWarning,
   'ValueError': ValueError,
   'Warning': Warning,
   'ZeroDivisionError': ZeroDivisionError,
   '__IPYTHON__': True,
   '__IPYTHON__active': 'Deprecated, check for __IPYTHON__',
   '__build_class__': <function __build_class__>,
   '__debug__': True,
   '__doc__': "Built-in functions, exceptions, and other objects.\n\nNoteworthy: None is the `nil' object; Ellipsis represents `...' in slices.",
   '__import__': <function __import__>,
   '__loader__': _frozen_importlib.BuiltinImporter,
   '__name__': 'builtins',
   '__package__': '',
   '__spec__': ModuleSpec(name='builtins', loader=<class '_frozen_importlib.BuiltinImporter'>),
   'abs': <function abs>,
   'all': <function all>,
   'any': <function any>,
   'ascii': <function ascii>,
   'bin': <function bin>,
   'bool': bool,
   'bytearray': bytearray,
   'bytes': bytes,
   'callable': <function callable>,
   'chr': <function chr>,
   'classmethod': classmethod,
   'compile': <function compile>,
   'complex': complex,
   'copyright': Copyright (c) 2001-2015 Python Software Foundation.
   All Rights Reserved.
   
   Copyright (c) 2000 BeOpen.com.
   All Rights Reserved.
   
   Copyright (c) 1995-2001 Corporation for National Research Initiatives.
   All Rights Reserved.
   
   Copyright (c) 1991-1995 Stichting Mathematisch Centrum, Amsterdam.
   All Rights Reserved.,
   'credits':     Thanks to CWI, CNRI, BeOpen.com, Zope Corporation and a cast of thousands
       for supporting Python development.  See www.python.org for more information.,
   'delattr': <function delattr>,
   'dict': dict,
   'dir': <function dir>,
   'divmod': <function divmod>,
   'dreload': <function IPython.lib.deepreload._dreload>,
   'enumerate': enumerate,
   'eval': <function eval>,
   'exec': <function exec>,
   'filter': filter,
   'float': float,
   'format': <function format>,
   'frozenset': frozenset,
   'get_ipython': <bound method ZMQInteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>,
   'getattr': <function getattr>,
   'globals': <function globals>,
   'hasattr': <function hasattr>,
   'hash': <function hash>,
   'help': Type help() for interactive help, or help(object) for help about object.,
   'hex': <function hex>,
   'id': <function id>,
   'input': <bound method IPythonKernel.raw_input of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
   'int': int,
   'isinstance': <function isinstance>,
   'issubclass': <function issubclass>,
   'iter': <function iter>,
   'len': <function len>,
   'license': See https://www.python.org/psf/license/,
   'list': list,
   'locals': <function locals>,
   'map': map,
   'max': <function max>,
   'memoryview': memoryview,
   'min': <function min>,
   'next': <function next>,
   'object': object,
   'oct': <function oct>,
   'open': <function io.open>,
   'ord': <function ord>,
   'pow': <function pow>,
   'print': <function print>,
   'property': property,
   'range': range,
   'repr': <function repr>,
   'reversed': reversed,
   'round': <function round>,
   'set': set,
   'setattr': <function setattr>,
   'slice': slice,
   'sorted': <function sorted>,
   'staticmethod': staticmethod,
   'str': str,
   'sum': <function sum>,
   'super': super,
   'tuple': tuple,
   'type': type,
   'vars': <function vars>,
   'zip': zip},
  'user_global': {'In': ['',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
    "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    'def pick(l: list, index: int) -> int:\n    return l[index]',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
    'pick([1, 2, 3], 2)',
    "pick([1, 2, 3], '2')",
    'import gc',
    'import gc\nпс',
    'import gc\ngc',
    'import gc\ngc.garbage',
    'gc.get_objects()'],
   'Out': {14: 3, 15: 3, 19: <module 'gc' (built-in)>, 20: []},
   '_': [],
   '_14': 3,
   '_15': 3,
   '_19': <module 'gc' (built-in)>,
   '_20': [],
   '__': <module 'gc' (built-in)>,
   '___': 3,
   '__builtin__': <module 'builtins' (built-in)>,
   '__builtins__': <module 'builtins' (built-in)>,
   '__doc__': 'Automatically created module for IPython interactive environment',
   '__loader__': None,
   '__name__': '__main__',
   '__package__': None,
   '__spec__': None,
   '_dh': ['/home/pasha/machine-learning.coursera/LearnInProgress/final.assignment/Kaggle'],
   '_i': 'import gc\ngc.garbage',
   '_i1': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
   '_i10': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_i11': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   '_i12': 'def pick(l: list, index: int) -> int:\n    return l[index]',
   '_i13': 'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
   '_i14': 'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
   '_i15': 'pick([1, 2, 3], 2)',
   '_i16': "pick([1, 2, 3], '2')",
   '_i17': 'import gc',
   '_i18': 'import gc\nпс',
   '_i19': 'import gc\ngc',
   '_i2': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
   '_i20': 'import gc\ngc.garbage',
   '_i21': 'gc.get_objects()',
   '_i3': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
   '_i4': "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   '_i5': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   '_i6': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_i7': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_i8': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_i9': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_ih': ['',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
    "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    'def pick(l: list, index: int) -> int:\n    return l[index]',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
    'pick([1, 2, 3], 2)',
    "pick([1, 2, 3], '2')",
    'import gc',
    'import gc\nпс',
    'import gc\ngc',
    'import gc\ngc.garbage',
    'gc.get_objects()'],
   '_ii': 'import gc\ngc',
   '_iii': 'import gc\nпс',
   '_oh': {14: 3, 15: 3, 19: <module 'gc' (built-in)>, 20: []},
   '_sh': <module 'IPython.core.shadowns' from '/home/pasha/.local/lib/python3.4/site-packages/IPython/core/shadowns.py'>,
   'exit': <IPython.core.autocall.ZMQExitAutocall at 0x7f51c016ef98>,
   'gc': <module 'gc' (built-in)>,
   'get_ipython': <bound method ZMQInteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>,
   'pick': <function __main__.pick>,
   'quit': <IPython.core.autocall.ZMQExitAutocall at 0x7f51c016ef98>,
   'v': 3,
   'x': {1: False, 3: True}},
  'user_local': {'In': ['',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
    "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    'def pick(l: list, index: int) -> int:\n    return l[index]',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
    'pick([1, 2, 3], 2)',
    "pick([1, 2, 3], '2')",
    'import gc',
    'import gc\nпс',
    'import gc\ngc',
    'import gc\ngc.garbage',
    'gc.get_objects()'],
   'Out': {14: 3, 15: 3, 19: <module 'gc' (built-in)>, 20: []},
   '_': [],
   '_14': 3,
   '_15': 3,
   '_19': <module 'gc' (built-in)>,
   '_20': [],
   '__': <module 'gc' (built-in)>,
   '___': 3,
   '__builtin__': <module 'builtins' (built-in)>,
   '__builtins__': <module 'builtins' (built-in)>,
   '__doc__': 'Automatically created module for IPython interactive environment',
   '__loader__': None,
   '__name__': '__main__',
   '__package__': None,
   '__spec__': None,
   '_dh': ['/home/pasha/machine-learning.coursera/LearnInProgress/final.assignment/Kaggle'],
   '_i': 'import gc\ngc.garbage',
   '_i1': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
   '_i10': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_i11': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   '_i12': 'def pick(l: list, index: int) -> int:\n    return l[index]',
   '_i13': 'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
   '_i14': 'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
   '_i15': 'pick([1, 2, 3], 2)',
   '_i16': "pick([1, 2, 3], '2')",
   '_i17': 'import gc',
   '_i18': 'import gc\nпс',
   '_i19': 'import gc\ngc',
   '_i2': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
   '_i20': 'import gc\ngc.garbage',
   '_i21': 'gc.get_objects()',
   '_i3': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
   '_i4': "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   '_i5': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   '_i6': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_i7': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_i8': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_i9': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_ih': ['',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
    "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    'def pick(l: list, index: int) -> int:\n    return l[index]',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
    'pick([1, 2, 3], 2)',
    "pick([1, 2, 3], '2')",
    'import gc',
    'import gc\nпс',
    'import gc\ngc',
    'import gc\ngc.garbage',
    'gc.get_objects()'],
   '_ii': 'import gc\ngc',
   '_iii': 'import gc\nпс',
   '_oh': {14: 3, 15: 3, 19: <module 'gc' (built-in)>, 20: []},
   '_sh': <module 'IPython.core.shadowns' from '/home/pasha/.local/lib/python3.4/site-packages/IPython/core/shadowns.py'>,
   'exit': <IPython.core.autocall.ZMQExitAutocall at 0x7f51c016ef98>,
   'gc': <module 'gc' (built-in)>,
   'get_ipython': <bound method ZMQInteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>,
   'pick': <function __main__.pick>,
   'quit': <IPython.core.autocall.ZMQExitAutocall at 0x7f51c016ef98>,
   'v': 3,
   'x': {1: False, 3: True}}},
 {'excepthook': <bound method IPKernelApp.excepthook of <ipykernel.kernelapp.IPKernelApp object at 0x7f51d2a1ac18>>,
  'stderr': <ipykernel.iostream.OutStream at 0x7f51c1221b38>,
  'stdin': <_io.TextIOWrapper name='<stdin>' mode='r' encoding='UTF-8'>,
  'stdout': <ipykernel.iostream.OutStream at 0x7f51c1221b70>},
 PickleShareDB('/home/pasha/.ipython/profile_default/db'),
 {'cache': {}, 'root': Path('/home/pasha/.ipython/profile_default/db')},
 <IPython.core.history.HistoryManager at 0x7f51c1221710>,
 {'_cross_validation_lock': False,
  '_trait_notifiers': {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
  '_trait_validators': {},
  '_trait_values': {'_i': 'import gc\ngc.garbage',
   '_i00': 'gc.get_objects()',
   '_ii': 'import gc\ngc',
   '_iii': 'import gc\nпс',
   'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
   'connection_options': {},
   'db': <sqlite3.Connection at 0x7f51c12c0e30>,
   'db_cache_size': 0,
   'db_input_cache': [],
   'db_log_output': False,
   'db_output_cache': [],
   'dir_hist': ['/home/pasha/machine-learning.coursera/LearnInProgress/final.assignment/Kaggle'],
   'enabled': True,
   'hist_file': '/home/pasha/.ipython/profile_default/history.sqlite',
   'input_hist_parsed': ['',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
    "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    'def pick(l: list, index: int) -> int:\n    return l[index]',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
    'pick([1, 2, 3], 2)',
    "pick([1, 2, 3], '2')",
    'import gc',
    'import gc\nпс',
    'import gc\ngc',
    'import gc\ngc.garbage',
    'gc.get_objects()'],
   'input_hist_raw': ['',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
    "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    'def pick(l: list, index: int) -> int:\n    return l[index]',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
    'pick([1, 2, 3], 2)',
    "pick([1, 2, 3], '2')",
    'import gc',
    'import gc\nпс',
    'import gc\ngc',
    'import gc\ngc.garbage',
    'gc.get_objects()'],
   'output_hist': {14: 3, 15: 3, 19: <module 'gc' (built-in)>, 20: []},
   'output_hist_reprs': {14: '3',
    15: '3',
    19: "<module 'gc' (built-in)>",
    20: '[]'},
   'parent': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>,
   'save_flag': <threading.Event at 0x7f51c016e0f0>,
   'save_thread': <HistorySavingThread(IPythonHistorySavingThread, started 139988989622016)>,
   'session_number': 291,
   'shell': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>},
  'db_input_cache_lock': <_thread.lock at 0x7f51c12897d8>,
  'db_output_cache_lock': <_thread.lock at 0x7f51c1289aa8>},
 {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
 (31768,
  1457880499.8372402,
  ['""" History related magics and functionality """\n',
   '#-----------------------------------------------------------------------------\n',
   '#  Copyright (C) 2010-2011 The IPython Development Team.\n',
   '#\n',
   '#  Distributed under the terms of the BSD License.\n',
   '#\n',
   '#  The full license is in the file COPYING.txt, distributed with this software.\n',
   '#-----------------------------------------------------------------------------\n',
   '\n',
   '#-----------------------------------------------------------------------------\n',
   '# Imports\n',
   '#-----------------------------------------------------------------------------\n',
   'from __future__ import print_function\n',
   '\n',
   '# Stdlib imports\n',
   'import atexit\n',
   'import datetime\n',
   'import os\n',
   'import re\n',
   'try:\n',
   '    import sqlite3\n',
   'except ImportError:\n',
   '    try:\n',
   '        from pysqlite2 import dbapi2 as sqlite3\n',
   '    except ImportError:\n',
   '        sqlite3 = None\n',
   'import threading\n',
   '\n',
   '# Our own packages\n',
   'from traitlets.config.configurable import Configurable\n',
   'from decorator import decorator\n',
   'from IPython.utils.decorators import undoc\n',
   'from IPython.utils.path import locate_profile\n',
   'from IPython.utils import py3compat\n',
   'from traitlets import (\n',
   '    Any, Bool, Dict, Instance, Integer, List, Unicode, TraitError,\n',
   ')\n',
   'from IPython.utils.warn import warn\n',
   '\n',
   '#-----------------------------------------------------------------------------\n',
   '# Classes and functions\n',
   '#-----------------------------------------------------------------------------\n',
   '\n',
   '@undoc\n',
   'class DummyDB(object):\n',
   '    """Dummy DB that will act as a black hole for history.\n',
   '    \n',
   '    Only used in the absence of sqlite"""\n',
   '    def execute(*args, **kwargs):\n',
   '        return []\n',
   '    \n',
   '    def commit(self, *args, **kwargs):\n',
   '        pass\n',
   '    \n',
   '    def __enter__(self, *args, **kwargs):\n',
   '        pass\n',
   '    \n',
   '    def __exit__(self, *args, **kwargs):\n',
   '        pass\n',
   '\n',
   '\n',
   '@decorator\n',
   'def needs_sqlite(f, self, *a, **kw):\n',
   '    """Decorator: return an empty list in the absence of sqlite."""\n',
   '    if sqlite3 is None or not self.enabled:\n',
   '        return []\n',
   '    else:\n',
   '        return f(self, *a, **kw)\n',
   '\n',
   '\n',
   'if sqlite3 is not None:\n',
   '    DatabaseError = sqlite3.DatabaseError\n',
   '    OperationalError = sqlite3.OperationalError\n',
   'else:\n',
   '    @undoc\n',
   '    class DatabaseError(Exception):\n',
   '        "Dummy exception when sqlite could not be imported. Should never occur."\n',
   '    \n',
   '    @undoc\n',
   '    class OperationalError(Exception):\n',
   '        "Dummy exception when sqlite could not be imported. Should never occur."\n',
   '\n',
   '@decorator\n',
   'def catch_corrupt_db(f, self, *a, **kw):\n',
   '    """A decorator which wraps HistoryAccessor method calls to catch errors from\n',
   '    a corrupt SQLite database, move the old database out of the way, and create\n',
   '    a new one.\n',
   '    """\n',
   '    try:\n',
   '        return f(self, *a, **kw)\n',
   '    except (DatabaseError, OperationalError):\n',
   '        if os.path.isfile(self.hist_file):\n',
   '            # Try to move the file out of the way\n',
   '            base,ext = os.path.splitext(self.hist_file)\n',
   "            newpath = base + '-corrupt' + ext\n",
   '            os.rename(self.hist_file, newpath)\n',
   '            self.init_db()\n',
   '            print("ERROR! History file wasn\'t a valid SQLite database.",\n',
   '            "It was moved to %s" % newpath, "and a new file created.")\n',
   '            return []\n',
   '        \n',
   '        else:\n',
   '            # The hist_file is probably :memory: or something else.\n',
   '            raise\n',
   '        \n',
   'class HistoryAccessorBase(Configurable):\n',
   '    """An abstract class for History Accessors """\n',
   '\n',
   '    def get_tail(self, n=10, raw=True, output=False, include_latest=False):\n',
   '        raise NotImplementedError\n',
   '\n',
   '    def search(self, pattern="*", raw=True, search_raw=True,\n',
   '               output=False, n=None, unique=False):\n',
   '        raise NotImplementedError\n',
   '\n',
   '    def get_range(self, session, start=1, stop=None, raw=True,output=False):\n',
   '        raise NotImplementedError\n',
   '\n',
   '    def get_range_by_str(self, rangestr, raw=True, output=False):\n',
   '        raise NotImplementedError\n',
   '\n',
   '\n',
   'class HistoryAccessor(HistoryAccessorBase):\n',
   '    """Access the history database without adding to it.\n',
   '    \n',
   '    This is intended for use by standalone history tools. IPython shells use\n',
   '    HistoryManager, below, which is a subclass of this."""\n',
   '\n',
   '    # String holding the path to the history file\n',
   '    hist_file = Unicode(config=True,\n',
   '        help="""Path to file to use for SQLite history database.\n',
   '        \n',
   '        By default, IPython will put the history database in the IPython\n',
   '        profile directory.  If you would rather share one history among\n',
   '        profiles, you can set this value in each, so that they are consistent.\n',
   '        \n',
   '        Due to an issue with fcntl, SQLite is known to misbehave on some NFS\n',
   '        mounts.  If you see IPython hanging, try setting this to something on a\n',
   '        local disk, e.g::\n',
   '        \n',
   '            ipython --HistoryManager.hist_file=/tmp/ipython_hist.sqlite\n',
   '        \n',
   '        """)\n',
   '    \n',
   '    enabled = Bool(True, config=True,\n',
   '        help="""enable the SQLite history\n',
   '        \n',
   '        set enabled=False to disable the SQLite history,\n',
   '        in which case there will be no stored history, no SQLite connection,\n',
   '        and no background saving thread.  This may be necessary in some\n',
   '        threaded environments where IPython is embedded.\n',
   '        """\n',
   '    )\n',
   '    \n',
   '    connection_options = Dict(config=True,\n',
   '        help="""Options for configuring the SQLite connection\n',
   '        \n',
   '        These options are passed as keyword args to sqlite3.connect\n',
   '        when establishing database conenctions.\n',
   '        """\n',
   '    )\n',
   '\n',
   '    # The SQLite database\n',
   '    db = Any()\n',
   '    def _db_changed(self, name, old, new):\n',
   '        """validate the db, since it can be an Instance of two different types"""\n',
   '        connection_types = (DummyDB,)\n',
   '        if sqlite3 is not None:\n',
   '            connection_types = (DummyDB, sqlite3.Connection)\n',
   '        if not isinstance(new, connection_types):\n',
   '            msg = "%s.db must be sqlite3 Connection or DummyDB, not %r" % \\\n',
   '                    (self.__class__.__name__, new)\n',
   '            raise TraitError(msg)\n',
   '    \n',
   "    def __init__(self, profile='default', hist_file=u'', **traits):\n",
   '        """Create a new history accessor.\n',
   '        \n',
   '        Parameters\n',
   '        ----------\n',
   '        profile : str\n',
   '          The name of the profile from which to open history.\n',
   '        hist_file : str\n',
   '          Path to an SQLite history database stored by IPython. If specified,\n',
   '          hist_file overrides profile.\n',
   '        config : :class:`~traitlets.config.loader.Config`\n',
   '          Config object. hist_file can also be set through this.\n',
   '        """\n',
   '        # We need a pointer back to the shell for various tasks.\n',
   '        super(HistoryAccessor, self).__init__(**traits)\n',
   '        # defer setting hist_file from kwarg until after init,\n',
   '        # otherwise the default kwarg value would clobber any value\n',
   '        # set by config\n',
   '        if hist_file:\n',
   '            self.hist_file = hist_file\n',
   '        \n',
   "        if self.hist_file == u'':\n",
   '            # No one has set the hist_file, yet.\n',
   '            self.hist_file = self._get_hist_file_name(profile)\n',
   '\n',
   '        if sqlite3 is None and self.enabled:\n',
   '            warn("IPython History requires SQLite, your history will not be saved")\n',
   '            self.enabled = False\n',
   '        \n',
   '        self.init_db()\n',
   '    \n',
   "    def _get_hist_file_name(self, profile='default'):\n",
   '        """Find the history file for the given profile name.\n',
   '        \n',
   "        This is overridden by the HistoryManager subclass, to use the shell's\n",
   '        active profile.\n',
   '        \n',
   '        Parameters\n',
   '        ----------\n',
   '        profile : str\n',
   '          The name of a profile which has a history file.\n',
   '        """\n',
   "        return os.path.join(locate_profile(profile), 'history.sqlite')\n",
   '    \n',
   '    @catch_corrupt_db\n',
   '    def init_db(self):\n',
   '        """Connect to the database, and create tables if necessary."""\n',
   '        if not self.enabled:\n',
   '            self.db = DummyDB()\n',
   '            return\n',
   '        \n',
   '        # use detect_types so that timestamps return datetime objects\n',
   '        kwargs = dict(detect_types=sqlite3.PARSE_DECLTYPES|sqlite3.PARSE_COLNAMES)\n',
   '        kwargs.update(self.connection_options)\n',
   '        self.db = sqlite3.connect(self.hist_file, **kwargs)\n',
   '        self.db.execute("""CREATE TABLE IF NOT EXISTS sessions (session integer\n',
   '                        primary key autoincrement, start timestamp,\n',
   '                        end timestamp, num_cmds integer, remark text)""")\n',
   '        self.db.execute("""CREATE TABLE IF NOT EXISTS history\n',
   '                (session integer, line integer, source text, source_raw text,\n',
   '                PRIMARY KEY (session, line))""")\n',
   "        # Output history is optional, but ensure the table's there so it can be\n",
   '        # enabled later.\n',
   '        self.db.execute("""CREATE TABLE IF NOT EXISTS output_history\n',
   '                        (session integer, line integer, output text,\n',
   '                        PRIMARY KEY (session, line))""")\n',
   '        self.db.commit()\n',
   '\n',
   '    def writeout_cache(self):\n',
   '        """Overridden by HistoryManager to dump the cache before certain\n',
   '        database lookups."""\n',
   '        pass\n',
   '\n',
   '    ## -------------------------------\n',
   '    ## Methods for retrieving history:\n',
   '    ## -------------------------------\n',
   '    def _run_sql(self, sql, params, raw=True, output=False):\n',
   '        """Prepares and runs an SQL query for the history database.\n',
   '\n',
   '        Parameters\n',
   '        ----------\n',
   '        sql : str\n',
   '          Any filtering expressions to go after SELECT ... FROM ...\n',
   '        params : tuple\n',
   '          Parameters passed to the SQL query (to replace "?")\n',
   '        raw, output : bool\n',
   '          See :meth:`get_range`\n',
   '\n',
   '        Returns\n',
   '        -------\n',
   '        Tuples as :meth:`get_range`\n',
   '        """\n',
   "        toget = 'source_raw' if raw else 'source'\n",
   '        sqlfrom = "history"\n',
   '        if output:\n',
   '            sqlfrom = "history LEFT JOIN output_history USING (session, line)"\n',
   '            toget = "history.%s, output_history.output" % toget\n',
   '        cur = self.db.execute("SELECT session, line, %s FROM %s " %\\\n',
   '                                (toget, sqlfrom) + sql, params)\n',
   '        if output:    # Regroup into 3-tuples, and parse JSON\n',
   '            return ((ses, lin, (inp, out)) for ses, lin, inp, out in cur)\n',
   '        return cur\n',
   '\n',
   '    @needs_sqlite\n',
   '    @catch_corrupt_db\n',
   '    def get_session_info(self, session):\n',
   '        """Get info about a session.\n',
   '\n',
   '        Parameters\n',
   '        ----------\n',
   '\n',
   '        session : int\n',
   '            Session number to retrieve.\n',
   '\n',
   '        Returns\n',
   '        -------\n',
   '        \n',
   '        session_id : int\n',
   '           Session ID number\n',
   '        start : datetime\n',
   '           Timestamp for the start of the session.\n',
   '        end : datetime\n',
   '           Timestamp for the end of the session, or None if IPython crashed.\n',
   '        num_cmds : int\n',
   '           Number of commands run, or None if IPython crashed.\n',
   '        remark : unicode\n',
   '           A manually set description.\n',
   '        """\n',
   '        query = "SELECT * from sessions where session == ?"\n',
   '        return self.db.execute(query, (session,)).fetchone()\n',
   '\n',
   '    @catch_corrupt_db\n',
   '    def get_last_session_id(self):\n',
   '        """Get the last session ID currently in the database.\n',
   '        \n',
   '        Within IPython, this should be the same as the value stored in\n',
   '        :attr:`HistoryManager.session_number`.\n',
   '        """\n',
   '        for record in self.get_tail(n=1, include_latest=True):\n',
   '            return record[0]\n',
   '\n',
   '    @catch_corrupt_db\n',
   '    def get_tail(self, n=10, raw=True, output=False, include_latest=False):\n',
   '        """Get the last n lines from the history database.\n',
   '\n',
   '        Parameters\n',
   '        ----------\n',
   '        n : int\n',
   '          The number of lines to get\n',
   '        raw, output : bool\n',
   '          See :meth:`get_range`\n',
   '        include_latest : bool\n',
   '          If False (default), n+1 lines are fetched, and the latest one\n',
   '          is discarded. This is intended to be used where the function\n',
   '          is called by a user command, which it should not return.\n',
   '\n',
   '        Returns\n',
   '        -------\n',
   '        Tuples as :meth:`get_range`\n',
   '        """\n',
   '        self.writeout_cache()\n',
   '        if not include_latest:\n',
   '            n += 1\n',
   '        cur = self._run_sql("ORDER BY session DESC, line DESC LIMIT ?",\n',
   '                                (n,), raw=raw, output=output)\n',
   '        if not include_latest:\n',
   '            return reversed(list(cur)[1:])\n',
   '        return reversed(list(cur))\n',
   '\n',
   '    @catch_corrupt_db\n',
   '    def search(self, pattern="*", raw=True, search_raw=True,\n',
   '               output=False, n=None, unique=False):\n',
   '        """Search the database using unix glob-style matching (wildcards\n',
   '        * and ?).\n',
   '\n',
   '        Parameters\n',
   '        ----------\n',
   '        pattern : str\n',
   '          The wildcarded pattern to match when searching\n',
   '        search_raw : bool\n',
   '          If True, search the raw input, otherwise, the parsed input\n',
   '        raw, output : bool\n',
   '          See :meth:`get_range`\n',
   '        n : None or int\n',
   '          If an integer is given, it defines the limit of\n',
   '          returned entries.\n',
   '        unique : bool\n',
   '          When it is true, return only unique entries.\n',
   '\n',
   '        Returns\n',
   '        -------\n',
   '        Tuples as :meth:`get_range`\n',
   '        """\n',
   '        tosearch = "source_raw" if search_raw else "source"\n',
   '        if output:\n',
   '            tosearch = "history." + tosearch\n',
   '        self.writeout_cache()\n',
   '        sqlform = "WHERE %s GLOB ?" % tosearch\n',
   '        params = (pattern,)\n',
   '        if unique:\n',
   "            sqlform += ' GROUP BY {0}'.format(tosearch)\n",
   '        if n is not None:\n',
   '            sqlform += " ORDER BY session DESC, line DESC LIMIT ?"\n',
   '            params += (n,)\n',
   '        elif unique:\n',
   '            sqlform += " ORDER BY session, line"\n',
   '        cur = self._run_sql(sqlform, params, raw=raw, output=output)\n',
   '        if n is not None:\n',
   '            return reversed(list(cur))\n',
   '        return cur\n',
   '    \n',
   '    @catch_corrupt_db\n',
   '    def get_range(self, session, start=1, stop=None, raw=True,output=False):\n',
   '        """Retrieve input by session.\n',
   '\n',
   '        Parameters\n',
   '        ----------\n',
   '        session : int\n',
   '            Session number to retrieve.\n',
   '        start : int\n',
   '            First line to retrieve.\n',
   '        stop : int\n',
   '            End of line range (excluded from output itself). If None, retrieve\n',
   '            to the end of the session.\n',
   '        raw : bool\n',
   '            If True, return untranslated input\n',
   '        output : bool\n',
   "            If True, attempt to include output. This will be 'real' Python\n",
   '            objects for the current session, or text reprs from previous\n',
   '            sessions if db_log_output was enabled at the time. Where no output\n',
   '            is found, None is used.\n',
   '\n',
   '        Returns\n',
   '        -------\n',
   '        entries\n',
   '          An iterator over the desired lines. Each line is a 3-tuple, either\n',
   '          (session, line, input) if output is False, or\n',
   '          (session, line, (input, output)) if output is True.\n',
   '        """\n',
   '        if stop:\n',
   '            lineclause = "line >= ? AND line < ?"\n',
   '            params = (session, start, stop)\n',
   '        else:\n',
   '            lineclause = "line>=?"\n',
   '            params = (session, start)\n',
   '\n',
   '        return self._run_sql("WHERE session==? AND %s" % lineclause,\n',
   '                                    params, raw=raw, output=output)\n',
   '\n',
   '    def get_range_by_str(self, rangestr, raw=True, output=False):\n',
   '        """Get lines of history from a string of ranges, as used by magic\n',
   '        commands %hist, %save, %macro, etc.\n',
   '\n',
   '        Parameters\n',
   '        ----------\n',
   '        rangestr : str\n',
   '          A string specifying ranges, e.g. "5 ~2/1-4". See\n',
   '          :func:`magic_history` for full details.\n',
   '        raw, output : bool\n',
   '          As :meth:`get_range`\n',
   '\n',
   '        Returns\n',
   '        -------\n',
   '        Tuples as :meth:`get_range`\n',
   '        """\n',
   '        for sess, s, e in extract_hist_ranges(rangestr):\n',
   '            for line in self.get_range(sess, s, e, raw=raw, output=output):\n',
   '                yield line\n',
   '\n',
   '\n',
   'class HistoryManager(HistoryAccessor):\n',
   '    """A class to organize all history-related functionality in one place.\n',
   '    """\n',
   '    # Public interface\n',
   '\n',
   '    # An instance of the IPython shell we are attached to\n',
   "    shell = Instance('IPython.core.interactiveshell.InteractiveShellABC',\n",
   '                     allow_none=True)\n',
   '    # Lists to hold processed and raw history. These start with a blank entry\n',
   '    # so that we can index them starting from 1\n',
   '    input_hist_parsed = List([""])\n',
   '    input_hist_raw = List([""])\n',
   '    # A list of directories visited during session\n',
   '    dir_hist = List()\n',
   '    def _dir_hist_default(self):\n',
   '        try:\n',
   '            return [py3compat.getcwd()]\n',
   '        except OSError:\n',
   '            return []\n',
   '\n',
   "    # A dict of output history, keyed with ints from the shell's\n",
   '    # execution count.\n',
   '    output_hist = Dict()\n',
   '    # The text/plain repr of outputs.\n',
   '    output_hist_reprs = Dict()\n',
   '\n',
   '    # The number of the current session in the history database\n',
   '    session_number = Integer()\n',
   '    \n',
   '    db_log_output = Bool(False, config=True,\n',
   '        help="Should the history database include output? (default: no)"\n',
   '    )\n',
   '    db_cache_size = Integer(0, config=True,\n',
   '        help="Write to database every x commands (higher values save disk access & power).\\n"\n',
   '        "Values of 1 or less effectively disable caching."\n',
   '    )\n',
   '    # The input and output caches\n',
   '    db_input_cache = List()\n',
   '    db_output_cache = List()\n',
   '    \n',
   '    # History saving in separate thread\n',
   "    save_thread = Instance('IPython.core.history.HistorySavingThread',\n",
   '                           allow_none=True)\n',
   '    try:               # Event is a function returning an instance of _Event...\n',
   '        save_flag = Instance(threading._Event, allow_none=True)\n',
   "    except AttributeError:         # ...until Python 3.3, when it's a class.\n",
   '        save_flag = Instance(threading.Event, allow_none=True)\n',
   '    \n',
   '    # Private interface\n',
   '    # Variables used to store the three last inputs from the user.  On each new\n',
   "    # history update, we populate the user's namespace with these, shifted as\n",
   '    # necessary.\n',
   "    _i00 = Unicode(u'')\n",
   "    _i = Unicode(u'')\n",
   "    _ii = Unicode(u'')\n",
   "    _iii = Unicode(u'')\n",
   '\n',
   "    # A regex matching all forms of the exit command, so that we don't store\n",
   "    # them in the history (it's annoying to rewind the first entry and land on\n",
   '    # an exit call).\n',
   '    _exit_re = re.compile(r"(exit|quit)(\\s*\\(.*\\))?$")\n',
   '\n',
   '    def __init__(self, shell=None, config=None, **traits):\n',
   '        """Create a new history manager associated with a shell instance.\n',
   '        """\n',
   '        # We need a pointer back to the shell for various tasks.\n',
   '        super(HistoryManager, self).__init__(shell=shell, config=config,\n',
   '            **traits)\n',
   '        self.save_flag = threading.Event()\n',
   '        self.db_input_cache_lock = threading.Lock()\n',
   '        self.db_output_cache_lock = threading.Lock()\n',
   '        \n',
   '        try:\n',
   '            self.new_session()\n',
   '        except OperationalError:\n',
   '            self.log.error("Failed to create history session in %s. History will not be saved.",\n',
   '                self.hist_file, exc_info=True)\n',
   "            self.hist_file = ':memory:'\n",
   '        \n',
   "        if self.enabled and self.hist_file != ':memory:':\n",
   '            self.save_thread = HistorySavingThread(self)\n',
   '            self.save_thread.start()\n',
   '\n',
   '    def _get_hist_file_name(self, profile=None):\n',
   '        """Get default history file name based on the Shell\'s profile.\n',
   '        \n',
   '        The profile parameter is ignored, but must exist for compatibility with\n',
   '        the parent class."""\n',
   '        profile_dir = self.shell.profile_dir.location\n',
   "        return os.path.join(profile_dir, 'history.sqlite')\n",
   '    \n',
   '    @needs_sqlite\n',
   '    def new_session(self, conn=None):\n',
   '        """Get a new session number."""\n',
   '        if conn is None:\n',
   '            conn = self.db\n',
   '        \n',
   '        with conn:\n',
   '            cur = conn.execute("""INSERT INTO sessions VALUES (NULL, ?, NULL,\n',
   '                            NULL, "") """, (datetime.datetime.now(),))\n',
   '            self.session_number = cur.lastrowid\n',
   '            \n',
   '    def end_session(self):\n',
   '        """Close the database session, filling in the end time and line count."""\n',
   '        self.writeout_cache()\n',
   '        with self.db:\n',
   '            self.db.execute("""UPDATE sessions SET end=?, num_cmds=? WHERE\n',
   '                            session==?""", (datetime.datetime.now(),\n',
   '                            len(self.input_hist_parsed)-1, self.session_number))\n',
   '        self.session_number = 0\n',
   '                            \n',
   '    def name_session(self, name):\n',
   '        """Give the current session a name in the history database."""\n',
   '        with self.db:\n',
   '            self.db.execute("UPDATE sessions SET remark=? WHERE session==?",\n',
   '                            (name, self.session_number))\n',
   '                            \n',
   '    def reset(self, new_session=True):\n',
   '        """Clear the session history, releasing all object references, and\n',
   '        optionally open a new session."""\n',
   '        self.output_hist.clear()\n',
   "        # The directory history can't be completely empty\n",
   '        self.dir_hist[:] = [py3compat.getcwd()]\n',
   '        \n',
   '        if new_session:\n',
   '            if self.session_number:\n',
   '                self.end_session()\n',
   '            self.input_hist_parsed[:] = [""]\n',
   '            self.input_hist_raw[:] = [""]\n',
   '            self.new_session()\n',
   '\n',
   '    # ------------------------------\n',
   '    # Methods for retrieving history\n',
   '    # ------------------------------\n',
   '    def get_session_info(self, session=0):\n',
   '        """Get info about a session.\n',
   '\n',
   '        Parameters\n',
   '        ----------\n',
   '\n',
   '        session : int\n',
   '            Session number to retrieve. The current session is 0, and negative\n',
   '            numbers count back from current session, so -1 is the previous session.\n',
   '\n',
   '        Returns\n',
   '        -------\n',
   '        \n',
   '        session_id : int\n',
   '           Session ID number\n',
   '        start : datetime\n',
   '           Timestamp for the start of the session.\n',
   '        end : datetime\n',
   '           Timestamp for the end of the session, or None if IPython crashed.\n',
   '        num_cmds : int\n',
   '           Number of commands run, or None if IPython crashed.\n',
   '        remark : unicode\n',
   '           A manually set description.\n',
   '        """\n',
   '        if session <= 0:\n',
   '            session += self.session_number\n',
   '\n',
   '        return super(HistoryManager, self).get_session_info(session=session)\n',
   '\n',
   '    def _get_range_session(self, start=1, stop=None, raw=True, output=False):\n',
   '        """Get input and output history from the current session. Called by\n',
   '        get_range, and takes similar parameters."""\n',
   '        input_hist = self.input_hist_raw if raw else self.input_hist_parsed\n',
   '            \n',
   '        n = len(input_hist)\n',
   '        if start < 0:\n',
   '            start += n\n',
   '        if not stop or (stop > n):\n',
   '            stop = n\n',
   '        elif stop < 0:\n',
   '            stop += n\n',
   '        \n',
   '        for i in range(start, stop):\n',
   '            if output:\n',
   '                line = (input_hist[i], self.output_hist_reprs.get(i))\n',
   '            else:\n',
   '                line = input_hist[i]\n',
   '            yield (0, i, line)\n',
   '    \n',
   '    def get_range(self, session=0, start=1, stop=None, raw=True,output=False):\n',
   '        """Retrieve input by session.\n',
   '        \n',
   '        Parameters\n',
   '        ----------\n',
   '        session : int\n',
   '            Session number to retrieve. The current session is 0, and negative\n',
   '            numbers count back from current session, so -1 is previous session.\n',
   '        start : int\n',
   '            First line to retrieve.\n',
   '        stop : int\n',
   '            End of line range (excluded from output itself). If None, retrieve\n',
   '            to the end of the session.\n',
   '        raw : bool\n',
   '            If True, return untranslated input\n',
   '        output : bool\n',
   "            If True, attempt to include output. This will be 'real' Python\n",
   '            objects for the current session, or text reprs from previous\n',
   '            sessions if db_log_output was enabled at the time. Where no output\n',
   '            is found, None is used.\n',
   '            \n',
   '        Returns\n',
   '        -------\n',
   '        entries\n',
   '          An iterator over the desired lines. Each line is a 3-tuple, either\n',
   '          (session, line, input) if output is False, or\n',
   '          (session, line, (input, output)) if output is True.\n',
   '        """\n',
   '        if session <= 0:\n',
   '            session += self.session_number\n',
   '        if session==self.session_number:          # Current session\n',
   '            return self._get_range_session(start, stop, raw, output)\n',
   '        return super(HistoryManager, self).get_range(session, start, stop, raw,\n',
   '                                                     output)\n',
   '\n',
   '    ## ----------------------------\n',
   '    ## Methods for storing history:\n',
   '    ## ----------------------------\n',
   '    def store_inputs(self, line_num, source, source_raw=None):\n',
   '        """Store source and raw input in history and create input cache\n',
   '        variables ``_i*``.\n',
   '\n',
   '        Parameters\n',
   '        ----------\n',
   '        line_num : int\n',
   '          The prompt number of this input.\n',
   '\n',
   '        source : str\n',
   '          Python input.\n',
   '\n',
   '        source_raw : str, optional\n',
   '          If given, this is the raw input without any IPython transformations\n',
   '          applied to it.  If not given, ``source`` is used.\n',
   '        """\n',
   '        if source_raw is None:\n',
   '            source_raw = source\n',
   "        source = source.rstrip('\\n')\n",
   "        source_raw = source_raw.rstrip('\\n')\n",
   '\n',
   '        # do not store exit/quit commands\n',
   '        if self._exit_re.match(source_raw.strip()):\n',
   '            return\n',
   '\n',
   '        self.input_hist_parsed.append(source)\n',
   '        self.input_hist_raw.append(source_raw)\n',
   '\n',
   '        with self.db_input_cache_lock:\n',
   '            self.db_input_cache.append((line_num, source, source_raw))\n',
   '            # Trigger to flush cache and write to DB.\n',
   '            if len(self.db_input_cache) >= self.db_cache_size:\n',
   '                self.save_flag.set()\n',
   '\n',
   '        # update the auto _i variables\n',
   '        self._iii = self._ii\n',
   '        self._ii = self._i\n',
   '        self._i = self._i00\n',
   '        self._i00 = source_raw\n',
   '\n',
   '        # hackish access to user namespace to create _i1,_i2... dynamically\n',
   "        new_i = '_i%s' % line_num\n",
   "        to_main = {'_i': self._i,\n",
   "                   '_ii': self._ii,\n",
   "                   '_iii': self._iii,\n",
   '                   new_i : self._i00 }\n',
   '        \n',
   '        if self.shell is not None:\n',
   '            self.shell.push(to_main, interactive=False)\n',
   '\n',
   '    def store_output(self, line_num):\n',
   '        """If database output logging is enabled, this saves all the\n',
   "        outputs from the indicated prompt number to the database. It's\n",
   '        called by run_cell after code has been executed.\n',
   '\n',
   '        Parameters\n',
   '        ----------\n',
   '        line_num : int\n',
   '          The line number from which to save outputs\n',
   '        """\n',
   '        if (not self.db_log_output) or (line_num not in self.output_hist_reprs):\n',
   '            return\n',
   '        output = self.output_hist_reprs[line_num]\n',
   '\n',
   '        with self.db_output_cache_lock:\n',
   '            self.db_output_cache.append((line_num, output))\n',
   '        if self.db_cache_size <= 1:\n',
   '            self.save_flag.set()\n',
   '\n',
   '    def _writeout_input_cache(self, conn):\n',
   '        with conn:\n',
   '            for line in self.db_input_cache:\n',
   '                conn.execute("INSERT INTO history VALUES (?, ?, ?, ?)",\n',
   '                                (self.session_number,)+line)\n',
   '\n',
   '    def _writeout_output_cache(self, conn):\n',
   '        with conn:\n',
   '            for line in self.db_output_cache:\n',
   '                conn.execute("INSERT INTO output_history VALUES (?, ?, ?)",\n',
   '                                (self.session_number,)+line)\n',
   '\n',
   '    @needs_sqlite\n',
   '    def writeout_cache(self, conn=None):\n',
   '        """Write any entries in the cache to the database."""\n',
   '        if conn is None:\n',
   '            conn = self.db\n',
   '\n',
   '        with self.db_input_cache_lock:\n',
   '            try:\n',
   '                self._writeout_input_cache(conn)\n',
   '            except sqlite3.IntegrityError:\n',
   '                self.new_session(conn)\n',
   '                print("ERROR! Session/line number was not unique in",\n',
   '                      "database. History logging moved to new session",\n',
   '                                                self.session_number)\n',
   '                try:\n',
   "                    # Try writing to the new session. If this fails, don't\n",
   '                    # recurse\n',
   '                    self._writeout_input_cache(conn)\n',
   '                except sqlite3.IntegrityError:\n',
   '                    pass\n',
   '            finally:\n',
   '                self.db_input_cache = []\n',
   '\n',
   '        with self.db_output_cache_lock:\n',
   '            try:\n',
   '                self._writeout_output_cache(conn)\n',
   '            except sqlite3.IntegrityError:\n',
   '                print("!! Session/line number for output was not unique",\n',
   '                      "in database. Output will not be stored.")\n',
   '            finally:\n',
   '                self.db_output_cache = []\n',
   '\n',
   '\n',
   'class HistorySavingThread(threading.Thread):\n',
   '    """This thread takes care of writing history to the database, so that\n',
   "    the UI isn't held up while that happens.\n",
   '\n',
   "    It waits for the HistoryManager's save_flag to be set, then writes out\n",
   '    the history cache. The main thread is responsible for setting the flag when\n',
   '    the cache size reaches a defined threshold."""\n',
   '    daemon = True\n',
   '    stop_now = False\n',
   '    enabled = True\n',
   '    def __init__(self, history_manager):\n',
   '        super(HistorySavingThread, self).__init__(name="IPythonHistorySavingThread")\n',
   '        self.history_manager = history_manager\n',
   '        self.enabled = history_manager.enabled\n',
   '        atexit.register(self.stop)\n',
   '\n',
   '    @needs_sqlite\n',
   '    def run(self):\n',
   '        # We need a separate db connection per thread:\n',
   '        try:\n',
   '            self.db = sqlite3.connect(self.history_manager.hist_file,\n',
   '                            **self.history_manager.connection_options\n',
   '            )\n',
   '            while True:\n',
   '                self.history_manager.save_flag.wait()\n',
   '                if self.stop_now:\n',
   '                    self.db.close()\n',
   '                    return\n',
   '                self.history_manager.save_flag.clear()\n',
   '                self.history_manager.writeout_cache(self.db)\n',
   '        except Exception as e:\n',
   '            print(("The history saving thread hit an unexpected error (%s)."\n',
   '                   "History will not be written to the database.") % repr(e))\n',
   '\n',
   '    def stop(self):\n',
   '        """This can be called from the main thread to safely stop this thread.\n',
   '\n',
   '        Note that it does not attempt to write out remaining history before\n',
   "        exiting. That should be done by calling the HistoryManager's\n",
   '        end_session method."""\n',
   '        self.stop_now = True\n',
   '        self.history_manager.save_flag.set()\n',
   '        self.join()\n',
   '\n',
   '\n',
   '# To match, e.g. ~5/8-~2/3\n',
   'range_re = re.compile(r"""\n',
   '((?P<startsess>~?\\d+)/)?\n',
   '(?P<start>\\d+)?\n',
   '((?P<sep>[\\-:])\n',
   ' ((?P<endsess>~?\\d+)/)?\n',
   ' (?P<end>\\d+))?\n',
   '$""", re.VERBOSE)\n',
   '\n',
   '\n',
   'def extract_hist_ranges(ranges_str):\n',
   '    """Turn a string of history ranges into 3-tuples of (session, start, stop).\n',
   '\n',
   '    Examples\n',
   '    --------\n',
   '    >>> list(extract_hist_ranges("~8/5-~7/4 2"))\n',
   '    [(-8, 5, None), (-7, 1, 5), (0, 2, 3)]\n',
   '    """\n',
   '    for range_str in ranges_str.split():\n',
   '        rmatch = range_re.match(range_str)\n',
   '        if not rmatch:\n',
   '            continue\n',
   '        start = rmatch.group("start")\n',
   '        if start:\n',
   '            start = int(start)\n',
   '            end = rmatch.group("end")\n',
   '            # If no end specified, get (a, a + 1)\n',
   '            end = int(end) if end else start + 1\n',
   '        else:  # start not specified\n',
   "            if not rmatch.group('startsess'):  # no startsess\n",
   '                continue\n',
   '            start = 1\n',
   '            end = None  # provide the entire session hist\n',
   '\n',
   '        if rmatch.group("sep") == "-":       # 1-3 == 1:4 --> [1, 2, 3]\n',
   '            end += 1\n',
   '        startsess = rmatch.group("startsess") or "0"\n',
   '        endsess = rmatch.group("endsess") or startsess\n',
   '        startsess = int(startsess.replace("~","-"))\n',
   '        endsess = int(endsess.replace("~","-"))\n',
   '        assert endsess >= startsess, "start session must be earlier than end session"\n',
   '\n',
   '        if endsess == startsess:\n',
   '            yield (startsess, start, end)\n',
   '            continue\n',
   '        # Multiple sessions in one range:\n',
   '        yield (startsess, start, None)\n',
   '        for sess in range(startsess+1, endsess):\n',
   '            yield (sess, 1, None)\n',
   '        yield (endsess, 1, end)\n',
   '\n',
   '\n',
   'def _format_lineno(session, line):\n',
   '    """Helper function to format line numbers properly."""\n',
   '    if session == 0:\n',
   '        return str(line)\n',
   '    return "%s#%s" % (session, line)\n',
   '\n',
   '\n'],
  '/home/pasha/.local/lib/python3.4/site-packages/IPython/core/history.py'),
 {'_i': 'import gc\ngc.garbage',
  '_i00': 'gc.get_objects()',
  '_ii': 'import gc\ngc',
  '_iii': 'import gc\nпс',
  'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
  'connection_options': {},
  'db': <sqlite3.Connection at 0x7f51c12c0e30>,
  'db_cache_size': 0,
  'db_input_cache': [],
  'db_log_output': False,
  'db_output_cache': [],
  'dir_hist': ['/home/pasha/machine-learning.coursera/LearnInProgress/final.assignment/Kaggle'],
  'enabled': True,
  'hist_file': '/home/pasha/.ipython/profile_default/history.sqlite',
  'input_hist_parsed': ['',
   'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
   'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
   'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
   "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   'def pick(l: list, index: int) -> int:\n    return l[index]',
   'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
   'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
   'pick([1, 2, 3], 2)',
   "pick([1, 2, 3], '2')",
   'import gc',
   'import gc\nпс',
   'import gc\ngc',
   'import gc\ngc.garbage',
   'gc.get_objects()'],
  'input_hist_raw': ['',
   'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
   'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
   'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
   "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   'def pick(l: list, index: int) -> int:\n    return l[index]',
   'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
   'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
   'pick([1, 2, 3], 2)',
   "pick([1, 2, 3], '2')",
   'import gc',
   'import gc\nпс',
   'import gc\ngc',
   'import gc\ngc.garbage',
   'gc.get_objects()'],
  'output_hist': {14: 3, 15: 3, 19: <module 'gc' (built-in)>, 20: []},
  'output_hist_reprs': {14: '3',
   15: '3',
   19: "<module 'gc' (built-in)>",
   20: '[]'},
  'parent': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>,
  'save_flag': <threading.Event at 0x7f51c016e0f0>,
  'save_thread': <HistorySavingThread(IPythonHistorySavingThread, started 139988989622016)>,
  'session_number': 291,
  'shell': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>},
 [<weakref at 0x7f51c017b908; to 'sqlite3.Statement' at 0x7f51c016e0a0>,
  <weakref at 0x7f51c017b818; to 'sqlite3.Statement' at 0x7f51c016e110>,
  <weakref at 0x7f51c017b8b8; to 'sqlite3.Statement' at 0x7f51c016e730>,
  <weakref at 0x7f51c017b9a8; to 'sqlite3.Statement' at 0x7f51c016e810>],
 [<weakref at 0x7f51c017b728; dead>,
  <weakref at 0x7f51c017b7c8; dead>,
  <weakref at 0x7f51c017b868; dead>,
  <weakref at 0x7f51c017b958; dead>],
 <weakref at 0x7f51c017b728; dead>,
 <weakref at 0x7f51c017b908; to 'sqlite3.Statement' at 0x7f51c016e0a0>,
 {('CREATE TABLE IF NOT EXISTS history\n                (session integer, line integer, source text, source_raw text,\n                PRIMARY KEY (session, line))',): <sqlite3Node at 0x7f51c016e068>,
  ('CREATE TABLE IF NOT EXISTS output_history\n                        (session integer, line integer, output text,\n                        PRIMARY KEY (session, line))',): <sqlite3Node at 0x7f51c016e768>,
  ('CREATE TABLE IF NOT EXISTS sessions (session integer\n                        primary key autoincrement, start timestamp,\n                        end timestamp, num_cmds integer, remark text)',): <sqlite3Node at 0x7f51c016e030>,
  ('INSERT INTO sessions VALUES (NULL, ?, NULL,\n                            NULL, "") ',): <sqlite3Node at 0x7f51c016e848>},
 <weakref at 0x7f51c017b7c8; dead>,
 <weakref at 0x7f51c017b818; to 'sqlite3.Statement' at 0x7f51c016e110>,
 <weakref at 0x7f51c017b868; dead>,
 <weakref at 0x7f51c017b8b8; to 'sqlite3.Statement' at 0x7f51c016e730>,
 <threading.Event at 0x7f51c016e0f0>,
 {'_cond': <Condition(<_thread.lock object at 0x7f51c12898a0>, 1)>,
  '_flag': False},
 <weakref at 0x7f51c017b958; dead>,
 <weakref at 0x7f51c017b9a8; to 'sqlite3.Statement' at 0x7f51c016e810>,
 <HistorySavingThread(IPythonHistorySavingThread, started 139988989622016)>,
 {'_args': (),
  '_daemonic': False,
  '_ident': 139988989622016,
  '_initialized': True,
  '_is_stopped': False,
  '_kwargs': {},
  '_name': 'IPythonHistorySavingThread',
  '_started': <threading.Event at 0x7f51c016e898>,
  '_stderr': <ipykernel.iostream.OutStream at 0x7f51c1221b38>,
  '_target': None,
  '_tstate_lock': <_thread.lock at 0x7f51c1289af8>,
  'db': <sqlite3.Connection at 0x7f51c12c0c70>,
  'enabled': True,
  'history_manager': <IPython.core.history.HistoryManager at 0x7f51c1221710>},
 <threading.Event at 0x7f51c016e898>,
 {'_cond': <Condition(<_thread.lock object at 0x7f51c12899e0>, 0)>,
  '_flag': True},
 <weakref at 0x7f51c017ba48; to 'HistorySavingThread' at 0x7f51c016e7f0>,
 <bound method HistorySavingThread.stop of <HistorySavingThread(IPythonHistorySavingThread, started 139988989622016)>>,
 <bound method HistorySavingThread._bootstrap of <HistorySavingThread(IPythonHistorySavingThread, started 139988989622016)>>,
 (<HistorySavingThread(IPythonHistorySavingThread, started 139988989622016)>,),
 <frame at 0x7f51c017f048>,
 <frame at 0x7f51a40008d8>,
 <weakref at 0x7f51c017ba98; to '_thread.lock' at 0x7f51c1289af8>,
 <frame at 0x7f51c11fc3b8>,
 <frame at 0x7f51c11fd5d0>,
 (<HistorySavingThread(IPythonHistorySavingThread, started 139988989622016)>,),
 <frame at 0x7f51a4000f58>,
 <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
 {'_checkers': [<EmacsChecker(priority=100, enabled=False)>,
   <MacroChecker(priority=250, enabled=True)>,
   <IPyAutocallChecker(priority=300, enabled=True)>,
   <AssignmentChecker(priority=600, enabled=True)>,
   <AutoMagicChecker(priority=700, enabled=True)>,
   <PythonOpsChecker(priority=900, enabled=True)>,
   <AutocallChecker(priority=1000, enabled=True)>],
  '_cross_validation_lock': False,
  '_esc_handlers': {'%': <IPython.core.prefilter.MagicHandler at 0x7f51c016eac8>,
   ',': <IPython.core.prefilter.AutoHandler at 0x7f51c016eb38>,
   '/': <IPython.core.prefilter.AutoHandler at 0x7f51c016eb38>,
   ';': <IPython.core.prefilter.AutoHandler at 0x7f51c016eb38>},
  '_handlers': {'auto': <IPython.core.prefilter.AutoHandler at 0x7f51c016eb38>,
   'emacs': <IPython.core.prefilter.EmacsHandler at 0x7f51c016eb70>,
   'macro': <IPython.core.prefilter.MacroHandler at 0x7f51c016ea90>,
   'magic': <IPython.core.prefilter.MagicHandler at 0x7f51c016eac8>,
   'normal': <IPython.core.prefilter.PrefilterHandler at 0x7f51c016ea20>},
  '_trait_notifiers': {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
  '_trait_validators': {},
  '_trait_values': {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
   'multi_line_specials': True,
   'parent': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>,
   'shell': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>},
  '_transformers': []},
 {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
 {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
  'multi_line_specials': True,
  'parent': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>,
  'shell': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>},
 [],
 {'auto': <IPython.core.prefilter.AutoHandler at 0x7f51c016eb38>,
  'emacs': <IPython.core.prefilter.EmacsHandler at 0x7f51c016eb70>,
  'macro': <IPython.core.prefilter.MacroHandler at 0x7f51c016ea90>,
  'magic': <IPython.core.prefilter.MagicHandler at 0x7f51c016eac8>,
  'normal': <IPython.core.prefilter.PrefilterHandler at 0x7f51c016ea20>},
 <IPython.core.prefilter.MacroHandler at 0x7f51c016ea90>,
 {'_cross_validation_lock': False,
  '_trait_notifiers': {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
  '_trait_validators': {},
  '_trait_values': {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
   'esc_strings': [],
   'handler_name': 'macro',
   'parent': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
   'prefilter_manager': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
   'shell': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>}},
 {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
 {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
  'esc_strings': [],
  'handler_name': 'macro',
  'parent': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
  'prefilter_manager': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
  'shell': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>},
 [],
 <IPython.core.prefilter.MagicHandler at 0x7f51c016eac8>,
 {'_cross_validation_lock': False,
  '_trait_notifiers': {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
  '_trait_validators': {},
  '_trait_values': {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
   'esc_strings': ['%'],
   'handler_name': 'magic',
   'parent': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
   'prefilter_manager': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
   'shell': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>}},
 {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
 {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
  'esc_strings': ['%'],
  'handler_name': 'magic',
  'parent': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
  'prefilter_manager': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
  'shell': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>},
 ['%'],
 {'%': <IPython.core.prefilter.MagicHandler at 0x7f51c016eac8>,
  ',': <IPython.core.prefilter.AutoHandler at 0x7f51c016eb38>,
  '/': <IPython.core.prefilter.AutoHandler at 0x7f51c016eb38>,
  ';': <IPython.core.prefilter.AutoHandler at 0x7f51c016eb38>},
 <IPython.core.prefilter.AutoHandler at 0x7f51c016eb38>,
 {'_cross_validation_lock': False,
  '_trait_notifiers': {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
  '_trait_validators': {},
  '_trait_values': {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
   'esc_strings': ['/', ',', ';'],
   'handler_name': 'auto',
   'parent': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
   'prefilter_manager': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
   'shell': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>}},
 {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
 {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
  'esc_strings': ['/', ',', ';'],
  'handler_name': 'auto',
  'parent': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
  'prefilter_manager': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
  'shell': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>},
 ['/', ',', ';'],
 <IPython.core.prefilter.EmacsHandler at 0x7f51c016eb70>,
 {'_cross_validation_lock': False,
  '_trait_notifiers': {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
  '_trait_validators': {},
  '_trait_values': {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
   'esc_strings': [],
   'handler_name': 'emacs',
   'parent': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
   'prefilter_manager': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
   'shell': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>}},
 {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
 {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
  'esc_strings': [],
  'handler_name': 'emacs',
  'parent': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
  'prefilter_manager': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
  'shell': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>},
 [],
 [<EmacsChecker(priority=100, enabled=False)>,
  <MacroChecker(priority=250, enabled=True)>,
  <IPyAutocallChecker(priority=300, enabled=True)>,
  <AssignmentChecker(priority=600, enabled=True)>,
  <AutoMagicChecker(priority=700, enabled=True)>,
  <PythonOpsChecker(priority=900, enabled=True)>,
  <AutocallChecker(priority=1000, enabled=True)>],
 <EmacsChecker(priority=100, enabled=False)>,
 {'_cross_validation_lock': False,
  '_trait_notifiers': {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
  '_trait_validators': {},
  '_trait_values': {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
   'enabled': False,
   'parent': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
   'prefilter_manager': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
   'priority': 100,
   'shell': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>}},
 {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
 {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
  'enabled': False,
  'parent': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
  'prefilter_manager': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
  'priority': 100,
  'shell': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>},
 <MacroChecker(priority=250, enabled=True)>,
 {'_cross_validation_lock': False,
  '_trait_notifiers': {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
  '_trait_validators': {},
  '_trait_values': {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
   'enabled': True,
   'parent': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
   'prefilter_manager': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
   'priority': 250,
   'shell': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>}},
 {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
 {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
  'enabled': True,
  'parent': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
  'prefilter_manager': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
  'priority': 250,
  'shell': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>},
 <bound method IOPubThread._thread_main of <ipykernel.iostream.IOPubThread object at 0x7f51c124be48>>,
 <Condition(<_thread.lock object at 0x7f51c125c3a0>, 0)>,
 [],
 [],
 <logging.PercentStyle at 0x7f51c1221d68>,
 (<cell at 0x7f51c1284588: weakref object at 0x7f51c12416d8>,),
 <zmq.sugar.context.Context at 0x7f51c11ee2e8>,
 <Condition(<_thread.lock object at 0x7f51c1289490>, 0)>,
 ModuleSpec(name='faulthandler', loader=<class '_frozen_importlib.BuiltinImporter'>, origin='built-in'),
 (<cell at 0x7f51c1284a98: builtin_function_or_method object at 0x7f51c1232cc8>,),
 (<cell at 0x7f51c1284ac8: builtin_function_or_method object at 0x7f51c122ee48>,),
 <zmq.eventloop.ioloop.ZMQPoller at 0x7f51c1221438>,
 <_io.FileIO name=29 mode='rb'>,
 (29, <function tornado.stack_context.wrap.<locals>.null_wrapper>),
 [],
 deque([]),
 <function lock.acquire>,
 <function lock.acquire>,
 <function lock.acquire>,
 <function tornado.stack_context.wrap.<locals>.null_wrapper>,
 [],
 deque([]),
 <function lock.acquire>,
 <function lock.acquire>,
 <function lock.acquire>,
 <function tornado.stack_context.wrap.<locals>.null_wrapper>,
 {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]},
 ['"""Base class for a kernel that talks to frontends over 0MQ."""\n',
  '\n',
  '# Copyright (c) IPython Development Team.\n',
  '# Distributed under the terms of the Modified BSD License.\n',
  '\n',
  'from __future__ import print_function\n',
  '\n',
  'import sys\n',
  'import time\n',
  'import logging\n',
  'import uuid\n',
  '\n',
  'from datetime import datetime\n',
  'from signal import (\n',
  '        signal, default_int_handler, SIGINT\n',
  ')\n',
  '\n',
  'import zmq\n',
  'from zmq.eventloop import ioloop\n',
  'from zmq.eventloop.zmqstream import ZMQStream\n',
  '\n',
  'from traitlets.config.configurable import SingletonConfigurable\n',
  'from IPython.core.error import StdinNotImplementedError\n',
  'from ipython_genutils import py3compat\n',
  'from ipython_genutils.py3compat import unicode_type, string_types\n',
  'from ipykernel.jsonutil import json_clean\n',
  'from traitlets import (\n',
  '    Any, Instance, Float, Dict, List, Set, Integer, Unicode, Bool,\n',
  ')\n',
  '\n',
  'from jupyter_client.session import Session\n',
  '\n',
  'from ._version import kernel_protocol_version\n',
  '\n',
  'class Kernel(SingletonConfigurable):\n',
  '\n',
  '    #---------------------------------------------------------------------------\n',
  '    # Kernel interface\n',
  '    #---------------------------------------------------------------------------\n',
  '\n',
  '    # attribute to override with a GUI\n',
  '    eventloop = Any(None)\n',
  '    def _eventloop_changed(self, name, old, new):\n',
  '        """schedule call to eventloop from IOLoop"""\n',
  '        loop = ioloop.IOLoop.instance()\n',
  '        loop.add_callback(self.enter_eventloop)\n',
  '\n',
  '    session = Instance(Session, allow_none=True)\n',
  "    profile_dir = Instance('IPython.core.profiledir.ProfileDir', allow_none=True)\n",
  '    shell_streams = List()\n',
  '    control_stream = Instance(ZMQStream, allow_none=True)\n',
  '    iopub_socket = Any()\n',
  '    iopub_thread = Any()\n',
  '    stdin_socket = Any()\n',
  '    log = Instance(logging.Logger, allow_none=True)\n',
  '\n',
  '    # identities:\n',
  '    int_id = Integer(-1)\n',
  '    ident = Unicode()\n',
  '\n',
  '    def _ident_default(self):\n',
  '        return unicode_type(uuid.uuid4())\n',
  '\n',
  '    # This should be overridden by wrapper kernels that implement any real\n',
  '    # language.\n',
  '    language_info = {}\n',
  '\n',
  '    # any links that should go in the help menu\n',
  '    help_links = List()\n',
  '\n',
  '    # Private interface\n',
  '\n',
  '    _darwin_app_nap = Bool(True, config=True,\n',
  '        help="""Whether to use appnope for compatiblity with OS X App Nap.\n',
  '\n',
  '        Only affects OS X >= 10.9.\n',
  '        """\n',
  '    )\n',
  '\n',
  '    # track associations with current request\n',
  '    _allow_stdin = Bool(False)\n',
  '    _parent_header = Dict()\n',
  "    _parent_ident = Any(b'')\n",
  '    # Time to sleep after flushing the stdout/err buffers in each execute\n',
  '    # cycle.  While this introduces a hard limit on the minimal latency of the\n',
  '    # execute cycle, it helps prevent output synchronization problems for\n',
  '    # clients.\n',
  '    # Units are in seconds.  The minimum zmq latency on local host is probably\n',
  '    # ~150 microseconds, set this to 500us for now.  We may need to increase it\n',
  "    # a little if it's not enough after more interactive testing.\n",
  '    _execute_sleep = Float(0.0005, config=True)\n',
  '\n',
  "    # Frequency of the kernel's event loop.\n",
  '    # Units are in seconds, kernel subclasses for GUI toolkits may need to\n',
  '    # adapt to milliseconds.\n',
  '    _poll_interval = Float(0.05, config=True)\n',
  '\n',
  '    # If the shutdown was requested over the network, we leave here the\n',
  '    # necessary reply message so it can be sent by our registered atexit\n',
  '    # handler.  This ensures that the reply is only sent to clients truly at\n',
  '    # the end of our shutdown process (which happens after the underlying\n',
  "    # IPython shell's own shutdown).\n",
  '    _shutdown_message = None\n',
  '\n',
  '    # This is a dict of port number that the kernel is listening on. It is set\n',
  '    # by record_ports and used by connect_request.\n',
  '    _recorded_ports = Dict()\n',
  '\n',
  '    # set of aborted msg_ids\n',
  '    aborted = Set()\n',
  '\n',
  '    # Track execution count here. For IPython, we override this to use the\n',
  '    # execution count we store in the shell.\n',
  '    execution_count = 0\n',
  '    \n',
  '    msg_types = [\n',
  "        'execute_request', 'complete_request',\n",
  "        'inspect_request', 'history_request',\n",
  "        'comm_info_request', 'kernel_info_request',\n",
  "        'connect_request', 'shutdown_request',\n",
  "        'is_complete_request',\n",
  '        # deprecated:\n',
  "        'apply_request',\n",
  '    ]\n',
  '    # add deprecated ipyparallel control messages\n',
  "    control_msg_types = msg_types + ['clear_request', 'abort_request']\n",
  '\n',
  '    def __init__(self, **kwargs):\n',
  '        super(Kernel, self).__init__(**kwargs)\n',
  '\n',
  '        # Build dict of handlers for message types\n',
  '        self.shell_handlers = {}\n',
  '        for msg_type in self.msg_types:\n',
  '            self.shell_handlers[msg_type] = getattr(self, msg_type)\n',
  '\n',
  '        self.control_handlers = {}\n',
  '        for msg_type in self.control_msg_types:\n',
  '            self.control_handlers[msg_type] = getattr(self, msg_type)\n',
  '\n',
  '\n',
  '    def dispatch_control(self, msg):\n',
  '        """dispatch control requests"""\n',
  '        idents,msg = self.session.feed_identities(msg, copy=False)\n',
  '        try:\n',
  '            msg = self.session.deserialize(msg, content=True, copy=False)\n',
  '        except:\n',
  '            self.log.error("Invalid Control Message", exc_info=True)\n',
  '            return\n',
  '\n',
  '        self.log.debug("Control received: %s", msg)\n',
  '\n',
  '        # Set the parent message for side effects.\n',
  '        self.set_parent(idents, msg)\n',
  "        self._publish_status(u'busy')\n",
  '\n',
  "        header = msg['header']\n",
  "        msg_type = header['msg_type']\n",
  '\n',
  '        handler = self.control_handlers.get(msg_type, None)\n',
  '        if handler is None:\n',
  '            self.log.error("UNKNOWN CONTROL MESSAGE TYPE: %r", msg_type)\n',
  '        else:\n',
  '            try:\n',
  '                handler(self.control_stream, idents, msg)\n',
  '            except Exception:\n',
  '                self.log.error("Exception in control handler:", exc_info=True)\n',
  '\n',
  '        sys.stdout.flush()\n',
  '        sys.stderr.flush()\n',
  "        self._publish_status(u'idle')\n",
  '\n',
  '    def should_handle(self, stream, msg, idents):\n',
  '        """Check whether a shell-channel message should be handled\n',
  '        \n',
  '        Allows subclasses to prevent handling of certain messages (e.g. aborted requests).\n',
  '        """\n',
  "        msg_id = msg['header']['msg_id']\n",
  '        if msg_id in self.aborted:\n',
  "            msg_type = msg['header']['msg_type']\n",
  '            # is it safe to assume a msg_id will not be resubmitted?\n',
  '            self.aborted.remove(msg_id)\n',
  "            reply_type = msg_type.split('_')[0] + '_reply'\n",
  "            status = {'status' : 'aborted'}\n",
  "            md = {'engine' : self.ident}\n",
  '            md.update(status)\n',
  '            self.session.send(stream, reply_type, metadata=md,\n',
  '                        content=status, parent=msg, ident=idents)\n',
  '            return False\n',
  '        return True\n',
  '\n',
  '    def dispatch_shell(self, stream, msg):\n',
  '        """dispatch shell requests"""\n',
  '        # flush control requests first\n',
  '        if self.control_stream:\n',
  '            self.control_stream.flush()\n',
  '\n',
  '        idents,msg = self.session.feed_identities(msg, copy=False)\n',
  '        try:\n',
  '            msg = self.session.deserialize(msg, content=True, copy=False)\n',
  '        except:\n',
  '            self.log.error("Invalid Message", exc_info=True)\n',
  '            return\n',
  '\n',
  '        # Set the parent message for side effects.\n',
  '        self.set_parent(idents, msg)\n',
  "        self._publish_status(u'busy')\n",
  '\n',
  "        header = msg['header']\n",
  "        msg_id = header['msg_id']\n",
  "        msg_type = msg['header']['msg_type']\n",
  '\n',
  "        # Print some info about this message and leave a '--->' marker, so it's\n",
  '        # easier to trace visually the message chain when debugging.  Each\n',
  '        # handler prints its message at the end.\n',
  "        self.log.debug('\\n*** MESSAGE TYPE:%s***', msg_type)\n",
  "        self.log.debug('   Content: %s\\n   --->\\n   ', msg['content'])\n",
  '\n',
  '        if not self.should_handle(stream, msg, idents):\n',
  '            return\n',
  '\n',
  '        handler = self.shell_handlers.get(msg_type, None)\n',
  '        if handler is None:\n',
  '            self.log.error("UNKNOWN MESSAGE TYPE: %r", msg_type)\n',
  '        else:\n',
  '            self.log.debug("%s: %s", msg_type, msg)\n',
  '            self.pre_handler_hook()\n',
  '            try:\n',
  '                handler(stream, idents, msg)\n',
  '            except Exception:\n',
  '                self.log.error("Exception in message handler:", exc_info=True)\n',
  '            finally:\n',
  '                self.post_handler_hook()\n',
  '\n',
  '        sys.stdout.flush()\n',
  '        sys.stderr.flush()\n',
  "        self._publish_status(u'idle')\n",
  '\n',
  '    def pre_handler_hook(self):\n',
  '        """Hook to execute before calling message handler"""\n',
  '        # ensure default_int_handler during handler call\n',
  '        self.saved_sigint_handler = signal(SIGINT, default_int_handler)\n',
  '\n',
  '    def post_handler_hook(self):\n',
  '        """Hook to execute after calling message handler"""\n',
  '        signal(SIGINT, self.saved_sigint_handler)\n',
  '\n',
  '    def enter_eventloop(self):\n',
  '        """enter eventloop"""\n',
  '        self.log.info("entering eventloop %s", self.eventloop)\n',
  '        for stream in self.shell_streams:\n',
  '            # flush any pending replies,\n',
  '            # which may be skipped by entering the eventloop\n',
  '            stream.flush(zmq.POLLOUT)\n',
  '        # restore default_int_handler\n',
  '        signal(SIGINT, default_int_handler)\n',
  '        while self.eventloop is not None:\n',
  '            try:\n',
  '                self.eventloop(self)\n',
  '            except KeyboardInterrupt:\n',
  "                # Ctrl-C shouldn't crash the kernel\n",
  '                self.log.error("KeyboardInterrupt caught in kernel")\n',
  '                continue\n',
  '            else:\n',
  '                # eventloop exited cleanly, this means we should stop (right?)\n',
  '                self.eventloop = None\n',
  '                break\n',
  '        self.log.info("exiting eventloop")\n',
  '\n',
  '    def start(self):\n',
  '        """register dispatchers for streams"""\n',
  '        if self.control_stream:\n',
  '            self.control_stream.on_recv(self.dispatch_control, copy=False)\n',
  '\n',
  '        def make_dispatcher(stream):\n',
  '            def dispatcher(msg):\n',
  '                return self.dispatch_shell(stream, msg)\n',
  '            return dispatcher\n',
  '\n',
  '        for s in self.shell_streams:\n',
  '            s.on_recv(make_dispatcher(s), copy=False)\n',
  '\n',
  '        # publish idle status\n',
  "        self._publish_status('starting')\n",
  '\n',
  '    def do_one_iteration(self):\n',
  '        """step eventloop just once"""\n',
  '        if self.control_stream:\n',
  '            self.control_stream.flush()\n',
  '        for stream in self.shell_streams:\n',
  '            # handle at most one request per iteration\n',
  '            stream.flush(zmq.POLLIN, 1)\n',
  '            stream.flush(zmq.POLLOUT)\n',
  '\n',
  '\n',
  '    def record_ports(self, ports):\n',
  '        """Record the ports that this kernel is using.\n',
  '\n',
  '        The creator of the Kernel instance must call this methods if they\n',
  '        want the :meth:`connect_request` method to return the port numbers.\n',
  '        """\n',
  '        self._recorded_ports = ports\n',
  '\n',
  '    #---------------------------------------------------------------------------\n',
  '    # Kernel request handlers\n',
  '    #---------------------------------------------------------------------------\n',
  '\n',
  '    def _publish_execute_input(self, code, parent, execution_count):\n',
  '        """Publish the code request on the iopub stream."""\n',
  '\n',
  "        self.session.send(self.iopub_socket, u'execute_input',\n",
  "                            {u'code':code, u'execution_count': execution_count},\n",
  "                            parent=parent, ident=self._topic('execute_input')\n",
  '        )\n',
  '\n',
  '    def _publish_status(self, status, parent=None):\n',
  '        """send status (busy/idle) on IOPub"""\n',
  '        self.session.send(self.iopub_socket,\n',
  "                          u'status',\n",
  "                          {u'execution_state': status},\n",
  '                          parent=parent or self._parent_header,\n',
  "                          ident=self._topic('status'),\n",
  '                          )\n',
  '\n',
  '    def set_parent(self, ident, parent):\n',
  '        """Set the current parent_header\n',
  '\n',
  '        Side effects (IOPub messages) and replies are associated with\n',
  '        the request that caused them via the parent_header.\n',
  '\n',
  '        The parent identity is used to route input_request messages\n',
  '        on the stdin channel.\n',
  '        """\n',
  '        self._parent_ident = ident\n',
  '        self._parent_header = parent\n',
  '\n',
  '    def send_response(self, stream, msg_or_type, content=None, ident=None,\n',
  '             buffers=None, track=False, header=None, metadata=None):\n',
  '        """Send a response to the message we\'re currently processing.\n',
  '\n',
  '        This accepts all the parameters of :meth:`jupyter_client.session.Session.send`\n',
  '        except ``parent``.\n',
  '\n',
  '        This relies on :meth:`set_parent` having been called for the current\n',
  '        message.\n',
  '        """\n',
  '        return self.session.send(stream, msg_or_type, content, self._parent_header,\n',
  '                                 ident, buffers, track, header, metadata)\n',
  '    \n',
  '    def init_metadata(self, parent):\n',
  '        """Initialize metadata.\n',
  '        \n',
  '        Run at the beginning of execution requests.\n',
  '        """\n',
  '        return {\n',
  "            'started': datetime.now(),\n",
  '        }\n',
  '    \n',
  '    def finish_metadata(self, parent, metadata, reply_content):\n',
  '        """Finish populating metadata.\n',
  '        \n',
  '        Run after completing an execution request.\n',
  '        """\n',
  '        return metadata\n',
  '\n',
  '    def execute_request(self, stream, ident, parent):\n',
  '        """handle an execute_request"""\n',
  '\n',
  '        try:\n',
  "            content = parent[u'content']\n",
  "            code = py3compat.cast_unicode_py2(content[u'code'])\n",
  "            silent = content[u'silent']\n",
  "            store_history = content.get(u'store_history', not silent)\n",
  "            user_expressions = content.get('user_expressions', {})\n",
  "            allow_stdin = content.get('allow_stdin', False)\n",
  '        except:\n',
  '            self.log.error("Got bad msg: ")\n',
  '            self.log.error("%s", parent)\n',
  '            return\n',
  '\n',
  "        stop_on_error = content.get('stop_on_error', True)\n",
  '\n',
  '        metadata = self.init_metadata(parent)\n',
  '\n',
  '        # Re-broadcast our input for the benefit of listening clients, and\n',
  '        # start computing output\n',
  '        if not silent:\n',
  '            self.execution_count += 1\n',
  '            self._publish_execute_input(code, parent, self.execution_count)\n',
  '\n',
  '        reply_content = self.do_execute(code, silent, store_history,\n',
  '                                        user_expressions, allow_stdin)\n',
  '\n',
  '        # Flush output before sending the reply.\n',
  '        sys.stdout.flush()\n',
  '        sys.stderr.flush()\n',
  "        # FIXME: on rare occasions, the flush doesn't seem to make it to the\n",
  '        # clients... This seems to mitigate the problem, but we definitely need\n',
  "        # to better understand what's going on.\n",
  '        if self._execute_sleep:\n',
  '            time.sleep(self._execute_sleep)\n',
  '\n',
  '        # Send the reply.\n',
  '        reply_content = json_clean(reply_content)\n',
  '        metadata = self.finish_metadata(parent, metadata, reply_content)\n',
  '\n',
  "        reply_msg = self.session.send(stream, u'execute_reply',\n",
  '                                      reply_content, parent, metadata=metadata,\n',
  '                                      ident=ident)\n',
  '\n',
  '        self.log.debug("%s", reply_msg)\n',
  '\n',
  "        if not silent and reply_msg['content']['status'] == u'error' and stop_on_error:\n",
  '            self._abort_queues()\n',
  '\n',
  '    def do_execute(self, code, silent, store_history=True,\n',
  '                   user_expressions=None, allow_stdin=False):\n',
  '        """Execute user code. Must be overridden by subclasses.\n',
  '        """\n',
  '        raise NotImplementedError\n',
  '\n',
  '    def complete_request(self, stream, ident, parent):\n',
  "        content = parent['content']\n",
  "        code = content['code']\n",
  "        cursor_pos = content['cursor_pos']\n",
  '\n',
  '        matches = self.do_complete(code, cursor_pos)\n',
  '        matches = json_clean(matches)\n',
  "        completion_msg = self.session.send(stream, 'complete_reply',\n",
  '                                           matches, parent, ident)\n',
  '        self.log.debug("%s", completion_msg)\n',
  '\n',
  '    def do_complete(self, code, cursor_pos):\n',
  '        """Override in subclasses to find completions.\n',
  '        """\n',
  "        return {'matches' : [],\n",
  "                'cursor_end' : cursor_pos,\n",
  "                'cursor_start' : cursor_pos,\n",
  "                'metadata' : {},\n",
  "                'status' : 'ok'}\n",
  '\n',
  '    def inspect_request(self, stream, ident, parent):\n',
  "        content = parent['content']\n",
  '\n',
  "        reply_content = self.do_inspect(content['code'], content['cursor_pos'],\n",
  "                                        content.get('detail_level', 0))\n",
  '        # Before we send this object over, we scrub it for JSON usage\n',
  '        reply_content = json_clean(reply_content)\n',
  "        msg = self.session.send(stream, 'inspect_reply',\n",
  '                                reply_content, parent, ident)\n',
  '        self.log.debug("%s", msg)\n',
  '\n',
  '    def do_inspect(self, code, cursor_pos, detail_level=0):\n',
  '        """Override in subclasses to allow introspection.\n',
  '        """\n',
  "        return {'status': 'ok', 'data': {}, 'metadata': {}, 'found': False}\n",
  '\n',
  '    def history_request(self, stream, ident, parent):\n',
  "        content = parent['content']\n",
  '\n',
  '        reply_content = self.do_history(**content)\n',
  '\n',
  '        reply_content = json_clean(reply_content)\n',
  "        msg = self.session.send(stream, 'history_reply',\n",
  '                                reply_content, parent, ident)\n',
  '        self.log.debug("%s", msg)\n',
  '\n',
  '    def do_history(self, hist_access_type, output, raw, session=None, start=None,\n',
  '                   stop=None, n=None, pattern=None, unique=False):\n',
  '        """Override in subclasses to access history.\n',
  '        """\n',
  "        return {'history': []}\n",
  '\n',
  '    def connect_request(self, stream, ident, parent):\n',
  '        if self._recorded_ports is not None:\n',
  '            content = self._recorded_ports.copy()\n',
  '        else:\n',
  '            content = {}\n',
  "        msg = self.session.send(stream, 'connect_reply',\n",
  '                                content, parent, ident)\n',
  '        self.log.debug("%s", msg)\n',
  '\n',
  '    @property\n',
  '    def kernel_info(self):\n',
  '        return {\n',
  "            'protocol_version': kernel_protocol_version,\n",
  "            'implementation': self.implementation,\n",
  "            'implementation_version': self.implementation_version,\n",
  "            'language_info': self.language_info,\n",
  "            'banner': self.banner,\n",
  "            'help_links': self.help_links,\n",
  '        }\n',
  '\n',
  '    def kernel_info_request(self, stream, ident, parent):\n',
  "        msg = self.session.send(stream, 'kernel_info_reply',\n",
  '                                self.kernel_info, parent, ident)\n',
  '        self.log.debug("%s", msg)\n',
  '\n',
  '    def comm_info_request(self, stream, ident, parent):\n',
  "        content = parent['content']\n",
  "        target_name = content.get('target_name', None)\n",
  '\n',
  '        # Should this be moved to ipkernel?\n',
  "        if hasattr(self, 'comm_manager'):\n",
  '            comms = {\n',
  '                k: dict(target_name=v.target_name)\n',
  '                for (k, v) in self.comm_manager.comms.items()\n',
  '                if v.target_name == target_name or target_name is None\n',
  '            }\n',
  '        else:\n',
  '            comms = {}\n',
  '        reply_content = dict(comms=comms)\n',
  "        msg = self.session.send(stream, 'comm_info_reply',\n",
  '                                reply_content, parent, ident)\n',
  '        self.log.debug("%s", msg)\n',
  '\n',
  '    def shutdown_request(self, stream, ident, parent):\n',
  "        content = self.do_shutdown(parent['content']['restart'])\n",
  "        self.session.send(stream, u'shutdown_reply', content, parent, ident=ident)\n",
  '        # same content, but different msg_id for broadcasting on IOPub\n',
  "        self._shutdown_message = self.session.msg(u'shutdown_reply',\n",
  '                                                  content, parent\n',
  '        )\n',
  '\n',
  '        self._at_shutdown()\n',
  '        # call sys.exit after a short delay\n',
  '        loop = ioloop.IOLoop.instance()\n',
  '        loop.add_timeout(time.time()+0.1, loop.stop)\n',
  '\n',
  '    def do_shutdown(self, restart):\n',
  '        """Override in subclasses to do things when the frontend shuts down the\n',
  '        kernel.\n',
  '        """\n',
  "        return {'status': 'ok', 'restart': restart}\n",
  '\n',
  '    def is_complete_request(self, stream, ident, parent):\n',
  "        content = parent['content']\n",
  "        code = content['code']\n",
  '\n',
  '        reply_content = self.do_is_complete(code)\n',
  '        reply_content = json_clean(reply_content)\n',
  "        reply_msg = self.session.send(stream, 'is_complete_reply',\n",
  '                                           reply_content, parent, ident)\n',
  '        self.log.debug("%s", reply_msg)\n',
  '\n',
  '    def do_is_complete(self, code):\n',
  '        """Override in subclasses to find completions.\n',
  '        """\n',
  "        return {'status' : 'unknown',\n",
  '                }\n',
  '\n',
  '    #---------------------------------------------------------------------------\n',
  '    # Engine methods (DEPRECATED)\n',
  '    #---------------------------------------------------------------------------\n',
  '\n',
  '    def apply_request(self, stream, ident, parent):\n',
  '        self.log.warn("""apply_request is deprecated in kernel_base, moving to ipyparallel.""")\n',
  '        try:\n',
  "            content = parent[u'content']\n",
  "            bufs = parent[u'buffers']\n",
  "            msg_id = parent['header']['msg_id']\n",
  '        except:\n',
  '            self.log.error("Got bad msg: %s", parent, exc_info=True)\n',
  '            return\n',
  '\n',
  '        md = self.init_metadata(parent)\n',
  '\n',
  '        reply_content, result_buf = self.do_apply(content, bufs, msg_id, md)\n',
  '        \n',
  '        # flush i/o\n',
  '        sys.stdout.flush()\n',
  '        sys.stderr.flush()\n',
  '\n',
  '        md = self.finish_metadata(parent, md, reply_content)\n',
  '\n',
  "        self.session.send(stream, u'apply_reply', reply_content,\n",
  '                    parent=parent, ident=ident,buffers=result_buf, metadata=md)\n',
  '\n',
  '    def do_apply(self, content, bufs, msg_id, reply_metadata):\n',
  '        """DEPRECATED"""\n',
  '        raise NotImplementedError\n',
  '\n',
  '    #---------------------------------------------------------------------------\n',
  '    # Control messages (DEPRECATED)\n',
  '    #---------------------------------------------------------------------------\n',
  '\n',
  '    def abort_request(self, stream, ident, parent):\n',
  '        """abort a specific msg by id"""\n',
  '        self.log.warn("abort_request is deprecated in kernel_base. It os only part of IPython parallel")\n',
  "        msg_ids = parent['content'].get('msg_ids', None)\n",
  '        if isinstance(msg_ids, string_types):\n',
  '            msg_ids = [msg_ids]\n',
  '        if not msg_ids:\n',
  '            self._abort_queues()\n',
  '        for mid in msg_ids:\n',
  '            self.aborted.add(str(mid))\n',
  '\n',
  "        content = dict(status='ok')\n",
  "        reply_msg = self.session.send(stream, 'abort_reply', content=content,\n",
  '                parent=parent, ident=ident)\n',
  '        self.log.debug("%s", reply_msg)\n',
  '\n',
  '    def clear_request(self, stream, idents, parent):\n',
  '        """Clear our namespace."""\n',
  '        self.log.warn("clear_request is deprecated in kernel_base. It os only part of IPython parallel")\n',
  '        content = self.do_clear()\n',
  "        self.session.send(stream, 'clear_reply', ident=idents, parent=parent,\n",
  '                content = content)\n',
  '\n',
  '    def do_clear(self):\n',
  '        """DEPRECATED"""\n',
  '        raise NotImplementedError\n',
  '\n',
  '    #---------------------------------------------------------------------------\n',
  '    # Protected interface\n',
  '    #---------------------------------------------------------------------------\n',
  '\n',
  '    def _topic(self, topic):\n',
  '        """prefixed topic for IOPub messages"""\n',
  '        base = "kernel.%s" % self.ident\n',
  '\n',
  '        return py3compat.cast_bytes("%s.%s" % (base, topic))\n',
  '\n',
  '    def _abort_queues(self):\n',
  '        for stream in self.shell_streams:\n',
  '            if stream:\n',
  '                self._abort_queue(stream)\n',
  '\n',
  '    def _abort_queue(self, stream):\n',
  '        poller = zmq.Poller()\n',
  '        poller.register(stream.socket, zmq.POLLIN)\n',
  '        while True:\n',
  '            idents,msg = self.session.recv(stream, zmq.NOBLOCK, content=True)\n',
  '            if msg is None:\n',
  '                return\n',
  '\n',
  '            self.log.info("Aborting:")\n',
  '            self.log.info("%s", msg)\n',
  "            msg_type = msg['header']['msg_type']\n",
  "            reply_type = msg_type.split('_')[0] + '_reply'\n",
  '\n',
  "            status = {'status' : 'aborted'}\n",
  "            md = {'engine' : self.ident}\n",
  '            md.update(status)\n',
  '            reply_msg = self.session.send(stream, reply_type, metadata=md,\n',
  '                        content=status, parent=msg, ident=idents)\n',
  '            self.log.debug("%s", reply_msg)\n',
  '            # We need to wait a bit for requests to come in. This can probably\n',
  '            # be set shorter for true asynchronous clients.\n',
  '            poller.poll(50)\n',
  '\n',
  '\n',
  '    def _no_raw_input(self):\n',
  '        """Raise StdinNotImplentedError if active frontend doesn\'t support\n',
  '        stdin."""\n',
  '        raise StdinNotImplementedError("raw_input was called, but this "\n',
  '                                       "frontend does not support stdin.")\n',
  '\n',
  "    def getpass(self, prompt=''):\n",
  '        """Forward getpass to frontends\n',
  '\n',
  '        Raises\n',
  '        ------\n',
  "        StdinNotImplentedError if active frontend doesn't support stdin.\n",
  '        """\n',
  '        if not self._allow_stdin:\n',
  '            raise StdinNotImplementedError(\n',
  '                "getpass was called, but this frontend does not support input requests."\n',
  '            )\n',
  '        return self._input_request(prompt,\n',
  '            self._parent_ident,\n',
  '            self._parent_header,\n',
  '            password=True,\n',
  '        )\n',
  '\n',
  "    def raw_input(self, prompt=''):\n",
  '        """Forward raw_input to frontends\n',
  '\n',
  '        Raises\n',
  '        ------\n',
  "        StdinNotImplentedError if active frontend doesn't support stdin.\n",
  '        """\n',
  '        if not self._allow_stdin:\n',
  '            raise StdinNotImplementedError(\n',
  '                "raw_input was called, but this frontend does not support input requests."\n',
  '            )\n',
  '        return self._input_request(prompt,\n',
  '            self._parent_ident,\n',
  '            self._parent_header,\n',
  '            password=False,\n',
  '        )\n',
  '\n',
  '    def _input_request(self, prompt, ident, parent, password=False):\n',
  '        # Flush output before making the request.\n',
  '        sys.stderr.flush()\n',
  '        sys.stdout.flush()\n',
  '        # flush the stdin socket, to purge stale replies\n',
  '        while True:\n',
  '            try:\n',
  '                self.stdin_socket.recv_multipart(zmq.NOBLOCK)\n',
  '            except zmq.ZMQError as e:\n',
  '                if e.errno == zmq.EAGAIN:\n',
  '                    break\n',
  '                else:\n',
  '                    raise\n',
  '\n',
  '        # Send the input request.\n',
  '        content = json_clean(dict(prompt=prompt, password=password))\n',
  "        self.session.send(self.stdin_socket, u'input_request', content, parent,\n",
  '                          ident=ident)\n',
  '\n',
  '        # Await a response.\n',
  '        while True:\n',
  '            try:\n',
  '                ident, reply = self.session.recv(self.stdin_socket, 0)\n',
  '            except Exception:\n',
  '                self.log.warn("Invalid Message:", exc_info=True)\n',
  '            except KeyboardInterrupt:\n',
  '                # re-raise KeyboardInterrupt, to truncate traceback\n',
  '                raise KeyboardInterrupt\n',
  '            else:\n',
  '                break\n',
  '        try:\n',
  "            value = py3compat.unicode_to_str(reply['content']['value'])\n",
  '        except:\n',
  '            self.log.error("Bad input_reply: %s", parent)\n',
  "            value = ''\n",
  "        if value == '\\x04':\n",
  '            # EOF\n',
  '            raise EOFError\n',
  '        return value\n',
  '\n',
  '    def _at_shutdown(self):\n',
  '        """Actions taken at shutdown by the kernel, called by python\'s atexit.\n',
  '        """\n',
  '        # io.rprint("Kernel at_shutdown") # dbg\n',
  '        if self._shutdown_message is not None:\n',
  "            self.session.send(self.iopub_socket, self._shutdown_message, ident=self._topic('shutdown'))\n",
  '            self.log.debug("%s", self._shutdown_message)\n',
  '        [ s.flush(zmq.POLLOUT) for s in self.shell_streams ]\n'],
 ['"""The IPython kernel implementation"""\n',
  '\n',
  'import getpass\n',
  'import sys\n',
  'import traceback\n',
  '\n',
  'from IPython.core import release\n',
  'from ipython_genutils.py3compat import builtin_mod, PY3\n',
  'from IPython.utils.tokenutil import token_at_cursor, line_at_cursor\n',
  'from traitlets import Instance, Type, Any, List\n',
  '\n',
  'from .comm import CommManager\n',
  'from .kernelbase import Kernel as KernelBase\n',
  'from .zmqshell import ZMQInteractiveShell\n',
  '\n',
  '\n',
  'class IPythonKernel(KernelBase):\n',
  "    shell = Instance('IPython.core.interactiveshell.InteractiveShellABC',\n",
  '                     allow_none=True)\n',
  '    shell_class = Type(ZMQInteractiveShell)\n',
  '\n',
  '    user_module = Any()\n',
  '    def _user_module_changed(self, name, old, new):\n',
  '        if self.shell is not None:\n',
  '            self.shell.user_module = new\n',
  '\n',
  '    user_ns = Instance(dict, args=None, allow_none=True)\n',
  '    def _user_ns_changed(self, name, old, new):\n',
  '        if self.shell is not None:\n',
  '            self.shell.user_ns = new\n',
  '            self.shell.init_user_ns()\n',
  '\n',
  "    # A reference to the Python builtin 'raw_input' function.\n",
  '    # (i.e., __builtin__.raw_input for Python 2.7, builtins.input for Python 3)\n',
  '    _sys_raw_input = Any()\n',
  '    _sys_eval_input = Any()\n',
  '\n',
  '    def __init__(self, **kwargs):\n',
  '        super(IPythonKernel, self).__init__(**kwargs)\n',
  '\n',
  '        # Initialize the InteractiveShell subclass\n',
  '        self.shell = self.shell_class.instance(parent=self,\n',
  '            profile_dir = self.profile_dir,\n',
  '            user_module = self.user_module,\n',
  '            user_ns     = self.user_ns,\n',
  '            kernel      = self,\n',
  '        )\n',
  '        self.shell.displayhook.session = self.session\n',
  '        self.shell.displayhook.pub_socket = self.iopub_socket\n',
  "        self.shell.displayhook.topic = self._topic('execute_result')\n",
  '        self.shell.display_pub.session = self.session\n',
  '        self.shell.display_pub.pub_socket = self.iopub_socket\n',
  '\n',
  '        # TMP - hack while developing\n',
  '        self.shell._reply_content = None\n',
  '\n',
  '        self.comm_manager = CommManager(shell=self.shell, parent=self,\n',
  '                                        kernel=self)\n',
  '\n',
  '        self.shell.configurables.append(self.comm_manager)\n',
  "        comm_msg_types = [ 'comm_open', 'comm_msg', 'comm_close' ]\n",
  '        for msg_type in comm_msg_types:\n',
  '            self.shell_handlers[msg_type] = getattr(self.comm_manager, msg_type)\n',
  '\n',
  '    help_links = List([\n',
  '        {\n',
  '            \'text\': "Python",\n',
  '            \'url\': "http://docs.python.org/%i.%i" % sys.version_info[:2],\n',
  '        },\n',
  '        {\n',
  '            \'text\': "IPython",\n',
  '            \'url\': "http://ipython.org/documentation.html",\n',
  '        },\n',
  '        {\n',
  '            \'text\': "NumPy",\n',
  '            \'url\': "http://docs.scipy.org/doc/numpy/reference/",\n',
  '        },\n',
  '        {\n',
  '            \'text\': "SciPy",\n',
  '            \'url\': "http://docs.scipy.org/doc/scipy/reference/",\n',
  '        },\n',
  '        {\n',
  '            \'text\': "Matplotlib",\n',
  '            \'url\': "http://matplotlib.org/contents.html",\n',
  '        },\n',
  '        {\n',
  '            \'text\': "SymPy",\n',
  '            \'url\': "http://docs.sympy.org/latest/index.html",\n',
  '        },\n',
  '        {\n',
  '            \'text\': "pandas",\n',
  '            \'url\': "http://pandas.pydata.org/pandas-docs/stable/",\n',
  '        },\n',
  '    ])\n',
  '\n',
  '    # Kernel info fields\n',
  "    implementation = 'ipython'\n",
  '    implementation_version = release.version\n',
  '    language_info = {\n',
  "                     'name': 'python',\n",
  "                     'version': sys.version.split()[0],\n",
  "                     'mimetype': 'text/x-python',\n",
  "                     'codemirror_mode': {'name': 'ipython',\n",
  "                                         'version': sys.version_info[0]},\n",
  "                     'pygments_lexer': 'ipython%d' % (3 if PY3 else 2),\n",
  "                     'nbconvert_exporter': 'python',\n",
  "                     'file_extension': '.py'\n",
  '                    }\n',
  '    @property\n',
  '    def banner(self):\n',
  '        return self.shell.banner\n',
  '\n',
  '    def start(self):\n',
  '        self.shell.exit_now = False\n',
  '        super(IPythonKernel, self).start()\n',
  '\n',
  '    def set_parent(self, ident, parent):\n',
  '        """Overridden from parent to tell the display hook and output streams\n',
  '        about the parent message.\n',
  '        """\n',
  '        super(IPythonKernel, self).set_parent(ident, parent)\n',
  '        self.shell.set_parent(parent)\n',
  '\n',
  '    def init_metadata(self, parent):\n',
  '        """Initialize metadata.\n',
  '        \n',
  '        Run at the beginning of each execution request.\n',
  '        """\n',
  '        md = super(IPythonKernel, self).init_metadata(parent)\n',
  '        # FIXME: remove deprecated ipyparallel-specific code\n',
  '        # This is required for ipyparallel < 5.0\n',
  '        md.update({\n',
  "            'dependencies_met' : True,\n",
  "            'engine' : self.ident,\n",
  '        })\n',
  '        return md\n',
  '    \n',
  '    def finish_metadata(self, parent, metadata, reply_content):\n',
  '        """Finish populating metadata.\n',
  '        \n',
  '        Run after completing an execution request.\n',
  '        """\n',
  '        # FIXME: remove deprecated ipyparallel-specific code\n',
  '        # This is required by ipyparallel < 5.0\n',
  "        metadata['status'] = reply_content['status']\n",
  "        if reply_content['status'] == 'error' and reply_content['ename'] == 'UnmetDependency':\n",
  "                metadata['dependencies_met'] = False\n",
  '\n',
  '        return metadata\n',
  '\n',
  '    def _forward_input(self, allow_stdin=False):\n',
  '        """Forward raw_input and getpass to the current frontend.\n',
  '\n',
  '        via input_request\n',
  '        """\n',
  '        self._allow_stdin = allow_stdin\n',
  '\n',
  '        if PY3:\n',
  '            self._sys_raw_input = builtin_mod.input\n',
  '            builtin_mod.input = self.raw_input\n',
  '        else:\n',
  '            self._sys_raw_input = builtin_mod.raw_input\n',
  '            self._sys_eval_input = builtin_mod.input\n',
  '            builtin_mod.raw_input = self.raw_input\n',
  "            builtin_mod.input = lambda prompt='': eval(self.raw_input(prompt))\n",
  '        self._save_getpass = getpass.getpass\n',
  '        getpass.getpass = self.getpass\n',
  '\n',
  '    def _restore_input(self):\n',
  '        """Restore raw_input, getpass"""\n',
  '        if PY3:\n',
  '            builtin_mod.input = self._sys_raw_input\n',
  '        else:\n',
  '            builtin_mod.raw_input = self._sys_raw_input\n',
  '            builtin_mod.input = self._sys_eval_input\n',
  '\n',
  '        getpass.getpass = self._save_getpass\n',
  '\n',
  '    @property\n',
  '    def execution_count(self):\n',
  '        return self.shell.execution_count\n',
  '\n',
  '    @execution_count.setter\n',
  '    def execution_count(self, value):\n',
  "        # Ignore the incrememnting done by KernelBase, in favour of our shell's\n",
  '        # execution counter.\n',
  '        pass\n',
  '\n',
  '    def do_execute(self, code, silent, store_history=True,\n',
  '                   user_expressions=None, allow_stdin=False):\n',
  "        shell = self.shell # we'll need this a lot here\n",
  '\n',
  '        self._forward_input(allow_stdin)\n',
  '\n',
  '        reply_content = {}\n',
  '        # FIXME: the shell calls the exception handler itself.\n',
  '        shell._reply_content = None\n',
  '        try:\n',
  '            shell.run_cell(code, store_history=store_history, silent=silent)\n',
  '        except:\n',
  "            status = u'error'\n",
  "            # FIXME: this code right now isn't being used yet by default,\n",
  '            # because the run_cell() call above directly fires off exception\n',
  '            # reporting.  This code, therefore, is only active in the scenario\n',
  '            # where runlines itself has an unhandled exception.  We need to\n',
  '            # uniformize this, for all exception construction to come from a\n',
  '            # single location in the codbase.\n',
  '            etype, evalue, tb = sys.exc_info()\n',
  '            tb_list = traceback.format_exception(etype, evalue, tb)\n',
  '            reply_content.update(shell._showtraceback(etype, evalue, tb_list))\n',
  '        else:\n',
  "            status = u'ok'\n",
  '        finally:\n',
  '            self._restore_input()\n',
  '\n',
  "        reply_content[u'status'] = status\n",
  '\n',
  '        # Return the execution counter so clients can display prompts\n',
  "        reply_content['execution_count'] = shell.execution_count - 1\n",
  '\n',
  '        # FIXME - fish exception info out of shell, possibly left there by\n',
  "        # runlines.  We'll need to clean up this logic later.\n",
  '        if shell._reply_content is not None:\n',
  '            reply_content.update(shell._reply_content)\n',
  '            # reset after use\n',
  '            shell._reply_content = None\n',
  '            # FIXME: deprecate piece for ipyparallel:\n',
  "            e_info = dict(engine_uuid=self.ident, engine_id=self.int_id, method='execute')\n",
  "            reply_content['engine_info'] = e_info\n",
  '\n',
  "        if 'traceback' in reply_content:\n",
  '            self.log.info("Exception in execute request:\\n%s", \'\\n\'.join(reply_content[\'traceback\']))\n',
  '\n',
  '\n',
  '        # At this point, we can tell whether the main code execution succeeded\n',
  '        # or not.  If it did, we proceed to evaluate user_expressions\n',
  "        if reply_content['status'] == 'ok':\n",
  "            reply_content[u'user_expressions'] = \\\n",
  '                         shell.user_expressions(user_expressions or {})\n',
  '        else:\n',
  "            # If there was an error, don't even try to compute expressions\n",
  "            reply_content[u'user_expressions'] = {}\n",
  '\n',
  '        # Payloads should be retrieved regardless of outcome, so we can both\n',
  '        # recover partial output (that could have been generated early in a\n',
  '        # block, before an error) and clear the payload system always.\n',
  "        reply_content[u'payload'] = shell.payload_manager.read_payload()\n",
  "        # Be agressive about clearing the payload because we don't want\n",
  '        # it to sit in memory until the next execute_request comes in.\n',
  '        shell.payload_manager.clear_payload()\n',
  '\n',
  '        return reply_content\n',
  '\n',
  '    def do_complete(self, code, cursor_pos):\n',
  '        # FIXME: IPython completers currently assume single line,\n',
  '        # but completion messages give multi-line context\n',
  '        # For now, extract line from cell, based on cursor_pos:\n',
  '        if cursor_pos is None:\n',
  '            cursor_pos = len(code)\n',
  '        line, offset = line_at_cursor(code, cursor_pos)\n',
  '        line_cursor = cursor_pos - offset\n',
  '\n',
  "        txt, matches = self.shell.complete('', line, line_cursor)\n",
  "        return {'matches' : matches,\n",
  "                'cursor_end' : cursor_pos,\n",
  "                'cursor_start' : cursor_pos - len(txt),\n",
  "                'metadata' : {},\n",
  "                'status' : 'ok'}\n",
  '\n',
  '    def do_inspect(self, code, cursor_pos, detail_level=0):\n',
  '        name = token_at_cursor(code, cursor_pos)\n',
  '        info = self.shell.object_inspect(name)\n',
  '\n',
  "        reply_content = {'status' : 'ok'}\n",
  "        reply_content['data'] = data = {}\n",
  "        reply_content['metadata'] = {}\n",
  "        reply_content['found'] = info['found']\n",
  "        if info['found']:\n",
  '            info_text = self.shell.object_inspect_text(\n',
  '                name,\n',
  '                detail_level=detail_level,\n',
  '            )\n',
  "            data['text/plain'] = info_text\n",
  '\n',
  '        return reply_content\n',
  '\n',
  '    def do_history(self, hist_access_type, output, raw, session=None, start=None,\n',
  '                   stop=None, n=None, pattern=None, unique=False):\n',
  "        if hist_access_type == 'tail':\n",
  '            hist = self.shell.history_manager.get_tail(n, raw=raw, output=output,\n',
  '                                                            include_latest=True)\n',
  '\n',
  "        elif hist_access_type == 'range':\n",
  '            hist = self.shell.history_manager.get_range(session, start, stop,\n',
  '                                                        raw=raw, output=output)\n',
  '\n',
  "        elif hist_access_type == 'search':\n",
  '            hist = self.shell.history_manager.search(\n',
  '                pattern, raw=raw, output=output, n=n, unique=unique)\n',
  '        else:\n',
  '            hist = []\n',
  '\n',
  "        return {'history' : list(hist)}\n",
  '\n',
  '    def do_shutdown(self, restart):\n',
  '        self.shell.exit_now = True\n',
  "        return dict(status='ok', restart=restart)\n",
  '\n',
  '    def do_is_complete(self, code):\n',
  '        status, indent_spaces = self.shell.input_transformer_manager.check_complete(code)\n',
  "        r = {'status': status}\n",
  "        if status == 'incomplete':\n",
  "            r['indent'] = ' ' * indent_spaces\n",
  '        return r\n',
  '\n',
  '    def do_apply(self, content, bufs, msg_id, reply_metadata):\n',
  '        from .serialize import serialize_object, unpack_apply_message\n',
  '        shell = self.shell\n',
  '        try:\n',
  '            working = shell.user_ns\n',
  '\n',
  '            prefix = "_"+str(msg_id).replace("-","")+"_"\n',
  '\n',
  '            f,args,kwargs = unpack_apply_message(bufs, working, copy=False)\n',
  '\n',
  "            fname = getattr(f, '__name__', 'f')\n",
  '\n',
  '            fname = prefix+"f"\n',
  '            argname = prefix+"args"\n',
  '            kwargname = prefix+"kwargs"\n',
  '            resultname = prefix+"result"\n',
  '\n',
  '            ns = { fname : f, argname : args, kwargname : kwargs , resultname : None }\n',
  '            # print ns\n',
  '            working.update(ns)\n',
  '            code = "%s = %s(*%s,**%s)" % (resultname, fname, argname, kwargname)\n',
  '            try:\n',
  '                exec(code, shell.user_global_ns, shell.user_ns)\n',
  '                result = working.get(resultname)\n',
  '            finally:\n',
  '                for key in ns:\n',
  '                    working.pop(key)\n',
  '\n',
  '            result_buf = serialize_object(result,\n',
  '                buffer_threshold=self.session.buffer_threshold,\n',
  '                item_threshold=self.session.item_threshold,\n',
  '            )\n',
  '\n',
  '        except:\n',
  '            # invoke IPython traceback formatting\n',
  '            shell.showtraceback()\n',
  '            # FIXME - fish exception info out of shell, possibly left there by\n',
  "            # run_code.  We'll need to clean up this logic later.\n",
  '            reply_content = {}\n',
  '            if shell._reply_content is not None:\n',
  '                reply_content.update(shell._reply_content)\n',
  '                # reset after use\n',
  '                shell._reply_content = None\n',
  '                \n',
  '                # FIXME: deprecate piece for ipyparallel:\n',
  "                e_info = dict(engine_uuid=self.ident, engine_id=self.int_id, method='apply')\n",
  "                reply_content['engine_info'] = e_info\n",
  '\n',
  "            self.send_response(self.iopub_socket, u'error', reply_content,\n",
  "                                ident=self._topic('error'))\n",
  '            self.log.info("Exception in apply request:\\n%s", \'\\n\'.join(reply_content[\'traceback\']))\n',
  '            result_buf = []\n',
  '        else:\n',
  "            reply_content = {'status' : 'ok'}\n",
  '\n',
  '        return reply_content, result_buf\n',
  '\n',
  '    def do_clear(self):\n',
  '        self.shell.reset(False)\n',
  "        return dict(status='ok')\n",
  '\n',
  '\n',
  '# This exists only for backwards compatibility - use IPythonKernel instead\n',
  '\n',
  'class Kernel(IPythonKernel):\n',
  '    def __init__(self, *args, **kwargs):\n',
  '        import warnings\n',
  "        warnings.warn('Kernel is a deprecated alias of ipykernel.ipkernel.IPythonKernel',\n",
  '                      DeprecationWarning)\n',
  '        super(Kernel, self).__init__(*args, **kwargs)\n'],
 <bound method IPythonKernel.execute_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
 <bound method IPythonKernel.execute_request of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
 {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]},
 ['"""A ZMQ-based subclass of InteractiveShell.\n',
  '\n',
  'This code is meant to ease the refactoring of the base InteractiveShell into\n',
  'something with a cleaner architecture for 2-process use, without actually\n',
  "breaking InteractiveShell itself.  So we're doing something a bit ugly, where\n",
  'we subclass and override what we want to fix.  Once this is working well, we\n',
  'can go back to the base class and refactor the code for a cleaner inheritance\n',
  "implementation that doesn't rely on so much monkeypatching.\n",
  '\n',
  'But this lets us maintain a fully working IPython as we develop the new\n',
  'machinery.  This should thus be thought of as scaffolding.\n',
  '"""\n',
  '\n',
  '# Copyright (c) IPython Development Team.\n',
  '# Distributed under the terms of the Modified BSD License.\n',
  '\n',
  'from __future__ import print_function\n',
  '\n',
  'import os\n',
  'import sys\n',
  'import time\n',
  'import warnings\n',
  '\n',
  'from zmq.eventloop import ioloop\n',
  '\n',
  'from IPython.core.interactiveshell import (\n',
  '    InteractiveShell, InteractiveShellABC\n',
  ')\n',
  'from IPython.core import page\n',
  'from IPython.core.autocall import ZMQExitAutocall\n',
  'from IPython.core.displaypub import DisplayPublisher\n',
  'from IPython.core.error import UsageError\n',
  'from IPython.core.magics import MacroToEdit, CodeMagics\n',
  'from IPython.core.magic import magics_class, line_magic, Magics\n',
  'from IPython.core import payloadpage\n',
  'from IPython.core.usage import default_banner\n',
  'from IPython.display import display, Javascript\n',
  'from ipykernel import (\n',
  '    get_connection_file, get_connection_info, connect_qtconsole\n',
  ')\n',
  'from IPython.utils import openpy\n',
  'from ipykernel.jsonutil import json_clean, encode_images\n',
  'from IPython.utils.process import arg_split\n',
  'from ipython_genutils import py3compat\n',
  'from ipython_genutils.py3compat import unicode_type\n',
  'from traitlets import Instance, Type, Dict, CBool, CBytes, Any\n',
  'from IPython.utils.warn import error\n',
  'from ipykernel.displayhook import ZMQShellDisplayHook\n',
  'from jupyter_client.session import extract_header\n',
  'from jupyter_client.session import Session\n',
  '\n',
  '#-----------------------------------------------------------------------------\n',
  '# Functions and classes\n',
  '#-----------------------------------------------------------------------------\n',
  '\n',
  'class ZMQDisplayPublisher(DisplayPublisher):\n',
  '    """A display publisher that publishes data using a ZeroMQ PUB socket."""\n',
  '\n',
  '    session = Instance(Session, allow_none=True)\n',
  '    pub_socket = Any(allow_none=True)\n',
  '    parent_header = Dict({})\n',
  "    topic = CBytes(b'display_data')\n",
  '\n',
  '    def set_parent(self, parent):\n',
  '        """Set the parent for outbound messages."""\n',
  '        self.parent_header = extract_header(parent)\n',
  '\n',
  '    def _flush_streams(self):\n',
  '        """flush IO Streams prior to display"""\n',
  '        sys.stdout.flush()\n',
  '        sys.stderr.flush()\n',
  '\n',
  '    def publish(self, data, metadata=None, source=None):\n',
  '        self._flush_streams()\n',
  '        if metadata is None:\n',
  '            metadata = {}\n',
  '        self._validate_data(data, metadata)\n',
  '        content = {}\n',
  "        content['data'] = encode_images(data)\n",
  "        content['metadata'] = metadata\n",
  '        self.session.send(\n',
  "            self.pub_socket, u'display_data', json_clean(content),\n",
  '            parent=self.parent_header, ident=self.topic,\n',
  '        )\n',
  '\n',
  '    def clear_output(self, wait=False):\n',
  '        content = dict(wait=wait)\n',
  '        self._flush_streams()\n',
  '        self.session.send(\n',
  "            self.pub_socket, u'clear_output', content,\n",
  '            parent=self.parent_header, ident=self.topic,\n',
  '        )\n',
  '\n',
  '@magics_class\n',
  'class KernelMagics(Magics):\n',
  '    #------------------------------------------------------------------------\n',
  '    # Magic overrides\n',
  '    #------------------------------------------------------------------------\n',
  '    # Once the base class stops inheriting from magic, this code needs to be\n',
  '    # moved into a separate machinery as well.  For now, at least isolate here\n',
  '    # the magics which this class needs to implement differently from the base\n',
  '    # class, or that are unique to it.\n',
  '\n',
  '    _find_edit_target = CodeMagics._find_edit_target\n',
  '\n',
  '    @line_magic\n',
  "    def edit(self, parameter_s='', last_call=['','']):\n",
  '        """Bring up an editor and execute the resulting code.\n',
  '\n',
  '        Usage:\n',
  '          %edit [options] [args]\n',
  '\n',
  '        %edit runs an external text editor. You will need to set the command for\n',
  '        this editor via the ``TerminalInteractiveShell.editor`` option in your\n',
  '        configuration file before it will work.\n',
  '\n',
  '        This command allows you to conveniently edit multi-line code right in\n',
  '        your IPython session.\n',
  '\n',
  '        If called without arguments, %edit opens up an empty editor with a\n',
  '        temporary file and will execute the contents of this file when you\n',
  "        close it (don't forget to save it!).\n",
  '\n',
  '        Options:\n',
  '\n',
  '        -n <number>\n',
  '          Open the editor at a specified line number. By default, the IPython\n',
  "          editor hook uses the unix syntax 'editor +N filename', but you can\n",
  '          configure this by providing your own modified hook if your favorite\n',
  '          editor supports line-number specifications with a different syntax.\n',
  '\n',
  '        -p\n',
  '          Call the editor with the same data as the previous time it was used,\n',
  '          regardless of how long ago (in your current session) it was.\n',
  '\n',
  '        -r\n',
  "          Use 'raw' input. This option only applies to input taken from the\n",
  "          user's history.  By default, the 'processed' history is used, so that\n",
  '          magics are loaded in their transformed version to valid Python.  If\n',
  '          this option is given, the raw input as typed as the command line is\n',
  '          used instead.  When you exit the editor, it will be executed by\n',
  "          IPython's own processor.\n",
  '\n',
  '        Arguments:\n',
  '\n',
  '        If arguments are given, the following possibilites exist:\n',
  '\n',
  '        - The arguments are numbers or pairs of colon-separated numbers (like\n',
  '          1 4:8 9). These are interpreted as lines of previous input to be\n',
  '          loaded into the editor. The syntax is the same of the %macro command.\n',
  '\n',
  "        - If the argument doesn't start with a number, it is evaluated as a\n",
  '          variable and its contents loaded into the editor. You can thus edit\n',
  '          any string which contains python code (including the result of\n',
  '          previous edits).\n',
  '\n',
  '        - If the argument is the name of an object (other than a string),\n',
  '          IPython will try to locate the file where it was defined and open the\n',
  '          editor at the point where it is defined. You can use ``%edit function``\n',
  "          to load an editor exactly at the point where 'function' is defined,\n",
  '          edit it and have the file be executed automatically.\n',
  '\n',
  '          If the object is a macro (see %macro for details), this opens up your\n',
  "          specified editor with a temporary file containing the macro's data.\n",
  '          Upon exit, the macro is reloaded with the contents of the file.\n',
  '\n',
  '          Note: opening at an exact line is only supported under Unix, and some\n',
  '          editors (like kedit and gedit up to Gnome 2.8) do not understand the\n',
  "          '+NUMBER' parameter necessary for this feature. Good editors like\n",
  '          (X)Emacs, vi, jed, pico and joe all do.\n',
  '\n',
  '        - If the argument is not found as a variable, IPython will look for a\n',
  '          file with that name (adding .py if necessary) and load it into the\n',
  '          editor. It will execute its contents with execfile() when you exit,\n',
  '          loading any code in the file into your interactive namespace.\n',
  '\n',
  '        Unlike in the terminal, this is designed to use a GUI editor, and we do\n',
  '        not know when it has closed. So the file you edit will not be\n',
  '        automatically executed or printed.\n',
  '\n',
  '        Note that %edit is also available through the alias %ed.\n',
  '        """\n',
  '\n',
  "        opts,args = self.parse_options(parameter_s,'prn:')\n",
  '\n',
  '        try:\n',
  '            filename, lineno, _ = CodeMagics._find_edit_target(self.shell, args, opts, last_call)\n',
  '        except MacroToEdit as e:\n',
  '            # TODO: Implement macro editing over 2 processes.\n',
  '            print("Macro editing not yet implemented in 2-process model.")\n',
  '            return\n',
  '\n',
  '        # Make sure we send to the client an absolute path, in case the working\n',
  "        # directory of client and kernel don't match\n",
  '        filename = os.path.abspath(filename)\n',
  '\n',
  '        payload = {\n',
  "            'source' : 'edit_magic',\n",
  "            'filename' : filename,\n",
  "            'line_number' : lineno\n",
  '        }\n',
  '        self.shell.payload_manager.write_payload(payload)\n',
  '\n',
  '    # A few magics that are adapted to the specifics of using pexpect and a\n',
  '    # remote terminal\n',
  '\n',
  '    @line_magic\n',
  '    def clear(self, arg_s):\n',
  '        """Clear the terminal."""\n',
  "        if os.name == 'posix':\n",
  '            self.shell.system("clear")\n',
  '        else:\n',
  '            self.shell.system("cls")\n',
  '\n',
  "    if os.name == 'nt':\n",
  '        # This is the usual name in windows\n',
  "        cls = line_magic('cls')(clear)\n",
  '\n',
  "    # Terminal pagers won't work over pexpect, but we do have our own pager\n",
  '\n',
  '    @line_magic\n',
  '    def less(self, arg_s):\n',
  '        """Show a file through the pager.\n',
  '\n',
  '        Files ending in .py are syntax-highlighted."""\n',
  '        if not arg_s:\n',
  "            raise UsageError('Missing filename.')\n",
  '\n',
  "        if arg_s.endswith('.py'):\n",
  '            cont = self.shell.pycolorize(openpy.read_py_file(arg_s, skip_encoding_cookie=False))\n',
  '        else:\n',
  '            cont = open(arg_s).read()\n',
  '        page.page(cont)\n',
  '\n',
  "    more = line_magic('more')(less)\n",
  '\n',
  '    # Man calls a pager, so we also need to redefine it\n',
  "    if os.name == 'posix':\n",
  '        @line_magic\n',
  '        def man(self, arg_s):\n',
  '            """Find the man page for the given command and display in pager."""\n',
  "            page.page(self.shell.getoutput('man %s | col -b' % arg_s,\n",
  '                                           split=False))\n',
  '\n',
  '    @line_magic\n',
  '    def connect_info(self, arg_s):\n',
  '        """Print information for connecting other clients to this kernel\n',
  '\n',
  "        It will print the contents of this session's connection file, as well as\n",
  '        shortcuts for local clients.\n',
  '\n',
  '        In the simplest case, when called from the most recently launched kernel,\n',
  '        secondary clients can be connected, simply with:\n',
  '\n',
  '        $> ipython <app> --existing\n',
  '\n',
  '        """\n',
  '\n',
  '        from IPython.core.application import BaseIPythonApplication as BaseIPApp\n',
  '\n',
  '        if BaseIPApp.initialized():\n',
  '            app = BaseIPApp.instance()\n',
  '            security_dir = app.profile_dir.security_dir\n',
  '            profile = app.profile\n',
  '        else:\n',
  "            profile = 'default'\n",
  "            security_dir = ''\n",
  '\n',
  '        try:\n',
  '            connection_file = get_connection_file()\n',
  '            info = get_connection_info(unpack=False)\n',
  '        except Exception as e:\n',
  '            error("Could not get connection info: %r" % e)\n',
  '            return\n',
  '\n',
  '        # add profile flag for non-default profile\n',
  '        profile_flag = "--profile %s" % profile if profile != \'default\' else ""\n',
  '\n',
  "        # if it's in the security dir, truncate to basename\n",
  '        if security_dir == os.path.dirname(connection_file):\n',
  '            connection_file = os.path.basename(connection_file)\n',
  '\n',
  '\n',
  "        print (info + '\\n')\n",
  '        print ("Paste the above JSON into a file, and connect with:\\n"\n',
  '            "    $> ipython <app> --existing <file>\\n"\n',
  '            "or, if you are local, you can connect with just:\\n"\n',
  '            "    $> ipython <app> --existing {0} {1}\\n"\n',
  '            "or even just:\\n"\n',
  '            "    $> ipython <app> --existing {1}\\n"\n',
  '            "if this is the most recent IPython session you have started.".format(\n',
  '            connection_file, profile_flag\n',
  '            )\n',
  '        )\n',
  '\n',
  '    @line_magic\n',
  '    def qtconsole(self, arg_s):\n',
  '        """Open a qtconsole connected to this kernel.\n',
  '\n',
  '        Useful for connecting a qtconsole to running notebooks, for better\n',
  '        debugging.\n',
  '        """\n',
  '\n',
  '        # %qtconsole should imply bind_kernel for engines:\n',
  '        # FIXME: move to ipyparallel Kernel subclass\n',
  "        if 'ipyparallel' in sys.modules:\n",
  '            from ipyparallel import bind_kernel\n',
  '            bind_kernel()\n',
  '\n',
  '        try:\n',
  "            p = connect_qtconsole(argv=arg_split(arg_s, os.name=='posix'))\n",
  '        except Exception as e:\n',
  '            error("Could not start qtconsole: %r" % e)\n',
  '            return\n',
  '\n',
  '    @line_magic\n',
  '    def autosave(self, arg_s):\n',
  '        """Set the autosave interval in the notebook (in seconds).\n',
  '\n',
  '        The default value is 120, or two minutes.\n',
  '        ``%autosave 0`` will disable autosave.\n',
  '\n',
  '        This magic only has an effect when called from the notebook interface.\n',
  '        It has no effect when called in a startup file.\n',
  '        """\n',
  '\n',
  '        try:\n',
  '            interval = int(arg_s)\n',
  '        except ValueError:\n',
  '            raise UsageError("%%autosave requires an integer, got %r" % arg_s)\n',
  '\n',
  '        # javascript wants milliseconds\n',
  '        milliseconds = 1000 * interval\n',
  '        display(Javascript("IPython.notebook.set_autosave_interval(%i)" % milliseconds),\n',
  "            include=['application/javascript']\n",
  '        )\n',
  '        if interval:\n',
  '            print("Autosaving every %i seconds" % interval)\n',
  '        else:\n',
  '            print("Autosave disabled")\n',
  '\n',
  '\n',
  'class ZMQInteractiveShell(InteractiveShell):\n',
  '    """A subclass of InteractiveShell for ZMQ."""\n',
  '\n',
  '    displayhook_class = Type(ZMQShellDisplayHook)\n',
  '    display_pub_class = Type(ZMQDisplayPublisher)\n',
  "    data_pub_class = Type('ipykernel.datapub.ZMQDataPublisher')\n",
  '    kernel = Any()\n',
  '    parent_header = Any()\n',
  '\n',
  '    def _banner1_default(self):\n',
  '        return default_banner\n',
  '\n',
  "    # Override the traitlet in the parent class, because there's no point using\n",
  '    # readline for the kernel. Can be removed when the readline code is moved\n',
  '    # to the terminal frontend.\n',
  '    colors_force = CBool(True)\n',
  '    readline_use = CBool(False)\n',
  '    # autoindent has no meaning in a zmqshell, and attempting to enable it\n',
  '    # will print a warning in the absence of readline.\n',
  '    autoindent = CBool(False)\n',
  '\n',
  '    exiter = Instance(ZMQExitAutocall)\n',
  '    def _exiter_default(self):\n',
  '        return ZMQExitAutocall(self)\n',
  '\n',
  '    def _exit_now_changed(self, name, old, new):\n',
  '        """stop eventloop when exit_now fires"""\n',
  '        if new:\n',
  '            loop = ioloop.IOLoop.instance()\n',
  '            loop.add_timeout(time.time()+0.1, loop.stop)\n',
  '\n',
  '    keepkernel_on_exit = None\n',
  '\n',
  "    # Over ZeroMQ, GUI control isn't done with PyOS_InputHook as there is no\n",
  '    # interactive input being read; we provide event loop support in ipkernel\n',
  '    @staticmethod\n',
  '    def enable_gui(gui):\n',
  '        from .eventloops import enable_gui as real_enable_gui\n',
  '        try:\n',
  '            real_enable_gui(gui)\n',
  '        except ValueError as e:\n',
  '            raise UsageError("%s" % e)\n',
  '\n',
  '    def init_environment(self):\n',
  '        """Configure the user\'s environment."""\n',
  '        env = os.environ\n',
  "        # These two ensure 'ls' produces nice coloring on BSD-derived systems\n",
  "        env['TERM'] = 'xterm-color'\n",
  "        env['CLICOLOR'] = '1'\n",
  "        # Since normal pagers don't work at all (over pexpect we don't have\n",
  '        # single-key control of the subprocess), try to disable paging in\n',
  '        # subprocesses as much as possible.\n',
  "        env['PAGER'] = 'cat'\n",
  "        env['GIT_PAGER'] = 'cat'\n",
  '\n',
  '    def init_hooks(self):\n',
  '        super(ZMQInteractiveShell, self).init_hooks()\n',
  "        self.set_hook('show_in_pager', page.as_hook(payloadpage.page), 99)\n",
  '    \n',
  '    def init_data_pub(self):\n',
  '        """Delay datapub init until request, for deprecation warnings"""\n',
  '        pass\n',
  '    \n',
  '    @property\n',
  '    def data_pub(self):\n',
  "        if not hasattr(self, '_data_pub'):\n",
  '            warnings.warn("InteractiveShell.data_pub is deprecated outside IPython parallel.", \n',
  '                DeprecationWarning, stacklevel=2)\n',
  '            \n',
  '            self._data_pub = self.data_pub_class(parent=self)\n',
  '            self._data_pub.session = self.display_pub.session\n',
  '            self._data_pub.pub_socket = self.display_pub.pub_socket\n',
  '        return self._data_pub\n',
  '    \n',
  '    @data_pub.setter\n',
  '    def data_pub(self, pub):\n',
  '        self._data_pub = pub\n',
  '\n',
  '    def ask_exit(self):\n',
  '        """Engage the exit actions."""\n',
  '        self.exit_now = (not self.keepkernel_on_exit)\n',
  '        payload = dict(\n',
  "            source='ask_exit',\n",
  '            keepkernel=self.keepkernel_on_exit,\n',
  '            )\n',
  '        self.payload_manager.write_payload(payload)\n',
  '\n',
  '    def _showtraceback(self, etype, evalue, stb):\n',
  '        # try to preserve ordering of tracebacks and print statements\n',
  '        sys.stdout.flush()\n',
  '        sys.stderr.flush()\n',
  '\n',
  '        exc_content = {\n',
  "            u'traceback' : stb,\n",
  "            u'ename' : unicode_type(etype.__name__),\n",
  "            u'evalue' : py3compat.safe_unicode(evalue),\n",
  '        }\n',
  '\n',
  '        dh = self.displayhook\n',
  '        # Send exception info over pub socket for other clients than the caller\n',
  '        # to pick up\n',
  '        topic = None\n',
  '        if dh.topic:\n',
  "            topic = dh.topic.replace(b'execute_result', b'error')\n",
  '\n',
  "        exc_msg = dh.session.send(dh.pub_socket, u'error', json_clean(exc_content), dh.parent_header, ident=topic)\n",
  '\n',
  '        # FIXME - Hack: store exception info in shell object.  Right now, the\n',
  '        # caller is reading this info after the fact, we need to fix this logic\n',
  '        # to remove this hack.  Even uglier, we need to store the error status\n',
  '        # here, because in the main loop, the logic that sets it is being\n',
  '        # skipped because runlines swallows the exceptions.\n',
  "        exc_content[u'status'] = u'error'\n",
  '        self._reply_content = exc_content\n',
  '        # /FIXME\n',
  '\n',
  '        return exc_content\n',
  '\n',
  '    def set_next_input(self, text, replace=False):\n',
  '        """Send the specified text to the frontend to be presented at the next\n',
  '        input cell."""\n',
  '        payload = dict(\n',
  "            source='set_next_input',\n",
  '            text=text,\n',
  '            replace=replace,\n',
  '        )\n',
  '        self.payload_manager.write_payload(payload)\n',
  '\n',
  '    def set_parent(self, parent):\n',
  '        """Set the parent header for associating output with its triggering input"""\n',
  '        self.parent_header = parent\n',
  '        self.displayhook.set_parent(parent)\n',
  '        self.display_pub.set_parent(parent)\n',
  "        if hasattr(self, '_data_pub'):\n",
  '            self.data_pub.set_parent(parent)\n',
  '        try:\n',
  '            sys.stdout.set_parent(parent)\n',
  '        except AttributeError:\n',
  '            pass\n',
  '        try:\n',
  '            sys.stderr.set_parent(parent)\n',
  '        except AttributeError:\n',
  '            pass\n',
  '\n',
  '    def get_parent(self):\n',
  '        return self.parent_header\n',
  '\n',
  '    #-------------------------------------------------------------------------\n',
  '    # Things related to magics\n',
  '    #-------------------------------------------------------------------------\n',
  '\n',
  '    def init_magics(self):\n',
  '        super(ZMQInteractiveShell, self).init_magics()\n',
  '        self.register_magics(KernelMagics)\n',
  "        self.magics_manager.register_alias('ed', 'edit')\n",
  '\n',
  '\n',
  'InteractiveShellABC.register(ZMQInteractiveShell)\n'],
 ModuleSpec(name='ipykernel.datapub', loader=<_frozen_importlib.SourceFileLoader object at 0x7f51c124b780>, origin='/home/pasha/.local/lib/python3.4/site-packages/ipykernel/datapub.py'),
 <_frozen_importlib.SourceFileLoader at 0x7f51c124b780>,
 <_frozen_importlib.SourceFileLoader at 0x7f51c124b4a8>,
 ModuleSpec(name='ipykernel.serialize', loader=<_frozen_importlib.SourceFileLoader object at 0x7f51c124b4a8>, origin='/home/pasha/.local/lib/python3.4/site-packages/ipykernel/serialize.py'),
 ModuleSpec(name='ipykernel.pickleutil', loader=<_frozen_importlib.SourceFileLoader object at 0x7f51c124b4e0>, origin='/home/pasha/.local/lib/python3.4/site-packages/ipykernel/pickleutil.py'),
 <_frozen_importlib.SourceFileLoader at 0x7f51c124b4e0>,
 ModuleSpec(name='ipykernel.codeutil', loader=<_frozen_importlib.SourceFileLoader object at 0x7f51c01a6278>, origin='/home/pasha/.local/lib/python3.4/site-packages/ipykernel/codeutil.py'),
 <_frozen_importlib.SourceFileLoader at 0x7f51c01a6278>,
 {'__dict__': <attribute '__dict__' of 'CannedObject' objects>,
  '__doc__': None,
  '__init__': <function ipykernel.pickleutil.CannedObject.__init__>,
  '__module__': 'ipykernel.pickleutil',
  '__weakref__': <attribute '__weakref__' of 'CannedObject' objects>,
  'get_object': <function ipykernel.pickleutil.CannedObject.get_object>},
 {'__doc__': 'object for wrapping a remote reference by name.',
  '__init__': <function ipykernel.pickleutil.Reference.__init__>,
  '__module__': 'ipykernel.pickleutil',
  '__repr__': <function ipykernel.pickleutil.Reference.__repr__>,
  'get_object': <function ipykernel.pickleutil.Reference.get_object>},
 (ipykernel.pickleutil.CannedObject,),
 <weakref at 0x7f51c0199c28; to 'type' at 0x55b8f537b178 (Reference)>,
 {'__doc__': 'Can a closure cell',
  '__init__': <function ipykernel.pickleutil.CannedCell.__init__>,
  '__module__': 'ipykernel.pickleutil',
  'get_object': <function ipykernel.pickleutil.CannedCell.get_object>},
 (ipykernel.pickleutil.CannedObject,),
 {'__doc__': None,
  '__init__': <function ipykernel.pickleutil.CannedFunction.__init__>,
  '__module__': 'ipykernel.pickleutil',
  '_check_type': <function ipykernel.pickleutil.CannedFunction._check_type>,
  'get_object': <function ipykernel.pickleutil.CannedFunction.get_object>},
 (ipykernel.pickleutil.CannedObject,),
 {'__doc__': None,
  '__init__': <function ipykernel.pickleutil.CannedClass.__init__>,
  '__module__': 'ipykernel.pickleutil',
  '_check_type': <function ipykernel.pickleutil.CannedClass._check_type>,
  'get_object': <function ipykernel.pickleutil.CannedClass.get_object>},
 (ipykernel.pickleutil.CannedObject,),
 {'__doc__': None,
  '__init__': <function ipykernel.pickleutil.CannedArray.__init__>,
  '__module__': 'ipykernel.pickleutil',
  'get_object': <function ipykernel.pickleutil.CannedArray.get_object>},
 (ipykernel.pickleutil.CannedObject,),
 {'__doc__': None,
  '__init__': <function ipykernel.pickleutil.CannedBytes.__init__>,
  '__module__': 'ipykernel.pickleutil',
  'get_object': <function ipykernel.pickleutil.CannedBytes.get_object>,
  'wrap': <staticmethod at 0x7f51c01a6438>},
 (ipykernel.pickleutil.CannedObject,),
 (ipykernel.pickleutil.CannedBytes,),
 <weakref at 0x7f51c0199e08; to 'type' at 0x55b8f537cc48 (CannedBuffer)>,
 (ipykernel.pickleutil.CannedBytes,),
 <function ipykernel.pickleutil.<lambda>>,
 {'__doc__': None,
  '__module__': 'ipykernel.datapub',
  '_trait_default_generators': {},
  'parent_header': <traitlets.traitlets.Dict at 0x7f51c124b550>,
  'pub_socket': <traitlets.traitlets.Any at 0x7f51c124b630>,
  'publish_data': <function ipykernel.datapub.ZMQDataPublisher.publish_data>,
  'session': <traitlets.traitlets.Instance at 0x7f51c124b5f8>,
  'set_parent': <function ipykernel.datapub.ZMQDataPublisher.set_parent>,
  'topic': <traitlets.traitlets.CBytes at 0x7f51c124b6d8>},
 (traitlets.config.configurable.Configurable,),
 ['# -*- coding: utf-8 -*-\n',
  '"""Main IPython class."""\n',
  '\n',
  '#-----------------------------------------------------------------------------\n',
  '#  Copyright (C) 2001 Janko Hauser <jhauser@zscout.de>\n',
  '#  Copyright (C) 2001-2007 Fernando Perez. <fperez@colorado.edu>\n',
  '#  Copyright (C) 2008-2011  The IPython Development Team\n',
  '#\n',
  '#  Distributed under the terms of the BSD License.  The full license is in\n',
  '#  the file COPYING, distributed as part of this software.\n',
  '#-----------------------------------------------------------------------------\n',
  '\n',
  'from __future__ import absolute_import, print_function\n',
  '\n',
  'import __future__\n',
  'import abc\n',
  'import ast\n',
  'import atexit\n',
  'import functools\n',
  'import os\n',
  'import re\n',
  'import runpy\n',
  'import sys\n',
  'import tempfile\n',
  'import traceback\n',
  'import types\n',
  'import subprocess\n',
  'import warnings\n',
  'from io import open as io_open\n',
  '\n',
  'from pickleshare import PickleShareDB\n',
  '\n',
  'from traitlets.config.configurable import SingletonConfigurable\n',
  'from IPython.core import debugger, oinspect\n',
  'from IPython.core import magic\n',
  'from IPython.core import page\n',
  'from IPython.core import prefilter\n',
  'from IPython.core import shadowns\n',
  'from IPython.core import ultratb\n',
  'from IPython.core.alias import Alias, AliasManager\n',
  'from IPython.core.autocall import ExitAutocall\n',
  'from IPython.core.builtin_trap import BuiltinTrap\n',
  'from IPython.core.events import EventManager, available_events\n',
  'from IPython.core.compilerop import CachingCompiler, check_linecache_ipython\n',
  'from IPython.core.display_trap import DisplayTrap\n',
  'from IPython.core.displayhook import DisplayHook\n',
  'from IPython.core.displaypub import DisplayPublisher\n',
  'from IPython.core.error import InputRejected, UsageError\n',
  'from IPython.core.extensions import ExtensionManager\n',
  'from IPython.core.formatters import DisplayFormatter\n',
  'from IPython.core.history import HistoryManager\n',
  'from IPython.core.inputsplitter import IPythonInputSplitter, ESC_MAGIC, ESC_MAGIC2\n',
  'from IPython.core.logger import Logger\n',
  'from IPython.core.macro import Macro\n',
  'from IPython.core.payload import PayloadManager\n',
  'from IPython.core.prefilter import PrefilterManager\n',
  'from IPython.core.profiledir import ProfileDir\n',
  'from IPython.core.prompts import PromptManager\n',
  'from IPython.core.usage import default_banner\n',
  'from IPython.testing.skipdoctest import skip_doctest\n',
  'from IPython.utils import PyColorize\n',
  'from IPython.utils import io\n',
  'from IPython.utils import py3compat\n',
  'from IPython.utils import openpy\n',
  'from IPython.utils.contexts import NoOpContext\n',
  'from IPython.utils.decorators import undoc\n',
  'from IPython.utils.io import ask_yes_no\n',
  'from IPython.utils.ipstruct import Struct\n',
  'from IPython.paths import get_ipython_dir\n',
  'from IPython.utils.path import get_home_dir, get_py_filename, unquote_filename, ensure_dir_exists\n',
  'from IPython.utils.process import system, getoutput\n',
  'from IPython.utils.py3compat import (builtin_mod, unicode_type, string_types,\n',
  '                                     with_metaclass, iteritems)\n',
  'from IPython.utils.strdispatch import StrDispatch\n',
  'from IPython.utils.syspathcontext import prepended_to_syspath\n',
  'from IPython.utils.text import (format_screen, LSString, SList,\n',
  '                                DollarFormatter)\n',
  'from traitlets import (Integer, Bool, CBool, CaselessStrEnum, Enum,\n',
  '                                     List, Dict, Unicode, Instance, Type)\n',
  'from IPython.utils.warn import warn, error\n',
  'import IPython.core.hooks\n',
  '\n',
  '#-----------------------------------------------------------------------------\n',
  '# Globals\n',
  '#-----------------------------------------------------------------------------\n',
  '\n',
  '# compiled regexps for autoindent management\n',
  "dedent_re = re.compile(r'^\\s+raise|^\\s+return|^\\s+pass')\n",
  '\n',
  '#-----------------------------------------------------------------------------\n',
  '# Utilities\n',
  '#-----------------------------------------------------------------------------\n',
  '\n',
  '@undoc\n',
  'def softspace(file, newvalue):\n',
  '    """Copied from code.py, to remove the dependency"""\n',
  '\n',
  '    oldvalue = 0\n',
  '    try:\n',
  '        oldvalue = file.softspace\n',
  '    except AttributeError:\n',
  '        pass\n',
  '    try:\n',
  '        file.softspace = newvalue\n',
  '    except (AttributeError, TypeError):\n',
  '        # "attribute-less object" or "read-only attributes"\n',
  '        pass\n',
  '    return oldvalue\n',
  '\n',
  '@undoc\n',
  'def no_op(*a, **kw): pass\n',
  '\n',
  '\n',
  'class SpaceInInput(Exception): pass\n',
  '\n',
  '@undoc\n',
  'class Bunch: pass\n',
  '\n',
  '\n',
  'def get_default_colors():\n',
  "    if sys.platform=='darwin':\n",
  '        return "LightBG"\n',
  "    elif os.name=='nt':\n",
  "        return 'Linux'\n",
  '    else:\n',
  "        return 'Linux'\n",
  '\n',
  '\n',
  'class SeparateUnicode(Unicode):\n',
  '    r"""A Unicode subclass to validate separate_in, separate_out, etc.\n',
  '\n',
  "    This is a Unicode based trait that converts '0'->'' and ``'\\\\n'->'\\n'``.\n",
  '    """\n',
  '\n',
  '    def validate(self, obj, value):\n',
  "        if value == '0': value = ''\n",
  "        value = value.replace('\\\\n','\\n')\n",
  '        return super(SeparateUnicode, self).validate(obj, value)\n',
  '\n',
  '\n',
  '@undoc\n',
  'class DummyMod(object):\n',
  '    """A dummy module used for IPython\'s interactive module when\n',
  '    a namespace must be assigned to the module\'s __dict__."""\n',
  '    pass\n',
  '\n',
  '\n',
  'class ExecutionResult(object):\n',
  '    """The result of a call to :meth:`InteractiveShell.run_cell`\n',
  '\n',
  '    Stores information about what took place.\n',
  '    """\n',
  '    execution_count = None\n',
  '    error_before_exec = None\n',
  '    error_in_exec = None\n',
  '    result = None\n',
  '\n',
  '    @property\n',
  '    def success(self):\n',
  '        return (self.error_before_exec is None) and (self.error_in_exec is None)\n',
  '\n',
  '    def raise_error(self):\n',
  '        """Reraises error if `success` is `False`, otherwise does nothing"""\n',
  '        if self.error_before_exec is not None:\n',
  '            raise self.error_before_exec\n',
  '        if self.error_in_exec is not None:\n',
  '            raise self.error_in_exec\n',
  '\n',
  '\n',
  'class InteractiveShell(SingletonConfigurable):\n',
  '    """An enhanced, interactive shell for Python."""\n',
  '\n',
  '    _instance = None\n',
  '    \n',
  '    ast_transformers = List([], config=True, help=\n',
  '        """\n',
  '        A list of ast.NodeTransformer subclass instances, which will be applied\n',
  '        to user input before code is run.\n',
  '        """\n',
  '    )\n',
  '\n',
  '    autocall = Enum((0,1,2), default_value=0, config=True, help=\n',
  '        """\n',
  "        Make IPython automatically call any callable object even if you didn't\n",
  "        type explicit parentheses. For example, 'str 43' becomes 'str(43)'\n",
  "        automatically. The value can be '0' to disable the feature, '1' for\n",
  "        'smart' autocall, where it is not applied if there are no more\n",
  "        arguments on the line, and '2' for 'full' autocall, where all callable\n",
  '        objects are automatically called (even if no arguments are present).\n',
  '        """\n',
  '    )\n',
  '    # TODO: remove all autoindent logic and put into frontends.\n',
  "    # We can't do this yet because even runlines uses the autoindent.\n",
  '    autoindent = CBool(True, config=True, help=\n',
  '        """\n',
  '        Autoindent IPython code entered interactively.\n',
  '        """\n',
  '    )\n',
  '    automagic = CBool(True, config=True, help=\n',
  '        """\n',
  '        Enable magic commands to be called without the leading %.\n',
  '        """\n',
  '    )\n',
  '    \n',
  '    banner1 = Unicode(default_banner, config=True,\n',
  '        help="""The part of the banner to be printed before the profile"""\n',
  '    )\n',
  "    banner2 = Unicode('', config=True,\n",
  '        help="""The part of the banner to be printed after the profile"""\n',
  '    )\n',
  '\n',
  '    cache_size = Integer(1000, config=True, help=\n',
  '        """\n',
  '        Set the size of the output cache.  The default is 1000, you can\n',
  '        change it permanently in your config file.  Setting it to 0 completely\n',
  '        disables the caching system, and the minimum value accepted is 20 (if\n',
  '        you provide a value less than 20, it is reset to 0 and a warning is\n',
  "        issued).  This limit is defined because otherwise you'll spend more\n",
  '        time re-flushing a too small cache than working\n',
  '        """\n',
  '    )\n',
  '    color_info = CBool(True, config=True, help=\n',
  '        """\n',
  '        Use colors for displaying information about objects. Because this\n',
  "        information is passed through a pager (like 'less'), and some pagers\n",
  '        get confused with color codes, this capability can be turned off.\n',
  '        """\n',
  '    )\n',
  "    colors = CaselessStrEnum(('NoColor','LightBG','Linux'),\n",
  '                             default_value=get_default_colors(), config=True,\n',
  '        help="Set the color scheme (NoColor, Linux, or LightBG)."\n',
  '    )\n',
  '    colors_force = CBool(False, help=\n',
  '        """\n',
  '        Force use of ANSI color codes, regardless of OS and readline\n',
  '        availability.\n',
  '        """\n',
  '        # FIXME: This is essentially a hack to allow ZMQShell to show colors\n',
  '        # without readline on Win32. When the ZMQ formatting system is\n',
  '        # refactored, this should be removed.\n',
  '    )\n',
  '    debug = CBool(False, config=True)\n',
  '    deep_reload = CBool(False, config=True, help=\n',
  '        """\n',
  '        **Deprecated**\n',
  '\n',
  '        Will be removed in IPython 6.0\n',
  '\n',
  '        Enable deep (recursive) reloading by default. IPython can use the\n',
  '        deep_reload module which reloads changes in modules recursively (it\n',
  "        replaces the reload() function, so you don't need to change anything to\n",
  '        use it). `deep_reload` forces a full reload of modules whose code may\n',
  '        have changed, which the default reload() function does not.  When\n',
  '        deep_reload is off, IPython will use the normal reload(), but\n',
  '        deep_reload will still be available as dreload().\n',
  '        """\n',
  '    )\n',
  '    disable_failing_post_execute = CBool(False, config=True,\n',
  '        help="Don\'t call post-execute functions that have failed in the past."\n',
  '    )\n',
  '    display_formatter = Instance(DisplayFormatter, allow_none=True)\n',
  '    displayhook_class = Type(DisplayHook)\n',
  '    display_pub_class = Type(DisplayPublisher)\n',
  '    data_pub_class = None\n',
  '\n',
  '    exit_now = CBool(False)\n',
  '    exiter = Instance(ExitAutocall)\n',
  '    def _exiter_default(self):\n',
  '        return ExitAutocall(self)\n',
  '    # Monotonically increasing execution counter\n',
  '    execution_count = Integer(1)\n',
  '    filename = Unicode("<ipython console>")\n',
  "    ipython_dir= Unicode('', config=True) # Set to get_ipython_dir() in __init__\n",
  '\n',
  '    # Input splitter, to transform input line by line and detect when a block\n',
  '    # is ready to be executed.\n',
  "    input_splitter = Instance('IPython.core.inputsplitter.IPythonInputSplitter',\n",
  "                              (), {'line_input_checker': True})\n",
  '    \n',
  '    # This InputSplitter instance is used to transform completed cells before\n',
  '    # running them. It allows cell magics to contain blank lines.\n',
  "    input_transformer_manager = Instance('IPython.core.inputsplitter.IPythonInputSplitter',\n",
  "                                         (), {'line_input_checker': False})\n",
  '    \n',
  '    logstart = CBool(False, config=True, help=\n',
  '        """\n',
  '        Start logging to the default log file in overwrite mode.\n',
  '        Use `logappend` to specify a log file to **append** logs to.\n',
  '        """\n',
  '    )\n',
  "    logfile = Unicode('', config=True, help=\n",
  '        """\n',
  '        The name of the logfile to use.\n',
  '        """\n',
  '    )\n',
  "    logappend = Unicode('', config=True, help=\n",
  '        """\n',
  '        Start logging to the given file in append mode.\n',
  '        Use `logfile` to specify a log file to **overwrite** logs to.\n',
  '        """\n',
  '    )\n',
  '    object_info_string_level = Enum((0,1,2), default_value=0,\n',
  '                                    config=True)\n',
  '    pdb = CBool(False, config=True, help=\n',
  '        """\n',
  '        Automatically call the pdb debugger after every exception.\n',
  '        """\n',
  '    )\n',
  "    multiline_history = CBool(sys.platform != 'win32', config=True,\n",
  '        help="Save multi-line entries as one entry in readline history"\n',
  '    )\n',
  '    display_page = Bool(False, config=True,\n',
  '        help="""If True, anything that would be passed to the pager\n',
  '        will be displayed as regular output instead."""\n',
  '    )\n',
  '\n',
  '    # deprecated prompt traits:\n',
  '    \n',
  "    prompt_in1 = Unicode('In [\\\\#]: ', config=True,\n",
  '        help="Deprecated, will be removed in IPython 5.0, use PromptManager.in_template")\n',
  "    prompt_in2 = Unicode('   .\\\\D.: ', config=True,\n",
  '        help="Deprecated, will be removed in IPython 5.0, use PromptManager.in2_template")\n',
  "    prompt_out = Unicode('Out[\\\\#]: ', config=True,\n",
  '        help="Deprecated, will be removed in IPython 5.0, use PromptManager.out_template")\n',
  '    prompts_pad_left = CBool(True, config=True,\n',
  '        help="Deprecated, will be removed in IPython 5.0, use PromptManager.justify")\n',
  '    \n',
  '    def _prompt_trait_changed(self, name, old, new):\n',
  '        table = {\n',
  "            'prompt_in1' : 'in_template',\n",
  "            'prompt_in2' : 'in2_template',\n",
  "            'prompt_out' : 'out_template',\n",
  "            'prompts_pad_left' : 'justify',\n",
  '        }\n',
  '        warn("InteractiveShell.{name} is deprecated, use PromptManager.{newname}".format(\n',
  '                name=name, newname=table[name])\n',
  '        )\n',
  '        # protect against weird cases where self.config may not exist:\n',
  '        if self.config is not None:\n',
  '            # propagate to corresponding PromptManager trait\n',
  '            setattr(self.config.PromptManager, table[name], new)\n',
  '    \n',
  '    _prompt_in1_changed = _prompt_trait_changed\n',
  '    _prompt_in2_changed = _prompt_trait_changed\n',
  '    _prompt_out_changed = _prompt_trait_changed\n',
  '    _prompt_pad_left_changed = _prompt_trait_changed\n',
  '    \n',
  '    show_rewritten_input = CBool(True, config=True,\n',
  '        help="Show rewritten input, e.g. for autocall."\n',
  '    )\n',
  '    \n',
  '    quiet = CBool(False, config=True)\n',
  '\n',
  '    history_length = Integer(10000, config=True)\n',
  '\n',
  '    history_load_length = Integer(1000, config=True, help=\n',
  '        """\n',
  '        The number of saved history entries to be loaded\n',
  '        into the readline buffer at startup.\n',
  '        """\n',
  '    )\n',
  '\n',
  '    # The readline stuff will eventually be moved to the terminal subclass\n',
  "    # but for now, we can't do that as readline is welded in everywhere.\n",
  '    readline_use = CBool(True, config=True)\n',
  "    readline_remove_delims = Unicode('-/~', config=True)\n",
  '    readline_delims = Unicode() # set by init_readline()\n',
  "    # don't use \\M- bindings by default, because they\n",
  '    # conflict with 8-bit encodings. See gh-58,gh-88\n',
  '    readline_parse_and_bind = List([\n',
  "            'tab: complete',\n",
  '            \'"\\C-l": clear-screen\',\n',
  "            'set show-all-if-ambiguous on',\n",
  '            \'"\\C-o": tab-insert\',\n',
  '            \'"\\C-r": reverse-search-history\',\n',
  '            \'"\\C-s": forward-search-history\',\n',
  '            \'"\\C-p": history-search-backward\',\n',
  '            \'"\\C-n": history-search-forward\',\n',
  '            \'"\\e[A": history-search-backward\',\n',
  '            \'"\\e[B": history-search-forward\',\n',
  '            \'"\\C-k": kill-line\',\n',
  '            \'"\\C-u": unix-line-discard\',\n',
  '        ], config=True)\n',
  '    \n',
  '    _custom_readline_config = False\n',
  '    \n',
  '    def _readline_parse_and_bind_changed(self, name, old, new):\n',
  '        # notice that readline config is customized\n',
  '        # indicates that it should have higher priority than inputrc\n',
  '        self._custom_readline_config = True\n',
  '    \n',
  "    ast_node_interactivity = Enum(['all', 'last', 'last_expr', 'none'],\n",
  "                                  default_value='last_expr', config=True, \n",
  '                                  help="""\n',
  "        'all', 'last', 'last_expr' or 'none', specifying which nodes should be\n",
  '        run interactively (displaying output from expressions).""")\n',
  '\n',
  '    # TODO: this part of prompt management should be moved to the frontends.\n',
  "    # Use custom TraitTypes that convert '0'->'' and '\\\\n'->'\\n'\n",
  "    separate_in = SeparateUnicode('\\n', config=True)\n",
  "    separate_out = SeparateUnicode('', config=True)\n",
  "    separate_out2 = SeparateUnicode('', config=True)\n",
  '    wildcards_case_sensitive = CBool(True, config=True)\n',
  "    xmode = CaselessStrEnum(('Context','Plain', 'Verbose'),\n",
  "                            default_value='Context', config=True)\n",
  '\n',
  '    # Subcomponents of InteractiveShell\n',
  "    alias_manager = Instance('IPython.core.alias.AliasManager', allow_none=True)\n",
  "    prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager', allow_none=True)\n",
  "    builtin_trap = Instance('IPython.core.builtin_trap.BuiltinTrap', allow_none=True)\n",
  "    display_trap = Instance('IPython.core.display_trap.DisplayTrap', allow_none=True)\n",
  "    extension_manager = Instance('IPython.core.extensions.ExtensionManager', allow_none=True)\n",
  "    payload_manager = Instance('IPython.core.payload.PayloadManager', allow_none=True)\n",
  "    history_manager = Instance('IPython.core.history.HistoryAccessorBase', allow_none=True)\n",
  "    magics_manager = Instance('IPython.core.magic.MagicsManager', allow_none=True)\n",
  '\n',
  "    profile_dir = Instance('IPython.core.application.ProfileDir', allow_none=True)\n",
  '    @property\n',
  '    def profile(self):\n',
  '        if self.profile_dir is not None:\n',
  '            name = os.path.basename(self.profile_dir.location)\n',
  "            return name.replace('profile_','')\n",
  '\n',
  '\n',
  '    # Private interface\n',
  '    _post_execute = Dict()\n',
  '\n',
  '    # Tracks any GUI loop loaded for pylab\n',
  '    pylab_gui_select = None\n',
  '\n',
  '    def __init__(self, ipython_dir=None, profile_dir=None,\n',
  '                 user_module=None, user_ns=None,\n',
  '                 custom_exceptions=((), None), **kwargs):\n',
  '\n',
  '        # This is where traits with a config_key argument are updated\n',
  '        # from the values on config.\n',
  '        super(InteractiveShell, self).__init__(**kwargs)\n',
  '        self.configurables = [self]\n',
  '\n',
  '        # These are relatively independent and stateless\n',
  '        self.init_ipython_dir(ipython_dir)\n',
  '        self.init_profile_dir(profile_dir)\n',
  '        self.init_instance_attrs()\n',
  '        self.init_environment()\n',
  '        \n',
  "        # Check if we're in a virtualenv, and set up sys.path.\n",
  '        self.init_virtualenv()\n',
  '\n',
  '        # Create namespaces (user_ns, user_global_ns, etc.)\n',
  '        self.init_create_namespaces(user_module, user_ns)\n',
  '        # This has to be done after init_create_namespaces because it uses\n',
  '        # something in self.user_ns, but before init_sys_modules, which\n',
  '        # is the first thing to modify sys.\n',
  '        # TODO: When we override sys.stdout and sys.stderr before this class\n',
  '        # is created, we are saving the overridden ones here. Not sure if this\n',
  '        # is what we want to do.\n',
  '        self.save_sys_module_state()\n',
  '        self.init_sys_modules()\n',
  '\n',
  "        # While we're trying to have each part of the code directly access what\n",
  '        # it needs without keeping redundant references to objects, we have too\n',
  '        # much legacy code that expects ip.db to exist.\n',
  "        self.db = PickleShareDB(os.path.join(self.profile_dir.location, 'db'))\n",
  '\n',
  '        self.init_history()\n',
  '        self.init_encoding()\n',
  '        self.init_prefilter()\n',
  '\n',
  '        self.init_syntax_highlighting()\n',
  '        self.init_hooks()\n',
  '        self.init_events()\n',
  '        self.init_pushd_popd_magic()\n',
  '        # self.init_traceback_handlers use to be here, but we moved it below\n',
  '        # because it and init_io have to come after init_readline.\n',
  '        self.init_user_ns()\n',
  '        self.init_logger()\n',
  '        self.init_builtins()\n',
  '\n',
  '        # The following was in post_config_initialization\n',
  '        self.init_inspector()\n',
  '        # init_readline() must come before init_io(), because init_io uses\n',
  '        # readline related things.\n',
  '        self.init_readline()\n',
  '        # We save this here in case user code replaces raw_input, but it needs\n',
  "        # to be after init_readline(), because PyPy's readline works by replacing\n",
  '        # raw_input.\n',
  '        if py3compat.PY3:\n',
  '            self.raw_input_original = input\n',
  '        else:\n',
  '            self.raw_input_original = raw_input\n',
  '        # init_completer must come after init_readline, because it needs to\n',
  '        # know whether readline is present or not system-wide to configure the\n',
  '        # completers, since the completion machinery can now operate\n',
  '        # independently of readline (e.g. over the network)\n',
  '        self.init_completer()\n',
  '        # TODO: init_io() needs to happen before init_traceback handlers\n',
  '        # because the traceback handlers hardcode the stdout/stderr streams.\n',
  '        # This logic in in debugger.Pdb and should eventually be changed.\n',
  '        self.init_io()\n',
  '        self.init_traceback_handlers(custom_exceptions)\n',
  '        self.init_prompts()\n',
  '        self.init_display_formatter()\n',
  '        self.init_display_pub()\n',
  '        self.init_data_pub()\n',
  '        self.init_displayhook()\n',
  '        self.init_magics()\n',
  '        self.init_alias()\n',
  '        self.init_logstart()\n',
  '        self.init_pdb()\n',
  '        self.init_extension_manager()\n',
  '        self.init_payload()\n',
  '        self.init_deprecation_warnings()\n',
  '        self.hooks.late_startup_hook()\n',
  "        self.events.trigger('shell_initialized', self)\n",
  '        atexit.register(self.atexit_operations)\n',
  '\n',
  '    def get_ipython(self):\n',
  '        """Return the currently running IPython instance."""\n',
  '        return self\n',
  '\n',
  '    #-------------------------------------------------------------------------\n',
  '    # Trait changed handlers\n',
  '    #-------------------------------------------------------------------------\n',
  '\n',
  '    def _ipython_dir_changed(self, name, new):\n',
  '        ensure_dir_exists(new)\n',
  '\n',
  '    def set_autoindent(self,value=None):\n',
  '        """Set the autoindent flag, checking for readline support.\n',
  '\n',
  '        If called with no arguments, it acts as a toggle."""\n',
  '\n',
  '        if value != 0 and not self.has_readline:\n',
  "            if os.name == 'posix':\n",
  '                warn("The auto-indent feature requires the readline library")\n',
  '            self.autoindent = 0\n',
  '            return\n',
  '        if value is None:\n',
  '            self.autoindent = not self.autoindent\n',
  '        else:\n',
  '            self.autoindent = value\n',
  '\n',
  '    #-------------------------------------------------------------------------\n',
  '    # init_* methods called by __init__\n',
  '    #-------------------------------------------------------------------------\n',
  '\n',
  '    def init_ipython_dir(self, ipython_dir):\n',
  '        if ipython_dir is not None:\n',
  '            self.ipython_dir = ipython_dir\n',
  '            return\n',
  '\n',
  '        self.ipython_dir = get_ipython_dir()\n',
  '\n',
  '    def init_profile_dir(self, profile_dir):\n',
  '        if profile_dir is not None:\n',
  '            self.profile_dir = profile_dir\n',
  '            return\n',
  '        self.profile_dir =\\\n',
  "            ProfileDir.create_profile_dir_by_name(self.ipython_dir, 'default')\n",
  '\n',
  '    def init_instance_attrs(self):\n',
  '        self.more = False\n',
  '\n',
  '        # command compiler\n',
  '        self.compile = CachingCompiler()\n',
  '\n',
  '        # Make an empty namespace, which extension writers can rely on both\n',
  '        # existing and NEVER being used by ipython itself.  This gives them a\n',
  '        # convenient location for storing additional information and state\n',
  '        # their extensions may require, without fear of collisions with other\n',
  '        # ipython names that may develop later.\n',
  '        self.meta = Struct()\n',
  '\n',
  '        # Temporary files used for various purposes.  Deleted at exit.\n',
  '        self.tempfiles = []\n',
  '        self.tempdirs = []\n',
  '\n',
  '        # Keep track of readline usage (later set by init_readline)\n',
  '        self.has_readline = False\n',
  '\n',
  '        # keep track of where we started running (mainly for crash post-mortem)\n',
  '        # This is not being used anywhere currently.\n',
  '        self.starting_dir = py3compat.getcwd()\n',
  '\n',
  '        # Indentation management\n',
  '        self.indent_current_nsp = 0\n',
  '\n',
  '        # Dict to track post-execution functions that have been registered\n',
  '        self._post_execute = {}\n',
  '\n',
  '    def init_environment(self):\n',
  '        """Any changes we need to make to the user\'s environment."""\n',
  '        pass\n',
  '\n',
  '    def init_encoding(self):\n',
  '        # Get system encoding at startup time.  Certain terminals (like Emacs\n',
  '        # under Win32 have it set to None, and we need to have a known valid\n',
  '        # encoding to use in the raw_input() method\n',
  '        try:\n',
  "            self.stdin_encoding = sys.stdin.encoding or 'ascii'\n",
  '        except AttributeError:\n',
  "            self.stdin_encoding = 'ascii'\n",
  '\n',
  '    def init_syntax_highlighting(self):\n',
  '        # Python source parser/formatter for syntax highlighting\n',
  '        pyformat = PyColorize.Parser().format\n',
  "        self.pycolorize = lambda src: pyformat(src,'str',self.colors)\n",
  '\n',
  '    def init_pushd_popd_magic(self):\n',
  '        # for pushd/popd management\n',
  '        self.home_dir = get_home_dir()\n',
  '\n',
  '        self.dir_stack = []\n',
  '\n',
  '    def init_logger(self):\n',
  "        self.logger = Logger(self.home_dir, logfname='ipython_log.py',\n",
  "                             logmode='rotate')\n",
  '\n',
  '    def init_logstart(self):\n',
  '        """Initialize logging in case it was requested at the command line.\n',
  '        """\n',
  '        if self.logappend:\n',
  "            self.magic('logstart %s append' % self.logappend)\n",
  '        elif self.logfile:\n',
  "            self.magic('logstart %s' % self.logfile)\n",
  '        elif self.logstart:\n',
  "            self.magic('logstart')\n",
  '\n',
  '    def init_deprecation_warnings(self):\n',
  '        """\n',
  '        register default filter for deprecation warning.\n',
  '\n',
  '        This will allow deprecation warning of function used interactively to show\n',
  '        warning to users, and still hide deprecation warning from libraries import.\n',
  '        """\n',
  '        warnings.filterwarnings("default", category=DeprecationWarning, module=self.user_ns.get("__name__"))\n',
  '\n',
  '    def init_builtins(self):\n',
  '        # A single, static flag that we set to True.  Its presence indicates\n',
  '        # that an IPython shell has been created, and we make no attempts at\n',
  '        # removing on exit or representing the existence of more than one\n',
  '        # IPython at a time.\n',
  "        builtin_mod.__dict__['__IPYTHON__'] = True\n",
  '\n',
  "        # In 0.11 we introduced '__IPYTHON__active' as an integer we'd try to\n",
  "        # manage on enter/exit, but with all our shells it's virtually\n",
  "        # impossible to get all the cases right.  We're leaving the name in for\n",
  '        # those who adapted their codes to check for this flag, but will\n',
  '        # eventually remove it after a few more releases.\n',
  "        builtin_mod.__dict__['__IPYTHON__active'] = \\\n",
  "                                          'Deprecated, check for __IPYTHON__'\n",
  '\n',
  '        self.builtin_trap = BuiltinTrap(shell=self)\n',
  '\n',
  '    def init_inspector(self):\n',
  '        # Object inspector\n',
  '        self.inspector = oinspect.Inspector(oinspect.InspectColors,\n',
  '                                            PyColorize.ANSICodeColors,\n',
  "                                            'NoColor',\n",
  '                                            self.object_info_string_level)\n',
  '\n',
  '    def init_io(self):\n',
  '        # This will just use sys.stdout and sys.stderr. If you want to\n',
  '        # override sys.stdout and sys.stderr themselves, you need to do that\n',
  '        # *before* instantiating this class, because io holds onto\n',
  '        # references to the underlying streams.\n',
  "        if (sys.platform == 'win32' or sys.platform == 'cli') and self.has_readline:\n",
  '            io.stdout = io.stderr = io.IOStream(self.readline._outputfile)\n',
  '        else:\n',
  '            io.stdout = io.IOStream(sys.stdout)\n',
  '            io.stderr = io.IOStream(sys.stderr)\n',
  '\n',
  '    def init_prompts(self):\n',
  '        self.prompt_manager = PromptManager(shell=self, parent=self)\n',
  '        self.configurables.append(self.prompt_manager)\n',
  '        # Set system prompts, so that scripts can decide if they are running\n',
  '        # interactively.\n',
  "        sys.ps1 = 'In : '\n",
  "        sys.ps2 = '...: '\n",
  "        sys.ps3 = 'Out: '\n",
  '\n',
  '    def init_display_formatter(self):\n',
  '        self.display_formatter = DisplayFormatter(parent=self)\n',
  '        self.configurables.append(self.display_formatter)\n',
  '\n',
  '    def init_display_pub(self):\n',
  '        self.display_pub = self.display_pub_class(parent=self)\n',
  '        self.configurables.append(self.display_pub)\n',
  '\n',
  '    def init_data_pub(self):\n',
  '        if not self.data_pub_class:\n',
  '            self.data_pub = None\n',
  '            return\n',
  '        self.data_pub = self.data_pub_class(parent=self)\n',
  '        self.configurables.append(self.data_pub)\n',
  '\n',
  '    def init_displayhook(self):\n',
  '        # Initialize displayhook, set in/out prompts and printing system\n',
  '        self.displayhook = self.displayhook_class(\n',
  '            parent=self,\n',
  '            shell=self,\n',
  '            cache_size=self.cache_size,\n',
  '        )\n',
  '        self.configurables.append(self.displayhook)\n',
  '        # This is a context manager that installs/revmoes the displayhook at\n',
  '        # the appropriate time.\n',
  '        self.display_trap = DisplayTrap(hook=self.displayhook)\n',
  '\n',
  '    def init_virtualenv(self):\n',
  '        """Add a virtualenv to sys.path so the user can import modules from it.\n',
  "        This isn't perfect: it doesn't use the Python interpreter with which the\n",
  '        virtualenv was built, and it ignores the --no-site-packages option. A\n',
  '        warning will appear suggesting the user installs IPython in the\n',
  '        virtualenv, but for many cases, it probably works well enough.\n',
  '        \n',
  '        Adapted from code snippets online.\n',
  '        \n',
  '        http://blog.ufsoft.org/2009/1/29/ipython-and-virtualenv\n',
  '        """\n',
  "        if 'VIRTUAL_ENV' not in os.environ:\n",
  '            # Not in a virtualenv\n',
  '            return\n',
  '        \n',
  '        # venv detection:\n',
  "        # stdlib venv may symlink sys.executable, so we can't use realpath.\n",
  "        # but others can symlink *to* the venv Python, so we can't just use sys.executable.\n",
  '        # So we just check every item in the symlink tree (generally <= 3)\n',
  '        p = os.path.normcase(sys.executable)\n',
  '        paths = [p]\n',
  '        while os.path.islink(p):\n',
  '            p = os.path.normcase(os.path.join(os.path.dirname(p), os.readlink(p)))\n',
  '            paths.append(p)\n',
  "        p_venv = os.path.normcase(os.environ['VIRTUAL_ENV'])\n",
  '        if any(p.startswith(p_venv) for p in paths):\n',
  "            # Running properly in the virtualenv, don't need to do anything\n",
  '            return\n',
  '        \n',
  '        warn("Attempting to work in a virtualenv. If you encounter problems, please "\n',
  '             "install IPython inside the virtualenv.")\n',
  '        if sys.platform == "win32":\n',
  "            virtual_env = os.path.join(os.environ['VIRTUAL_ENV'], 'Lib', 'site-packages') \n",
  '        else:\n',
  "            virtual_env = os.path.join(os.environ['VIRTUAL_ENV'], 'lib',\n",
  "                       'python%d.%d' % sys.version_info[:2], 'site-packages')\n",
  '        \n',
  '        import site\n',
  '        sys.path.insert(0, virtual_env)\n',
  '        site.addsitedir(virtual_env)\n',
  '\n',
  '    #-------------------------------------------------------------------------\n',
  '    # Things related to injections into the sys module\n',
  '    #-------------------------------------------------------------------------\n',
  '\n',
  '    def save_sys_module_state(self):\n',
  '        """Save the state of hooks in the sys module.\n',
  '\n',
  '        This has to be called after self.user_module is created.\n',
  '        """\n',
  "        self._orig_sys_module_state = {'stdin': sys.stdin,\n",
  "                                       'stdout': sys.stdout,\n",
  "                                       'stderr': sys.stderr,\n",
  "                                       'excepthook': sys.excepthook}\n",
  '        self._orig_sys_modules_main_name = self.user_module.__name__\n',
  '        self._orig_sys_modules_main_mod = sys.modules.get(self.user_module.__name__)\n',
  '\n',
  '    def restore_sys_module_state(self):\n',
  '        """Restore the state of the sys module."""\n',
  '        try:\n',
  '            for k, v in iteritems(self._orig_sys_module_state):\n',
  '                setattr(sys, k, v)\n',
  '        except AttributeError:\n',
  '            pass\n',
  '        # Reset what what done in self.init_sys_modules\n',
  '        if self._orig_sys_modules_main_mod is not None:\n',
  '            sys.modules[self._orig_sys_modules_main_name] = self._orig_sys_modules_main_mod\n',
  '\n',
  '    #-------------------------------------------------------------------------\n',
  '    # Things related to the banner\n',
  '    #-------------------------------------------------------------------------\n',
  '    \n',
  '    @property\n',
  '    def banner(self):\n',
  '        banner = self.banner1\n',
  "        if self.profile and self.profile != 'default':\n",
  "            banner += '\\nIPython profile: %s\\n' % self.profile\n",
  '        if self.banner2:\n',
  "            banner += '\\n' + self.banner2\n",
  '        return banner\n',
  '\n',
  '    def show_banner(self, banner=None):\n',
  '        if banner is None:\n',
  '            banner = self.banner\n',
  '        self.write(banner)\n',
  '    \n',
  '    #-------------------------------------------------------------------------\n',
  '    # Things related to hooks\n',
  '    #-------------------------------------------------------------------------\n',
  '\n',
  '    def init_hooks(self):\n',
  '        # hooks holds pointers used for user-side customizations\n',
  '        self.hooks = Struct()\n',
  '\n',
  '        self.strdispatchers = {}\n',
  '\n',
  '        # Set all default hooks, defined in the IPython.hooks module.\n',
  '        hooks = IPython.core.hooks\n',
  '        for hook_name in hooks.__all__:\n',
  '            # default hooks have priority 100, i.e. low; user hooks should have\n',
  '            # 0-100 priority\n',
  '            self.set_hook(hook_name,getattr(hooks,hook_name), 100, _warn_deprecated=False)\n',
  '        \n',
  '        if self.display_page:\n',
  "            self.set_hook('show_in_pager', page.as_hook(page.display_page), 90)\n",
  '    \n',
  '    def set_hook(self,name,hook, priority=50, str_key=None, re_key=None,\n',
  '                 _warn_deprecated=True):\n',
  '        """set_hook(name,hook) -> sets an internal IPython hook.\n',
  '\n',
  '        IPython exposes some of its internal API as user-modifiable hooks.  By\n',
  "        adding your function to one of these hooks, you can modify IPython's\n",
  '        behavior to call at runtime your own routines."""\n',
  '\n',
  '        # At some point in the future, this should validate the hook before it\n',
  '        # accepts it.  Probably at least check that the hook takes the number\n',
  "        # of args it's supposed to.\n",
  '\n',
  '        f = types.MethodType(hook,self)\n',
  '\n',
  '        # check if the hook is for strdispatcher first\n',
  '        if str_key is not None:\n',
  '            sdp = self.strdispatchers.get(name, StrDispatch())\n',
  '            sdp.add_s(str_key, f, priority )\n',
  '            self.strdispatchers[name] = sdp\n',
  '            return\n',
  '        if re_key is not None:\n',
  '            sdp = self.strdispatchers.get(name, StrDispatch())\n',
  '            sdp.add_re(re.compile(re_key), f, priority )\n',
  '            self.strdispatchers[name] = sdp\n',
  '            return\n',
  '\n',
  '        dp = getattr(self.hooks, name, None)\n',
  '        if name not in IPython.core.hooks.__all__:\n',
  '            print("Warning! Hook \'%s\' is not one of %s" % \\\n',
  '                  (name, IPython.core.hooks.__all__ ))\n',
  '\n',
  '        if _warn_deprecated and (name in IPython.core.hooks.deprecated):\n',
  '            alternative = IPython.core.hooks.deprecated[name]\n',
  '            warn("Hook {} is deprecated. Use {} instead.".format(name, alternative))\n',
  '\n',
  '        if not dp:\n',
  '            dp = IPython.core.hooks.CommandChainDispatcher()\n',
  '\n',
  '        try:\n',
  '            dp.add(f,priority)\n',
  '        except AttributeError:\n',
  '            # it was not commandchain, plain old func - replace\n',
  '            dp = f\n',
  '\n',
  '        setattr(self.hooks,name, dp)\n',
  '\n',
  '    #-------------------------------------------------------------------------\n',
  '    # Things related to events\n',
  '    #-------------------------------------------------------------------------\n',
  '\n',
  '    def init_events(self):\n',
  '        self.events = EventManager(self, available_events)\n',
  '\n',
  '        self.events.register("pre_execute", self._clear_warning_registry)\n',
  '\n',
  '    def register_post_execute(self, func):\n',
  '        """DEPRECATED: Use ip.events.register(\'post_run_cell\', func)\n',
  '        \n',
  '        Register a function for calling after code execution.\n',
  '        """\n',
  '        warn("ip.register_post_execute is deprecated, use "\n',
  '             "ip.events.register(\'post_run_cell\', func) instead.")\n',
  "        self.events.register('post_run_cell', func)\n",
  '    \n',
  '    def _clear_warning_registry(self):\n',
  '        # clear the warning registry, so that different code blocks with\n',
  "        # overlapping line number ranges don't cause spurious suppression of\n",
  '        # warnings (see gh-6611 for details)\n',
  '        if "__warningregistry__" in self.user_global_ns:\n',
  '            del self.user_global_ns["__warningregistry__"]\n',
  '\n',
  '    #-------------------------------------------------------------------------\n',
  '    # Things related to the "main" module\n',
  '    #-------------------------------------------------------------------------\n',
  '\n',
  '    def new_main_mod(self, filename, modname):\n',
  '        """Return a new \'main\' module object for user code execution.\n',
  '        \n',
  '        ``filename`` should be the path of the script which will be run in the\n',
  '        module. Requests with the same filename will get the same module, with\n',
  '        its namespace cleared.\n',
  '        \n',
  "        ``modname`` should be the module name - normally either '__main__' or\n",
  '        the basename of the file without the extension.\n',
  '        \n',
  '        When scripts are executed via %run, we must keep a reference to their\n',
  "        __main__ module around so that Python doesn't\n",
  '        clear it, rendering references to module globals useless.\n',
  '\n',
  '        This method keeps said reference in a private dict, keyed by the\n',
  '        absolute path of the script. This way, for multiple executions of the\n',
  '        same script we only keep one copy of the namespace (the last one),\n',
  '        thus preventing memory leaks from old references while allowing the\n',
  '        objects from the last execution to be accessible.\n',
  '        """\n',
  '        filename = os.path.abspath(filename)\n',
  '        try:\n',
  '            main_mod = self._main_mod_cache[filename]\n',
  '        except KeyError:\n',
  '            main_mod = self._main_mod_cache[filename] = types.ModuleType(\n',
  '                        py3compat.cast_bytes_py2(modname),\n',
  '                        doc="Module created for script run in IPython")\n',
  '        else:\n',
  '            main_mod.__dict__.clear()\n',
  '            main_mod.__name__ = modname\n',
  '        \n',
  '        main_mod.__file__ = filename\n',
  '        # It seems pydoc (and perhaps others) needs any module instance to\n',
  '        # implement a __nonzero__ method\n',
  '        main_mod.__nonzero__ = lambda : True\n',
  '        \n',
  '        return main_mod\n',
  '\n',
  '    def clear_main_mod_cache(self):\n',
  '        """Clear the cache of main modules.\n',
  '\n',
  '        Mainly for use by utilities like %reset.\n',
  '\n',
  '        Examples\n',
  '        --------\n',
  '\n',
  '        In [15]: import IPython\n',
  '\n',
  "        In [16]: m = _ip.new_main_mod(IPython.__file__, 'IPython')\n",
  '\n',
  '        In [17]: len(_ip._main_mod_cache) > 0\n',
  '        Out[17]: True\n',
  '\n',
  '        In [18]: _ip.clear_main_mod_cache()\n',
  '\n',
  '        In [19]: len(_ip._main_mod_cache) == 0\n',
  '        Out[19]: True\n',
  '        """\n',
  '        self._main_mod_cache.clear()\n',
  '\n',
  '    #-------------------------------------------------------------------------\n',
  '    # Things related to debugging\n',
  '    #-------------------------------------------------------------------------\n',
  '\n',
  '    def init_pdb(self):\n',
  '        # Set calling of pdb on exceptions\n',
  '        # self.call_pdb is a property\n',
  '        self.call_pdb = self.pdb\n',
  '\n',
  '    def _get_call_pdb(self):\n',
  '        return self._call_pdb\n',
  '\n',
  '    def _set_call_pdb(self,val):\n',
  '\n',
  '        if val not in (0,1,False,True):\n',
  "            raise ValueError('new call_pdb value must be boolean')\n",
  '\n',
  '        # store value in instance\n',
  '        self._call_pdb = val\n',
  '\n',
  '        # notify the actual exception handlers\n',
  '        self.InteractiveTB.call_pdb = val\n',
  '\n',
  '    call_pdb = property(_get_call_pdb,_set_call_pdb,None,\n',
  "                        'Control auto-activation of pdb at exceptions')\n",
  '\n',
  '    def debugger(self,force=False):\n',
  '        """Call the pydb/pdb debugger.\n',
  '\n',
  '        Keywords:\n',
  '\n',
  '          - force(False): by default, this routine checks the instance call_pdb\n',
  '            flag and does not actually invoke the debugger if the flag is false.\n',
  "            The 'force' option forces the debugger to activate even if the flag\n",
  '            is false.\n',
  '        """\n',
  '\n',
  '        if not (force or self.call_pdb):\n',
  '            return\n',
  '\n',
  "        if not hasattr(sys,'last_traceback'):\n",
  "            error('No traceback has been produced, nothing to debug.')\n",
  '            return\n',
  '\n',
  '        # use pydb if available\n',
  '        if debugger.has_pydb:\n',
  '            from pydb import pm\n',
  '        else:\n',
  '            # fallback to our internal debugger\n',
  '            pm = lambda : self.InteractiveTB.debugger(force=True)\n',
  '\n',
  ...],
 Path('/home/pasha/.ipython/profile_default/db'),
 {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]},
 ['""" History related magics and functionality """\n',
  '#-----------------------------------------------------------------------------\n',
  '#  Copyright (C) 2010-2011 The IPython Development Team.\n',
  '#\n',
  '#  Distributed under the terms of the BSD License.\n',
  '#\n',
  '#  The full license is in the file COPYING.txt, distributed with this software.\n',
  '#-----------------------------------------------------------------------------\n',
  '\n',
  '#-----------------------------------------------------------------------------\n',
  '# Imports\n',
  '#-----------------------------------------------------------------------------\n',
  'from __future__ import print_function\n',
  '\n',
  '# Stdlib imports\n',
  'import atexit\n',
  'import datetime\n',
  'import os\n',
  'import re\n',
  'try:\n',
  '    import sqlite3\n',
  'except ImportError:\n',
  '    try:\n',
  '        from pysqlite2 import dbapi2 as sqlite3\n',
  '    except ImportError:\n',
  '        sqlite3 = None\n',
  'import threading\n',
  '\n',
  '# Our own packages\n',
  'from traitlets.config.configurable import Configurable\n',
  'from decorator import decorator\n',
  'from IPython.utils.decorators import undoc\n',
  'from IPython.utils.path import locate_profile\n',
  'from IPython.utils import py3compat\n',
  'from traitlets import (\n',
  '    Any, Bool, Dict, Instance, Integer, List, Unicode, TraitError,\n',
  ')\n',
  'from IPython.utils.warn import warn\n',
  '\n',
  '#-----------------------------------------------------------------------------\n',
  '# Classes and functions\n',
  '#-----------------------------------------------------------------------------\n',
  '\n',
  '@undoc\n',
  'class DummyDB(object):\n',
  '    """Dummy DB that will act as a black hole for history.\n',
  '    \n',
  '    Only used in the absence of sqlite"""\n',
  '    def execute(*args, **kwargs):\n',
  '        return []\n',
  '    \n',
  '    def commit(self, *args, **kwargs):\n',
  '        pass\n',
  '    \n',
  '    def __enter__(self, *args, **kwargs):\n',
  '        pass\n',
  '    \n',
  '    def __exit__(self, *args, **kwargs):\n',
  '        pass\n',
  '\n',
  '\n',
  '@decorator\n',
  'def needs_sqlite(f, self, *a, **kw):\n',
  '    """Decorator: return an empty list in the absence of sqlite."""\n',
  '    if sqlite3 is None or not self.enabled:\n',
  '        return []\n',
  '    else:\n',
  '        return f(self, *a, **kw)\n',
  '\n',
  '\n',
  'if sqlite3 is not None:\n',
  '    DatabaseError = sqlite3.DatabaseError\n',
  '    OperationalError = sqlite3.OperationalError\n',
  'else:\n',
  '    @undoc\n',
  '    class DatabaseError(Exception):\n',
  '        "Dummy exception when sqlite could not be imported. Should never occur."\n',
  '    \n',
  '    @undoc\n',
  '    class OperationalError(Exception):\n',
  '        "Dummy exception when sqlite could not be imported. Should never occur."\n',
  '\n',
  '@decorator\n',
  'def catch_corrupt_db(f, self, *a, **kw):\n',
  '    """A decorator which wraps HistoryAccessor method calls to catch errors from\n',
  '    a corrupt SQLite database, move the old database out of the way, and create\n',
  '    a new one.\n',
  '    """\n',
  '    try:\n',
  '        return f(self, *a, **kw)\n',
  '    except (DatabaseError, OperationalError):\n',
  '        if os.path.isfile(self.hist_file):\n',
  '            # Try to move the file out of the way\n',
  '            base,ext = os.path.splitext(self.hist_file)\n',
  "            newpath = base + '-corrupt' + ext\n",
  '            os.rename(self.hist_file, newpath)\n',
  '            self.init_db()\n',
  '            print("ERROR! History file wasn\'t a valid SQLite database.",\n',
  '            "It was moved to %s" % newpath, "and a new file created.")\n',
  '            return []\n',
  '        \n',
  '        else:\n',
  '            # The hist_file is probably :memory: or something else.\n',
  '            raise\n',
  '        \n',
  'class HistoryAccessorBase(Configurable):\n',
  '    """An abstract class for History Accessors """\n',
  '\n',
  '    def get_tail(self, n=10, raw=True, output=False, include_latest=False):\n',
  '        raise NotImplementedError\n',
  '\n',
  '    def search(self, pattern="*", raw=True, search_raw=True,\n',
  '               output=False, n=None, unique=False):\n',
  '        raise NotImplementedError\n',
  '\n',
  '    def get_range(self, session, start=1, stop=None, raw=True,output=False):\n',
  '        raise NotImplementedError\n',
  '\n',
  '    def get_range_by_str(self, rangestr, raw=True, output=False):\n',
  '        raise NotImplementedError\n',
  '\n',
  '\n',
  'class HistoryAccessor(HistoryAccessorBase):\n',
  '    """Access the history database without adding to it.\n',
  '    \n',
  '    This is intended for use by standalone history tools. IPython shells use\n',
  '    HistoryManager, below, which is a subclass of this."""\n',
  '\n',
  '    # String holding the path to the history file\n',
  '    hist_file = Unicode(config=True,\n',
  '        help="""Path to file to use for SQLite history database.\n',
  '        \n',
  '        By default, IPython will put the history database in the IPython\n',
  '        profile directory.  If you would rather share one history among\n',
  '        profiles, you can set this value in each, so that they are consistent.\n',
  '        \n',
  '        Due to an issue with fcntl, SQLite is known to misbehave on some NFS\n',
  '        mounts.  If you see IPython hanging, try setting this to something on a\n',
  '        local disk, e.g::\n',
  '        \n',
  '            ipython --HistoryManager.hist_file=/tmp/ipython_hist.sqlite\n',
  '        \n',
  '        """)\n',
  '    \n',
  '    enabled = Bool(True, config=True,\n',
  '        help="""enable the SQLite history\n',
  '        \n',
  '        set enabled=False to disable the SQLite history,\n',
  '        in which case there will be no stored history, no SQLite connection,\n',
  '        and no background saving thread.  This may be necessary in some\n',
  '        threaded environments where IPython is embedded.\n',
  '        """\n',
  '    )\n',
  '    \n',
  '    connection_options = Dict(config=True,\n',
  '        help="""Options for configuring the SQLite connection\n',
  '        \n',
  '        These options are passed as keyword args to sqlite3.connect\n',
  '        when establishing database conenctions.\n',
  '        """\n',
  '    )\n',
  '\n',
  '    # The SQLite database\n',
  '    db = Any()\n',
  '    def _db_changed(self, name, old, new):\n',
  '        """validate the db, since it can be an Instance of two different types"""\n',
  '        connection_types = (DummyDB,)\n',
  '        if sqlite3 is not None:\n',
  '            connection_types = (DummyDB, sqlite3.Connection)\n',
  '        if not isinstance(new, connection_types):\n',
  '            msg = "%s.db must be sqlite3 Connection or DummyDB, not %r" % \\\n',
  '                    (self.__class__.__name__, new)\n',
  '            raise TraitError(msg)\n',
  '    \n',
  "    def __init__(self, profile='default', hist_file=u'', **traits):\n",
  '        """Create a new history accessor.\n',
  '        \n',
  '        Parameters\n',
  '        ----------\n',
  '        profile : str\n',
  '          The name of the profile from which to open history.\n',
  '        hist_file : str\n',
  '          Path to an SQLite history database stored by IPython. If specified,\n',
  '          hist_file overrides profile.\n',
  '        config : :class:`~traitlets.config.loader.Config`\n',
  '          Config object. hist_file can also be set through this.\n',
  '        """\n',
  '        # We need a pointer back to the shell for various tasks.\n',
  '        super(HistoryAccessor, self).__init__(**traits)\n',
  '        # defer setting hist_file from kwarg until after init,\n',
  '        # otherwise the default kwarg value would clobber any value\n',
  '        # set by config\n',
  '        if hist_file:\n',
  '            self.hist_file = hist_file\n',
  '        \n',
  "        if self.hist_file == u'':\n",
  '            # No one has set the hist_file, yet.\n',
  '            self.hist_file = self._get_hist_file_name(profile)\n',
  '\n',
  '        if sqlite3 is None and self.enabled:\n',
  '            warn("IPython History requires SQLite, your history will not be saved")\n',
  '            self.enabled = False\n',
  '        \n',
  '        self.init_db()\n',
  '    \n',
  "    def _get_hist_file_name(self, profile='default'):\n",
  '        """Find the history file for the given profile name.\n',
  '        \n',
  "        This is overridden by the HistoryManager subclass, to use the shell's\n",
  '        active profile.\n',
  '        \n',
  '        Parameters\n',
  '        ----------\n',
  '        profile : str\n',
  '          The name of a profile which has a history file.\n',
  '        """\n',
  "        return os.path.join(locate_profile(profile), 'history.sqlite')\n",
  '    \n',
  '    @catch_corrupt_db\n',
  '    def init_db(self):\n',
  '        """Connect to the database, and create tables if necessary."""\n',
  '        if not self.enabled:\n',
  '            self.db = DummyDB()\n',
  '            return\n',
  '        \n',
  '        # use detect_types so that timestamps return datetime objects\n',
  '        kwargs = dict(detect_types=sqlite3.PARSE_DECLTYPES|sqlite3.PARSE_COLNAMES)\n',
  '        kwargs.update(self.connection_options)\n',
  '        self.db = sqlite3.connect(self.hist_file, **kwargs)\n',
  '        self.db.execute("""CREATE TABLE IF NOT EXISTS sessions (session integer\n',
  '                        primary key autoincrement, start timestamp,\n',
  '                        end timestamp, num_cmds integer, remark text)""")\n',
  '        self.db.execute("""CREATE TABLE IF NOT EXISTS history\n',
  '                (session integer, line integer, source text, source_raw text,\n',
  '                PRIMARY KEY (session, line))""")\n',
  "        # Output history is optional, but ensure the table's there so it can be\n",
  '        # enabled later.\n',
  '        self.db.execute("""CREATE TABLE IF NOT EXISTS output_history\n',
  '                        (session integer, line integer, output text,\n',
  '                        PRIMARY KEY (session, line))""")\n',
  '        self.db.commit()\n',
  '\n',
  '    def writeout_cache(self):\n',
  '        """Overridden by HistoryManager to dump the cache before certain\n',
  '        database lookups."""\n',
  '        pass\n',
  '\n',
  '    ## -------------------------------\n',
  '    ## Methods for retrieving history:\n',
  '    ## -------------------------------\n',
  '    def _run_sql(self, sql, params, raw=True, output=False):\n',
  '        """Prepares and runs an SQL query for the history database.\n',
  '\n',
  '        Parameters\n',
  '        ----------\n',
  '        sql : str\n',
  '          Any filtering expressions to go after SELECT ... FROM ...\n',
  '        params : tuple\n',
  '          Parameters passed to the SQL query (to replace "?")\n',
  '        raw, output : bool\n',
  '          See :meth:`get_range`\n',
  '\n',
  '        Returns\n',
  '        -------\n',
  '        Tuples as :meth:`get_range`\n',
  '        """\n',
  "        toget = 'source_raw' if raw else 'source'\n",
  '        sqlfrom = "history"\n',
  '        if output:\n',
  '            sqlfrom = "history LEFT JOIN output_history USING (session, line)"\n',
  '            toget = "history.%s, output_history.output" % toget\n',
  '        cur = self.db.execute("SELECT session, line, %s FROM %s " %\\\n',
  '                                (toget, sqlfrom) + sql, params)\n',
  '        if output:    # Regroup into 3-tuples, and parse JSON\n',
  '            return ((ses, lin, (inp, out)) for ses, lin, inp, out in cur)\n',
  '        return cur\n',
  '\n',
  '    @needs_sqlite\n',
  '    @catch_corrupt_db\n',
  '    def get_session_info(self, session):\n',
  '        """Get info about a session.\n',
  '\n',
  '        Parameters\n',
  '        ----------\n',
  '\n',
  '        session : int\n',
  '            Session number to retrieve.\n',
  '\n',
  '        Returns\n',
  '        -------\n',
  '        \n',
  '        session_id : int\n',
  '           Session ID number\n',
  '        start : datetime\n',
  '           Timestamp for the start of the session.\n',
  '        end : datetime\n',
  '           Timestamp for the end of the session, or None if IPython crashed.\n',
  '        num_cmds : int\n',
  '           Number of commands run, or None if IPython crashed.\n',
  '        remark : unicode\n',
  '           A manually set description.\n',
  '        """\n',
  '        query = "SELECT * from sessions where session == ?"\n',
  '        return self.db.execute(query, (session,)).fetchone()\n',
  '\n',
  '    @catch_corrupt_db\n',
  '    def get_last_session_id(self):\n',
  '        """Get the last session ID currently in the database.\n',
  '        \n',
  '        Within IPython, this should be the same as the value stored in\n',
  '        :attr:`HistoryManager.session_number`.\n',
  '        """\n',
  '        for record in self.get_tail(n=1, include_latest=True):\n',
  '            return record[0]\n',
  '\n',
  '    @catch_corrupt_db\n',
  '    def get_tail(self, n=10, raw=True, output=False, include_latest=False):\n',
  '        """Get the last n lines from the history database.\n',
  '\n',
  '        Parameters\n',
  '        ----------\n',
  '        n : int\n',
  '          The number of lines to get\n',
  '        raw, output : bool\n',
  '          See :meth:`get_range`\n',
  '        include_latest : bool\n',
  '          If False (default), n+1 lines are fetched, and the latest one\n',
  '          is discarded. This is intended to be used where the function\n',
  '          is called by a user command, which it should not return.\n',
  '\n',
  '        Returns\n',
  '        -------\n',
  '        Tuples as :meth:`get_range`\n',
  '        """\n',
  '        self.writeout_cache()\n',
  '        if not include_latest:\n',
  '            n += 1\n',
  '        cur = self._run_sql("ORDER BY session DESC, line DESC LIMIT ?",\n',
  '                                (n,), raw=raw, output=output)\n',
  '        if not include_latest:\n',
  '            return reversed(list(cur)[1:])\n',
  '        return reversed(list(cur))\n',
  '\n',
  '    @catch_corrupt_db\n',
  '    def search(self, pattern="*", raw=True, search_raw=True,\n',
  '               output=False, n=None, unique=False):\n',
  '        """Search the database using unix glob-style matching (wildcards\n',
  '        * and ?).\n',
  '\n',
  '        Parameters\n',
  '        ----------\n',
  '        pattern : str\n',
  '          The wildcarded pattern to match when searching\n',
  '        search_raw : bool\n',
  '          If True, search the raw input, otherwise, the parsed input\n',
  '        raw, output : bool\n',
  '          See :meth:`get_range`\n',
  '        n : None or int\n',
  '          If an integer is given, it defines the limit of\n',
  '          returned entries.\n',
  '        unique : bool\n',
  '          When it is true, return only unique entries.\n',
  '\n',
  '        Returns\n',
  '        -------\n',
  '        Tuples as :meth:`get_range`\n',
  '        """\n',
  '        tosearch = "source_raw" if search_raw else "source"\n',
  '        if output:\n',
  '            tosearch = "history." + tosearch\n',
  '        self.writeout_cache()\n',
  '        sqlform = "WHERE %s GLOB ?" % tosearch\n',
  '        params = (pattern,)\n',
  '        if unique:\n',
  "            sqlform += ' GROUP BY {0}'.format(tosearch)\n",
  '        if n is not None:\n',
  '            sqlform += " ORDER BY session DESC, line DESC LIMIT ?"\n',
  '            params += (n,)\n',
  '        elif unique:\n',
  '            sqlform += " ORDER BY session, line"\n',
  '        cur = self._run_sql(sqlform, params, raw=raw, output=output)\n',
  '        if n is not None:\n',
  '            return reversed(list(cur))\n',
  '        return cur\n',
  '    \n',
  '    @catch_corrupt_db\n',
  '    def get_range(self, session, start=1, stop=None, raw=True,output=False):\n',
  '        """Retrieve input by session.\n',
  '\n',
  '        Parameters\n',
  '        ----------\n',
  '        session : int\n',
  '            Session number to retrieve.\n',
  '        start : int\n',
  '            First line to retrieve.\n',
  '        stop : int\n',
  '            End of line range (excluded from output itself). If None, retrieve\n',
  '            to the end of the session.\n',
  '        raw : bool\n',
  '            If True, return untranslated input\n',
  '        output : bool\n',
  "            If True, attempt to include output. This will be 'real' Python\n",
  '            objects for the current session, or text reprs from previous\n',
  '            sessions if db_log_output was enabled at the time. Where no output\n',
  '            is found, None is used.\n',
  '\n',
  '        Returns\n',
  '        -------\n',
  '        entries\n',
  '          An iterator over the desired lines. Each line is a 3-tuple, either\n',
  '          (session, line, input) if output is False, or\n',
  '          (session, line, (input, output)) if output is True.\n',
  '        """\n',
  '        if stop:\n',
  '            lineclause = "line >= ? AND line < ?"\n',
  '            params = (session, start, stop)\n',
  '        else:\n',
  '            lineclause = "line>=?"\n',
  '            params = (session, start)\n',
  '\n',
  '        return self._run_sql("WHERE session==? AND %s" % lineclause,\n',
  '                                    params, raw=raw, output=output)\n',
  '\n',
  '    def get_range_by_str(self, rangestr, raw=True, output=False):\n',
  '        """Get lines of history from a string of ranges, as used by magic\n',
  '        commands %hist, %save, %macro, etc.\n',
  '\n',
  '        Parameters\n',
  '        ----------\n',
  '        rangestr : str\n',
  '          A string specifying ranges, e.g. "5 ~2/1-4". See\n',
  '          :func:`magic_history` for full details.\n',
  '        raw, output : bool\n',
  '          As :meth:`get_range`\n',
  '\n',
  '        Returns\n',
  '        -------\n',
  '        Tuples as :meth:`get_range`\n',
  '        """\n',
  '        for sess, s, e in extract_hist_ranges(rangestr):\n',
  '            for line in self.get_range(sess, s, e, raw=raw, output=output):\n',
  '                yield line\n',
  '\n',
  '\n',
  'class HistoryManager(HistoryAccessor):\n',
  '    """A class to organize all history-related functionality in one place.\n',
  '    """\n',
  '    # Public interface\n',
  '\n',
  '    # An instance of the IPython shell we are attached to\n',
  "    shell = Instance('IPython.core.interactiveshell.InteractiveShellABC',\n",
  '                     allow_none=True)\n',
  '    # Lists to hold processed and raw history. These start with a blank entry\n',
  '    # so that we can index them starting from 1\n',
  '    input_hist_parsed = List([""])\n',
  '    input_hist_raw = List([""])\n',
  '    # A list of directories visited during session\n',
  '    dir_hist = List()\n',
  '    def _dir_hist_default(self):\n',
  '        try:\n',
  '            return [py3compat.getcwd()]\n',
  '        except OSError:\n',
  '            return []\n',
  '\n',
  "    # A dict of output history, keyed with ints from the shell's\n",
  '    # execution count.\n',
  '    output_hist = Dict()\n',
  '    # The text/plain repr of outputs.\n',
  '    output_hist_reprs = Dict()\n',
  '\n',
  '    # The number of the current session in the history database\n',
  '    session_number = Integer()\n',
  '    \n',
  '    db_log_output = Bool(False, config=True,\n',
  '        help="Should the history database include output? (default: no)"\n',
  '    )\n',
  '    db_cache_size = Integer(0, config=True,\n',
  '        help="Write to database every x commands (higher values save disk access & power).\\n"\n',
  '        "Values of 1 or less effectively disable caching."\n',
  '    )\n',
  '    # The input and output caches\n',
  '    db_input_cache = List()\n',
  '    db_output_cache = List()\n',
  '    \n',
  '    # History saving in separate thread\n',
  "    save_thread = Instance('IPython.core.history.HistorySavingThread',\n",
  '                           allow_none=True)\n',
  '    try:               # Event is a function returning an instance of _Event...\n',
  '        save_flag = Instance(threading._Event, allow_none=True)\n',
  "    except AttributeError:         # ...until Python 3.3, when it's a class.\n",
  '        save_flag = Instance(threading.Event, allow_none=True)\n',
  '    \n',
  '    # Private interface\n',
  '    # Variables used to store the three last inputs from the user.  On each new\n',
  "    # history update, we populate the user's namespace with these, shifted as\n",
  '    # necessary.\n',
  "    _i00 = Unicode(u'')\n",
  "    _i = Unicode(u'')\n",
  "    _ii = Unicode(u'')\n",
  "    _iii = Unicode(u'')\n",
  '\n',
  "    # A regex matching all forms of the exit command, so that we don't store\n",
  "    # them in the history (it's annoying to rewind the first entry and land on\n",
  '    # an exit call).\n',
  '    _exit_re = re.compile(r"(exit|quit)(\\s*\\(.*\\))?$")\n',
  '\n',
  '    def __init__(self, shell=None, config=None, **traits):\n',
  '        """Create a new history manager associated with a shell instance.\n',
  '        """\n',
  '        # We need a pointer back to the shell for various tasks.\n',
  '        super(HistoryManager, self).__init__(shell=shell, config=config,\n',
  '            **traits)\n',
  '        self.save_flag = threading.Event()\n',
  '        self.db_input_cache_lock = threading.Lock()\n',
  '        self.db_output_cache_lock = threading.Lock()\n',
  '        \n',
  '        try:\n',
  '            self.new_session()\n',
  '        except OperationalError:\n',
  '            self.log.error("Failed to create history session in %s. History will not be saved.",\n',
  '                self.hist_file, exc_info=True)\n',
  "            self.hist_file = ':memory:'\n",
  '        \n',
  "        if self.enabled and self.hist_file != ':memory:':\n",
  '            self.save_thread = HistorySavingThread(self)\n',
  '            self.save_thread.start()\n',
  '\n',
  '    def _get_hist_file_name(self, profile=None):\n',
  '        """Get default history file name based on the Shell\'s profile.\n',
  '        \n',
  '        The profile parameter is ignored, but must exist for compatibility with\n',
  '        the parent class."""\n',
  '        profile_dir = self.shell.profile_dir.location\n',
  "        return os.path.join(profile_dir, 'history.sqlite')\n",
  '    \n',
  '    @needs_sqlite\n',
  '    def new_session(self, conn=None):\n',
  '        """Get a new session number."""\n',
  '        if conn is None:\n',
  '            conn = self.db\n',
  '        \n',
  '        with conn:\n',
  '            cur = conn.execute("""INSERT INTO sessions VALUES (NULL, ?, NULL,\n',
  '                            NULL, "") """, (datetime.datetime.now(),))\n',
  '            self.session_number = cur.lastrowid\n',
  '            \n',
  '    def end_session(self):\n',
  '        """Close the database session, filling in the end time and line count."""\n',
  '        self.writeout_cache()\n',
  '        with self.db:\n',
  '            self.db.execute("""UPDATE sessions SET end=?, num_cmds=? WHERE\n',
  '                            session==?""", (datetime.datetime.now(),\n',
  '                            len(self.input_hist_parsed)-1, self.session_number))\n',
  '        self.session_number = 0\n',
  '                            \n',
  '    def name_session(self, name):\n',
  '        """Give the current session a name in the history database."""\n',
  '        with self.db:\n',
  '            self.db.execute("UPDATE sessions SET remark=? WHERE session==?",\n',
  '                            (name, self.session_number))\n',
  '                            \n',
  '    def reset(self, new_session=True):\n',
  '        """Clear the session history, releasing all object references, and\n',
  '        optionally open a new session."""\n',
  '        self.output_hist.clear()\n',
  "        # The directory history can't be completely empty\n",
  '        self.dir_hist[:] = [py3compat.getcwd()]\n',
  '        \n',
  '        if new_session:\n',
  '            if self.session_number:\n',
  '                self.end_session()\n',
  '            self.input_hist_parsed[:] = [""]\n',
  '            self.input_hist_raw[:] = [""]\n',
  '            self.new_session()\n',
  '\n',
  '    # ------------------------------\n',
  '    # Methods for retrieving history\n',
  '    # ------------------------------\n',
  '    def get_session_info(self, session=0):\n',
  '        """Get info about a session.\n',
  '\n',
  '        Parameters\n',
  '        ----------\n',
  '\n',
  '        session : int\n',
  '            Session number to retrieve. The current session is 0, and negative\n',
  '            numbers count back from current session, so -1 is the previous session.\n',
  '\n',
  '        Returns\n',
  '        -------\n',
  '        \n',
  '        session_id : int\n',
  '           Session ID number\n',
  '        start : datetime\n',
  '           Timestamp for the start of the session.\n',
  '        end : datetime\n',
  '           Timestamp for the end of the session, or None if IPython crashed.\n',
  '        num_cmds : int\n',
  '           Number of commands run, or None if IPython crashed.\n',
  '        remark : unicode\n',
  '           A manually set description.\n',
  '        """\n',
  '        if session <= 0:\n',
  '            session += self.session_number\n',
  '\n',
  '        return super(HistoryManager, self).get_session_info(session=session)\n',
  '\n',
  '    def _get_range_session(self, start=1, stop=None, raw=True, output=False):\n',
  '        """Get input and output history from the current session. Called by\n',
  '        get_range, and takes similar parameters."""\n',
  '        input_hist = self.input_hist_raw if raw else self.input_hist_parsed\n',
  '            \n',
  '        n = len(input_hist)\n',
  '        if start < 0:\n',
  '            start += n\n',
  '        if not stop or (stop > n):\n',
  '            stop = n\n',
  '        elif stop < 0:\n',
  '            stop += n\n',
  '        \n',
  '        for i in range(start, stop):\n',
  '            if output:\n',
  '                line = (input_hist[i], self.output_hist_reprs.get(i))\n',
  '            else:\n',
  '                line = input_hist[i]\n',
  '            yield (0, i, line)\n',
  '    \n',
  '    def get_range(self, session=0, start=1, stop=None, raw=True,output=False):\n',
  '        """Retrieve input by session.\n',
  '        \n',
  '        Parameters\n',
  '        ----------\n',
  '        session : int\n',
  '            Session number to retrieve. The current session is 0, and negative\n',
  '            numbers count back from current session, so -1 is previous session.\n',
  '        start : int\n',
  '            First line to retrieve.\n',
  '        stop : int\n',
  '            End of line range (excluded from output itself). If None, retrieve\n',
  '            to the end of the session.\n',
  '        raw : bool\n',
  '            If True, return untranslated input\n',
  '        output : bool\n',
  "            If True, attempt to include output. This will be 'real' Python\n",
  '            objects for the current session, or text reprs from previous\n',
  '            sessions if db_log_output was enabled at the time. Where no output\n',
  '            is found, None is used.\n',
  '            \n',
  '        Returns\n',
  '        -------\n',
  '        entries\n',
  '          An iterator over the desired lines. Each line is a 3-tuple, either\n',
  '          (session, line, input) if output is False, or\n',
  '          (session, line, (input, output)) if output is True.\n',
  '        """\n',
  '        if session <= 0:\n',
  '            session += self.session_number\n',
  '        if session==self.session_number:          # Current session\n',
  '            return self._get_range_session(start, stop, raw, output)\n',
  '        return super(HistoryManager, self).get_range(session, start, stop, raw,\n',
  '                                                     output)\n',
  '\n',
  '    ## ----------------------------\n',
  '    ## Methods for storing history:\n',
  '    ## ----------------------------\n',
  '    def store_inputs(self, line_num, source, source_raw=None):\n',
  '        """Store source and raw input in history and create input cache\n',
  '        variables ``_i*``.\n',
  '\n',
  '        Parameters\n',
  '        ----------\n',
  '        line_num : int\n',
  '          The prompt number of this input.\n',
  '\n',
  '        source : str\n',
  '          Python input.\n',
  '\n',
  '        source_raw : str, optional\n',
  '          If given, this is the raw input without any IPython transformations\n',
  '          applied to it.  If not given, ``source`` is used.\n',
  '        """\n',
  '        if source_raw is None:\n',
  '            source_raw = source\n',
  "        source = source.rstrip('\\n')\n",
  "        source_raw = source_raw.rstrip('\\n')\n",
  '\n',
  '        # do not store exit/quit commands\n',
  '        if self._exit_re.match(source_raw.strip()):\n',
  '            return\n',
  '\n',
  '        self.input_hist_parsed.append(source)\n',
  '        self.input_hist_raw.append(source_raw)\n',
  '\n',
  '        with self.db_input_cache_lock:\n',
  '            self.db_input_cache.append((line_num, source, source_raw))\n',
  '            # Trigger to flush cache and write to DB.\n',
  '            if len(self.db_input_cache) >= self.db_cache_size:\n',
  '                self.save_flag.set()\n',
  '\n',
  '        # update the auto _i variables\n',
  '        self._iii = self._ii\n',
  '        self._ii = self._i\n',
  '        self._i = self._i00\n',
  '        self._i00 = source_raw\n',
  '\n',
  '        # hackish access to user namespace to create _i1,_i2... dynamically\n',
  "        new_i = '_i%s' % line_num\n",
  "        to_main = {'_i': self._i,\n",
  "                   '_ii': self._ii,\n",
  "                   '_iii': self._iii,\n",
  '                   new_i : self._i00 }\n',
  '        \n',
  '        if self.shell is not None:\n',
  '            self.shell.push(to_main, interactive=False)\n',
  '\n',
  '    def store_output(self, line_num):\n',
  '        """If database output logging is enabled, this saves all the\n',
  "        outputs from the indicated prompt number to the database. It's\n",
  '        called by run_cell after code has been executed.\n',
  '\n',
  '        Parameters\n',
  '        ----------\n',
  '        line_num : int\n',
  '          The line number from which to save outputs\n',
  '        """\n',
  '        if (not self.db_log_output) or (line_num not in self.output_hist_reprs):\n',
  '            return\n',
  '        output = self.output_hist_reprs[line_num]\n',
  '\n',
  '        with self.db_output_cache_lock:\n',
  '            self.db_output_cache.append((line_num, output))\n',
  '        if self.db_cache_size <= 1:\n',
  '            self.save_flag.set()\n',
  '\n',
  '    def _writeout_input_cache(self, conn):\n',
  '        with conn:\n',
  '            for line in self.db_input_cache:\n',
  '                conn.execute("INSERT INTO history VALUES (?, ?, ?, ?)",\n',
  '                                (self.session_number,)+line)\n',
  '\n',
  '    def _writeout_output_cache(self, conn):\n',
  '        with conn:\n',
  '            for line in self.db_output_cache:\n',
  '                conn.execute("INSERT INTO output_history VALUES (?, ?, ?)",\n',
  '                                (self.session_number,)+line)\n',
  '\n',
  '    @needs_sqlite\n',
  '    def writeout_cache(self, conn=None):\n',
  '        """Write any entries in the cache to the database."""\n',
  '        if conn is None:\n',
  '            conn = self.db\n',
  '\n',
  '        with self.db_input_cache_lock:\n',
  '            try:\n',
  '                self._writeout_input_cache(conn)\n',
  '            except sqlite3.IntegrityError:\n',
  '                self.new_session(conn)\n',
  '                print("ERROR! Session/line number was not unique in",\n',
  '                      "database. History logging moved to new session",\n',
  '                                                self.session_number)\n',
  '                try:\n',
  "                    # Try writing to the new session. If this fails, don't\n",
  '                    # recurse\n',
  '                    self._writeout_input_cache(conn)\n',
  '                except sqlite3.IntegrityError:\n',
  '                    pass\n',
  '            finally:\n',
  '                self.db_input_cache = []\n',
  '\n',
  '        with self.db_output_cache_lock:\n',
  '            try:\n',
  '                self._writeout_output_cache(conn)\n',
  '            except sqlite3.IntegrityError:\n',
  '                print("!! Session/line number for output was not unique",\n',
  '                      "in database. Output will not be stored.")\n',
  '            finally:\n',
  '                self.db_output_cache = []\n',
  '\n',
  '\n',
  'class HistorySavingThread(threading.Thread):\n',
  '    """This thread takes care of writing history to the database, so that\n',
  "    the UI isn't held up while that happens.\n",
  '\n',
  "    It waits for the HistoryManager's save_flag to be set, then writes out\n",
  '    the history cache. The main thread is responsible for setting the flag when\n',
  '    the cache size reaches a defined threshold."""\n',
  '    daemon = True\n',
  '    stop_now = False\n',
  '    enabled = True\n',
  '    def __init__(self, history_manager):\n',
  '        super(HistorySavingThread, self).__init__(name="IPythonHistorySavingThread")\n',
  '        self.history_manager = history_manager\n',
  '        self.enabled = history_manager.enabled\n',
  '        atexit.register(self.stop)\n',
  '\n',
  '    @needs_sqlite\n',
  '    def run(self):\n',
  '        # We need a separate db connection per thread:\n',
  '        try:\n',
  '            self.db = sqlite3.connect(self.history_manager.hist_file,\n',
  '                            **self.history_manager.connection_options\n',
  '            )\n',
  '            while True:\n',
  '                self.history_manager.save_flag.wait()\n',
  '                if self.stop_now:\n',
  '                    self.db.close()\n',
  '                    return\n',
  '                self.history_manager.save_flag.clear()\n',
  '                self.history_manager.writeout_cache(self.db)\n',
  '        except Exception as e:\n',
  '            print(("The history saving thread hit an unexpected error (%s)."\n',
  '                   "History will not be written to the database.") % repr(e))\n',
  '\n',
  '    def stop(self):\n',
  '        """This can be called from the main thread to safely stop this thread.\n',
  '\n',
  '        Note that it does not attempt to write out remaining history before\n',
  "        exiting. That should be done by calling the HistoryManager's\n",
  '        end_session method."""\n',
  '        self.stop_now = True\n',
  '        self.history_manager.save_flag.set()\n',
  '        self.join()\n',
  '\n',
  '\n',
  '# To match, e.g. ~5/8-~2/3\n',
  'range_re = re.compile(r"""\n',
  '((?P<startsess>~?\\d+)/)?\n',
  '(?P<start>\\d+)?\n',
  '((?P<sep>[\\-:])\n',
  ' ((?P<endsess>~?\\d+)/)?\n',
  ' (?P<end>\\d+))?\n',
  '$""", re.VERBOSE)\n',
  '\n',
  '\n',
  'def extract_hist_ranges(ranges_str):\n',
  '    """Turn a string of history ranges into 3-tuples of (session, start, stop).\n',
  '\n',
  '    Examples\n',
  '    --------\n',
  '    >>> list(extract_hist_ranges("~8/5-~7/4 2"))\n',
  '    [(-8, 5, None), (-7, 1, 5), (0, 2, 3)]\n',
  '    """\n',
  '    for range_str in ranges_str.split():\n',
  '        rmatch = range_re.match(range_str)\n',
  '        if not rmatch:\n',
  '            continue\n',
  '        start = rmatch.group("start")\n',
  '        if start:\n',
  '            start = int(start)\n',
  '            end = rmatch.group("end")\n',
  '            # If no end specified, get (a, a + 1)\n',
  '            end = int(end) if end else start + 1\n',
  '        else:  # start not specified\n',
  "            if not rmatch.group('startsess'):  # no startsess\n",
  '                continue\n',
  '            start = 1\n',
  '            end = None  # provide the entire session hist\n',
  '\n',
  '        if rmatch.group("sep") == "-":       # 1-3 == 1:4 --> [1, 2, 3]\n',
  '            end += 1\n',
  '        startsess = rmatch.group("startsess") or "0"\n',
  '        endsess = rmatch.group("endsess") or startsess\n',
  '        startsess = int(startsess.replace("~","-"))\n',
  '        endsess = int(endsess.replace("~","-"))\n',
  '        assert endsess >= startsess, "start session must be earlier than end session"\n',
  '\n',
  '        if endsess == startsess:\n',
  '            yield (startsess, start, end)\n',
  '            continue\n',
  '        # Multiple sessions in one range:\n',
  '        yield (startsess, start, None)\n',
  '        for sess in range(startsess+1, endsess):\n',
  '            yield (sess, 1, None)\n',
  '        yield (endsess, 1, end)\n',
  '\n',
  '\n',
  'def _format_lineno(session, line):\n',
  '    """Helper function to format line numbers properly."""\n',
  '    if session == 0:\n',
  '        return str(line)\n',
  '    return "%s#%s" % (session, line)\n',
  '\n',
  '\n'],
 <Condition(<_thread.lock object at 0x7f51c12898a0>, 1)>,
 <Condition(<_thread.lock object at 0x7f51c12899e0>, 0)>,
 {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]},
 <IPython.core.prefilter.PrefilterHandler at 0x7f51c016ea20>,
 {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]},
 {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]},
 {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]},
 {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]},
 {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]},
 {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]},
 {'_lock': <_thread.lock at 0x7f51c125c3a0>,
  '_waiters': deque([]),
  'acquire': <function lock.acquire>,
  'release': <function lock.release>},
 <cell at 0x7f51c1284588: weakref object at 0x7f51c12416d8>,
 {'_exiting': False, '_shadow': False, 'sockopts': {}},
 {'_lock': <_thread.lock at 0x7f51c1289490>,
  '_waiters': deque([]),
  'acquire': <function lock.acquire>,
  'release': <function lock.release>},
 {'_cached': None,
  '_set_fileattr': False,
  'loader': _frozen_importlib.BuiltinImporter,
  'loader_state': None,
  'name': 'faulthandler',
  'origin': 'built-in',
  'submodule_search_locations': None},
 <cell at 0x7f51c1284a98: builtin_function_or_method object at 0x7f51c1232cc8>,
 <cell at 0x7f51c1284ac8: builtin_function_or_method object at 0x7f51c122ee48>,
 {'_poller': <zmq.sugar.poll.Poller at 0x7f51c12212b0>},
 <function tornado.stack_context.wrap.<locals>.null_wrapper>,
 (<cell at 0x7f51c1284b88: list object at 0x7f51c122be08>,
  <cell at 0x7f51c1284bb8: method object at 0x7f51c2476fc8>),
 (<cell at 0x7f51c1284be8: list object at 0x7f51c122bb48>,
  <cell at 0x7f51c1284c18: method object at 0x7f51c1ffdd88>),
 [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>],
 [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>],
 {'_cached': '/home/pasha/.local/lib/python3.4/site-packages/ipykernel/__pycache__/datapub.cpython-34.pyc',
  '_initializing': False,
  '_set_fileattr': True,
  'loader': <_frozen_importlib.SourceFileLoader at 0x7f51c124b780>,
  'loader_state': None,
  'name': 'ipykernel.datapub',
  'origin': '/home/pasha/.local/lib/python3.4/site-packages/ipykernel/datapub.py',
  'submodule_search_locations': None},
 {'_cached': '/home/pasha/.local/lib/python3.4/site-packages/ipykernel/__pycache__/serialize.cpython-34.pyc',
  '_initializing': False,
  '_set_fileattr': True,
  'loader': <_frozen_importlib.SourceFileLoader at 0x7f51c124b4a8>,
  'loader_state': None,
  'name': 'ipykernel.serialize',
  'origin': '/home/pasha/.local/lib/python3.4/site-packages/ipykernel/serialize.py',
  'submodule_search_locations': None},
 {'_cached': '/home/pasha/.local/lib/python3.4/site-packages/ipykernel/__pycache__/pickleutil.cpython-34.pyc',
  '_initializing': False,
  '_set_fileattr': True,
  'loader': <_frozen_importlib.SourceFileLoader at 0x7f51c124b4e0>,
  'loader_state': None,
  'name': 'ipykernel.pickleutil',
  'origin': '/home/pasha/.local/lib/python3.4/site-packages/ipykernel/pickleutil.py',
  'submodule_search_locations': None},
 {'_cached': '/home/pasha/.local/lib/python3.4/site-packages/ipykernel/__pycache__/codeutil.cpython-34.pyc',
  '_initializing': False,
  '_set_fileattr': True,
  'loader': <_frozen_importlib.SourceFileLoader at 0x7f51c01a6278>,
  'loader_state': None,
  'name': 'ipykernel.codeutil',
  'origin': '/home/pasha/.local/lib/python3.4/site-packages/ipykernel/codeutil.py',
  'submodule_search_locations': None},
 <attribute '__weakref__' of 'CannedObject' objects>,
 <function ipykernel.pickleutil.CannedObject.get_object>,
 <function ipykernel.pickleutil.CannedObject.__init__>,
 <attribute '__dict__' of 'CannedObject' objects>,
 <function ipykernel.pickleutil.Reference.__repr__>,
 <function ipykernel.pickleutil.Reference.get_object>,
 <function ipykernel.pickleutil.Reference.__init__>,
 <function ipykernel.pickleutil.CannedCell.get_object>,
 <function ipykernel.pickleutil.CannedCell.__init__>,
 <function ipykernel.pickleutil.CannedFunction.get_object>,
 <function ipykernel.pickleutil.CannedFunction.__init__>,
 <function ipykernel.pickleutil.CannedFunction._check_type>,
 <function ipykernel.pickleutil.CannedClass.get_object>,
 <function ipykernel.pickleutil.CannedClass.__init__>,
 <function ipykernel.pickleutil.CannedClass._check_type>,
 <function ipykernel.pickleutil.CannedArray.get_object>,
 <function ipykernel.pickleutil.CannedArray.__init__>,
 <function ipykernel.pickleutil.CannedBytes.get_object>,
 <function ipykernel.pickleutil.CannedBytes.__init__>,
 <staticmethod at 0x7f51c01a6438>,
 <traitlets.traitlets.Instance at 0x7f51c124b5f8>,
 <traitlets.traitlets.Any at 0x7f51c124b630>,
 <traitlets.traitlets.CBytes at 0x7f51c124b6d8>,
 <traitlets.traitlets.Dict at 0x7f51c124b550>,
 <function ipykernel.datapub.ZMQDataPublisher.publish_data>,
 <function ipykernel.datapub.ZMQDataPublisher.set_parent>,
 [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>],
 {'_lock': <_thread.lock at 0x7f51c12898a0>,
  '_waiters': deque([<_thread.lock at 0x7f51c009aa58>]),
  'acquire': <function lock.acquire>,
  'release': <function lock.release>},
 {'_lock': <_thread.lock at 0x7f51c12899e0>,
  '_waiters': deque([]),
  'acquire': <function lock.acquire>,
  'release': <function lock.release>},
 [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>],
 {'_cross_validation_lock': False,
  '_trait_notifiers': {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
  '_trait_validators': {},
  '_trait_values': {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
   'esc_strings': [],
   'handler_name': 'normal',
   'parent': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
   'prefilter_manager': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
   'shell': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>}},
 [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>],
 [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>],
 [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>],
 [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>],
 [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>],
 [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>],
 deque([]),
 <function lock.release>,
 <function lock.acquire>,
 <weakref at 0x7f51c12416d8; to 'Context' at 0x7f51c11ee2e8>,
 deque([]),
 <function lock.release>,
 <function lock.acquire>,
 <function faulthandler.enable>,
 <function faulthandler.register>,
 <zmq.sugar.poll.Poller at 0x7f51c12212b0>,
 (<cell at 0x7f51c1284b28: list object at 0x7f51c122b0c8>,
  <cell at 0x7f51c1284b58: function object at 0x7f51c11f7598>),
 <cell at 0x7f51c1284bb8: method object at 0x7f51c2476fc8>,
 <cell at 0x7f51c1284b88: list object at 0x7f51c122be08>,
 <cell at 0x7f51c1284c18: method object at 0x7f51c1ffdd88>,
 <cell at 0x7f51c1284be8: list object at 0x7f51c122bb48>,
 ([], None),
 {'allow_none': True,
  'default_args': None,
  'default_kwargs': None,
  'help': '',
  'klass': jupyter_client.session.Session,
  'metadata': {},
  'name': 'session',
  'this_class': ipykernel.datapub.ZMQDataPublisher},
 {'allow_none': True,
  'help': '',
  'metadata': {},
  'name': 'pub_socket',
  'this_class': ipykernel.datapub.ZMQDataPublisher},
 {'default_value': b'datapub',
  'help': '',
  'metadata': {},
  'name': 'topic',
  'this_class': ipykernel.datapub.ZMQDataPublisher},
 {'_traits': None,
  'default_args': ({},),
  'default_kwargs': None,
  'help': '',
  'klass': dict,
  'metadata': {},
  'name': 'parent_header',
  'this_class': ipykernel.datapub.ZMQDataPublisher},
 deque([<_thread.lock at 0x7f51c009aa58>]),
 <function lock.release>,
 <function lock.acquire>,
 deque([]),
 <function lock.release>,
 <function lock.acquire>,
 {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
  'esc_strings': [],
  'handler_name': 'normal',
  'parent': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
  'prefilter_manager': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
  'shell': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>},
 {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
 {'_map': {<zmq.sugar.socket.Socket at 0x7f51c11eaca8>: 1,
   29: 0,
   <zmq.sugar.socket.Socket at 0x7f51c11ead68>: 2},
  'sockets': [(29, 5),
   (<zmq.sugar.socket.Socket at 0x7f51c11eaca8>, 5),
   (<zmq.sugar.socket.Socket at 0x7f51c11ead68>, 5)]},
 <cell at 0x7f51c1284b58: function object at 0x7f51c11f7598>,
 <cell at 0x7f51c1284b28: list object at 0x7f51c122b0c8>,
 <bound method ZMQStream._handle_events of <zmq.eventloop.zmqstream.ZMQStream object at 0x7f51c12216d8>>,
 [((), None)],
 <bound method ZMQStream._handle_events of <zmq.eventloop.zmqstream.ZMQStream object at 0x7f51c1221358>>,
 [((), None)],
 [],
 ({},),
 [],
 {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]},
 {<zmq.sugar.socket.Socket at 0x7f51c11eaca8>: 1,
  29: 0,
  <zmq.sugar.socket.Socket at 0x7f51c11ead68>: 2},
 [(29, 5),
  (<zmq.sugar.socket.Socket at 0x7f51c11eaca8>, 5),
  (<zmq.sugar.socket.Socket at 0x7f51c11ead68>, 5)],
 <function tornado.ioloop.PollIOLoop.initialize.<locals>.<lambda>>,
 [((), None)],
 [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>],
 (<cell at 0x7f51c1284af8: ZMQIOLoop object at 0x7f51c12214a8>,),
 <cell at 0x7f51c1284af8: ZMQIOLoop object at 0x7f51c12214a8>,
 <IPyAutocallChecker(priority=300, enabled=True)>,
 {'_cross_validation_lock': False,
  '_trait_notifiers': {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
  '_trait_validators': {},
  '_trait_values': {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
   'enabled': True,
   'parent': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
   'prefilter_manager': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
   'priority': 300,
   'shell': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>}},
 {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
 {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
  'enabled': True,
  'parent': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
  'prefilter_manager': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
  'priority': 300,
  'shell': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>},
 <AssignmentChecker(priority=600, enabled=True)>,
 {'_cross_validation_lock': False,
  '_trait_notifiers': {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
  '_trait_validators': {},
  '_trait_values': {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
   'enabled': True,
   'parent': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
   'prefilter_manager': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
   'priority': 600,
   'shell': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>}},
 {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
 {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
  'enabled': True,
  'parent': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
  'prefilter_manager': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
  'priority': 600,
  'shell': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>},
 [<weakref at 0x7f51c0052188; to 'sqlite3.Statement' at 0x7f51c00a5928>],
 [<weakref at 0x7f51c00bad18; dead>,
  <weakref at 0x7f51c0052228; dead>,
  <weakref at 0x7f51c0057278; dead>,
  <weakref at 0x7f51c0057c28; dead>,
  <weakref at 0x7f51c0052688; dead>,
  <weakref at 0x7f51c0057638; dead>,
  <weakref at 0x7f51c00524a8; dead>,
  <weakref at 0x7f51c0057408; dead>,
  <weakref at 0x7f51c0064868; dead>,
  <weakref at 0x7f51c00ba9a8; dead>,
  <weakref at 0x7f51c00ba818; dead>,
  <weakref at 0x7f51c00ba688; dead>,
  <weakref at 0x7f51c00ba638; dead>,
  <weakref at 0x7f51c0073908; dead>,
  <weakref at 0x7f51c0057368; dead>,
  <weakref at 0x7f51c0064908; dead>,
  <weakref at 0x7f51c00649a8; dead>,
  <weakref at 0x7f51c00644f8; dead>,
  <weakref at 0x7f51c0064638; dead>,
  <weakref at 0x7f51c0064b38; dead>,
  <weakref at 0x7f51c0064d18; dead>],
 <AutoMagicChecker(priority=700, enabled=True)>,
 {'_cross_validation_lock': False,
  '_trait_notifiers': {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
  '_trait_validators': {},
  '_trait_values': {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
   'enabled': True,
   'parent': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
   'prefilter_manager': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
   'priority': 700,
   'shell': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>}},
 {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
 {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
  'enabled': True,
  'parent': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
  'prefilter_manager': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
  'priority': 700,
  'shell': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>},
 <PythonOpsChecker(priority=900, enabled=True)>,
 {'_cross_validation_lock': False,
  '_trait_notifiers': {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
  '_trait_validators': {},
  '_trait_values': {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
   'enabled': True,
   'parent': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
   'prefilter_manager': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
   'priority': 900,
   'shell': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>}},
 {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
 {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
  'enabled': True,
  'parent': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
  'prefilter_manager': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
  'priority': 900,
  'shell': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>},
 <AutocallChecker(priority=1000, enabled=True)>,
 {'_cross_validation_lock': False,
  '_trait_notifiers': {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
  '_trait_validators': {},
  '_trait_values': {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
   'enabled': True,
   'exclude_regexp': re.compile(r'^[,&^\|\*/\+-]|^is |^not |^in |^and |^or ',
   re.UNICODE),
   'function_name_regexp': re.compile(r'[a-zA-Z_]([a-zA-Z0-9_.]*) *$',
   re.UNICODE),
   'parent': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
   'prefilter_manager': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
   'priority': 1000,
   'shell': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>}},
 {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
 {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
  'enabled': True,
  'exclude_regexp': re.compile(r'^[,&^\|\*/\+-]|^is |^not |^in |^and |^or ',
  re.UNICODE),
  'function_name_regexp': re.compile(r'[a-zA-Z_]([a-zA-Z0-9_.]*) *$',
  re.UNICODE),
  'parent': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
  'prefilter_manager': <IPython.core.prefilter.PrefilterManager at 0x7f51c016e908>,
  'priority': 1000,
  'shell': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>},
 <bound method PrefilterManager.prefilter_lines of <IPython.core.prefilter.PrefilterManager object at 0x7f51c016e908>>,
 <function IPython.core.interactiveshell.InteractiveShell.init_syntax_highlighting.<locals>.<lambda>>,
 {'clipboard_get': <IPython.core.hooks.CommandChainDispatcher at 0x7f51c016eeb8>,
  'editor': <IPython.core.hooks.CommandChainDispatcher at 0x7f51c016ecf8>,
  'fix_error_editor': <IPython.core.hooks.CommandChainDispatcher at 0x7f51c016ed30>,
  'late_startup_hook': <IPython.core.hooks.CommandChainDispatcher at 0x7f51c016edd8>,
  'pre_prompt_hook': <IPython.core.hooks.CommandChainDispatcher at 0x7f51c016ee48>,
  'pre_run_code_hook': <IPython.core.hooks.CommandChainDispatcher at 0x7f51c016ee80>,
  'show_in_pager': <IPython.core.hooks.CommandChainDispatcher at 0x7f51c016ee10>,
  'shutdown_hook': <IPython.core.hooks.CommandChainDispatcher at 0x7f51c016eda0>,
  'synchronize_with_editor': <IPython.core.hooks.CommandChainDispatcher at 0x7f51c016ed68>},
 <IPython.core.hooks.CommandChainDispatcher at 0x7f51c016ecf8>,
 {'chain': [(100,
    <bound method ZMQInteractiveShell.editor of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>)]},
 <IPython.core.hooks.CommandChainDispatcher at 0x7f51c016ed30>,
 {'chain': [(100,
    <bound method ZMQInteractiveShell.fix_error_editor of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>)]},
 <IPython.core.hooks.CommandChainDispatcher at 0x7f51c016ed68>,
 {'chain': [(100,
    <bound method ZMQInteractiveShell.synchronize_with_editor of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>)]},
 <IPython.core.hooks.CommandChainDispatcher at 0x7f51c016eda0>,
 {'chain': [(100,
    <bound method ZMQInteractiveShell.shutdown_hook of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>)]},
 <IPython.core.hooks.CommandChainDispatcher at 0x7f51c016edd8>,
 {'chain': [(100,
    <bound method ZMQInteractiveShell.late_startup_hook of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>)]},
 <IPython.core.hooks.CommandChainDispatcher at 0x7f51c016ee10>,
 {'chain': [(99,
    <bound method ZMQInteractiveShell.<lambda> of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>),
   (100,
    <bound method ZMQInteractiveShell.show_in_pager of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>)]},
 <IPython.core.hooks.CommandChainDispatcher at 0x7f51c016ee48>,
 {'chain': [(100,
    <bound method ZMQInteractiveShell.pre_prompt_hook of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>)]},
 <IPython.core.hooks.CommandChainDispatcher at 0x7f51c016ee80>,
 {'chain': [(100,
    <bound method ZMQInteractiveShell.pre_run_code_hook of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>)]},
 <IPython.core.hooks.CommandChainDispatcher at 0x7f51c016eeb8>,
 {'chain': [(100,
    <bound method ZMQInteractiveShell.clipboard_get of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>)]},
 <IPython.core.events.EventManager at 0x7f51c016ecc0>,
 {'callbacks': {'post_execute': [],
   'post_run_cell': [],
   'pre_execute': [<bound method ZMQInteractiveShell._clear_warning_registry of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>],
   'pre_run_cell': [],
   'shell_initialized': []},
  'shell': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>},
 {'post_execute': [],
  'post_run_cell': [],
  'pre_execute': [<bound method ZMQInteractiveShell._clear_warning_registry of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>],
  'pre_run_cell': [],
  'shell_initialized': []},
 [],
 [<bound method ZMQInteractiveShell._clear_warning_registry of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>],
 [],
 [],
 <bound method ZMQInteractiveShell._clear_warning_registry of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>,
 [],
 ['',
  'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
  'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
  'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
  "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
  "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
  "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
  "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
  "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
  "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
  "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
  "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
  'def pick(l: list, index: int) -> int:\n    return l[index]',
  'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
  'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
  'pick([1, 2, 3], 2)',
  "pick([1, 2, 3], '2')",
  'import gc',
  'import gc\nпс',
  'import gc\ngc',
  'import gc\ngc.garbage',
  'gc.get_objects()'],
 ['/home/pasha/machine-learning.coursera/LearnInProgress/final.assignment/Kaggle'],
 <bound method ZMQInteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>,
 <IPython.core.autocall.ZMQExitAutocall at 0x7f51c016ef98>,
 {'_ip': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>},
 {'In': ['',
   'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
   'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
   'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
   "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   'def pick(l: list, index: int) -> int:\n    return l[index]',
   'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
   'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
   'pick([1, 2, 3], 2)',
   "pick([1, 2, 3], '2')",
   'import gc',
   'import gc\nпс',
   'import gc\ngc',
   'import gc\ngc.garbage',
   'gc.get_objects()'],
  'Out': {14: 3, 15: 3, 19: <module 'gc' (built-in)>, 20: []},
  '_': [],
  '_14': 3,
  '_15': 3,
  '_19': <module 'gc' (built-in)>,
  '_20': [],
  '__': <module 'gc' (built-in)>,
  '___': 3,
  '__builtin__': <module 'builtins' (built-in)>,
  '__builtins__': <module 'builtins' (built-in)>,
  '__doc__': 'Automatically created module for IPython interactive environment',
  '__loader__': None,
  '__name__': '__main__',
  '__package__': None,
  '__spec__': None,
  '_dh': ['/home/pasha/machine-learning.coursera/LearnInProgress/final.assignment/Kaggle'],
  '_i': 'import gc\ngc.garbage',
  '_i1': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
  '_i10': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
  '_i11': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
  '_i12': 'def pick(l: list, index: int) -> int:\n    return l[index]',
  '_i13': 'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
  '_i14': 'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
  '_i15': 'pick([1, 2, 3], 2)',
  '_i16': "pick([1, 2, 3], '2')",
  '_i17': 'import gc',
  '_i18': 'import gc\nпс',
  '_i19': 'import gc\ngc',
  '_i2': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
  '_i20': 'import gc\ngc.garbage',
  '_i21': 'gc.get_objects()',
  '_i3': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
  '_i4': "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
  '_i5': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
  '_i6': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
  '_i7': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
  '_i8': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
  '_i9': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
  '_ih': ['',
   'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
   'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
   'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
   "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   'def pick(l: list, index: int) -> int:\n    return l[index]',
   'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
   'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
   'pick([1, 2, 3], 2)',
   "pick([1, 2, 3], '2')",
   'import gc',
   'import gc\nпс',
   'import gc\ngc',
   'import gc\ngc.garbage',
   'gc.get_objects()'],
  '_ii': 'import gc\ngc',
  '_iii': 'import gc\nпс',
  '_oh': {14: 3, 15: 3, 19: <module 'gc' (built-in)>, 20: []},
  '_sh': <module 'IPython.core.shadowns' from '/home/pasha/.local/lib/python3.4/site-packages/IPython/core/shadowns.py'>,
  'exit': <IPython.core.autocall.ZMQExitAutocall at 0x7f51c016ef98>,
  'get_ipython': <bound method ZMQInteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>,
  'quit': <IPython.core.autocall.ZMQExitAutocall at 0x7f51c016ef98>},
 <IPython.core.logger.Logger at 0x7f51c016ef28>,
 <IPython.core.builtin_trap.BuiltinTrap at 0x7f51c016eef0>,
 {'_builtins_added': False,
  '_cross_validation_lock': False,
  '_nested_level': 1,
  '_orig_builtins': {'dreload': <IPython.core.builtin_trap.__BuiltinUndefined at 0x7f51c5546860>,
   'exit': Use exit() or Ctrl-D (i.e. EOF) to exit,
   'get_ipython': <IPython.core.builtin_trap.__BuiltinUndefined at 0x7f51c5546860>,
   'quit': Use quit() or Ctrl-D (i.e. EOF) to exit},
  '_trait_notifiers': {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
  '_trait_validators': {},
  '_trait_values': {'config': {},
   'parent': None,
   'shell': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>},
  'auto_builtins': {'dreload': <function IPython.lib.deepreload._dreload>,
   'exit': <IPython.core.builtin_trap.__HideBuiltin at 0x7f51c5546898>,
   'get_ipython': <bound method ZMQInteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>,
   'quit': <IPython.core.builtin_trap.__HideBuiltin at 0x7f51c5546898>}},
 {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
 {'config': {},
  'parent': None,
  'shell': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>},
 {},
 {'dreload': <function IPython.lib.deepreload._dreload>,
  'exit': <IPython.core.builtin_trap.__HideBuiltin at 0x7f51c5546898>,
  'get_ipython': <bound method ZMQInteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>,
  'quit': <IPython.core.builtin_trap.__HideBuiltin at 0x7f51c5546898>},
 <bound method ZMQInteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>,
 <module 'IPython.lib.deepreload' from '/home/pasha/.local/lib/python3.4/site-packages/IPython/lib/deepreload.py'>,
 {'ModuleType': module,
  '__builtins__': {'ArithmeticError': ArithmeticError,
   'AssertionError': AssertionError,
   'AttributeError': AttributeError,
   'BaseException': BaseException,
   'BlockingIOError': BlockingIOError,
   'BrokenPipeError': BrokenPipeError,
   'BufferError': BufferError,
   'BytesWarning': BytesWarning,
   'ChildProcessError': ChildProcessError,
   'ConnectionAbortedError': ConnectionAbortedError,
   'ConnectionError': ConnectionError,
   'ConnectionRefusedError': ConnectionRefusedError,
   'ConnectionResetError': ConnectionResetError,
   'DeprecationWarning': DeprecationWarning,
   'EOFError': EOFError,
   'Ellipsis': Ellipsis,
   'EnvironmentError': OSError,
   'Exception': Exception,
   'False': False,
   'FileExistsError': FileExistsError,
   'FileNotFoundError': FileNotFoundError,
   'FloatingPointError': FloatingPointError,
   'FutureWarning': FutureWarning,
   'GeneratorExit': GeneratorExit,
   'IOError': OSError,
   'ImportError': ImportError,
   'ImportWarning': ImportWarning,
   'IndentationError': IndentationError,
   'IndexError': IndexError,
   'InterruptedError': InterruptedError,
   'IsADirectoryError': IsADirectoryError,
   'KeyError': KeyError,
   'KeyboardInterrupt': KeyboardInterrupt,
   'LookupError': LookupError,
   'MemoryError': MemoryError,
   'NameError': NameError,
   'None': None,
   'NotADirectoryError': NotADirectoryError,
   'NotImplemented': NotImplemented,
   'NotImplementedError': NotImplementedError,
   'OSError': OSError,
   'OverflowError': OverflowError,
   'PendingDeprecationWarning': PendingDeprecationWarning,
   'PermissionError': PermissionError,
   'ProcessLookupError': ProcessLookupError,
   'ReferenceError': ReferenceError,
   'ResourceWarning': ResourceWarning,
   'RuntimeError': RuntimeError,
   'RuntimeWarning': RuntimeWarning,
   'StopIteration': StopIteration,
   'SyntaxError': SyntaxError,
   'SyntaxWarning': SyntaxWarning,
   'SystemError': SystemError,
   'SystemExit': SystemExit,
   'TabError': TabError,
   'TimeoutError': TimeoutError,
   'True': True,
   'TypeError': TypeError,
   'UnboundLocalError': UnboundLocalError,
   'UnicodeDecodeError': UnicodeDecodeError,
   'UnicodeEncodeError': UnicodeEncodeError,
   'UnicodeError': UnicodeError,
   'UnicodeTranslateError': UnicodeTranslateError,
   'UnicodeWarning': UnicodeWarning,
   'UserWarning': UserWarning,
   'ValueError': ValueError,
   'Warning': Warning,
   'ZeroDivisionError': ZeroDivisionError,
   '__IPYTHON__': True,
   '__IPYTHON__active': 'Deprecated, check for __IPYTHON__',
   '__build_class__': <function __build_class__>,
   '__debug__': True,
   '__doc__': "Built-in functions, exceptions, and other objects.\n\nNoteworthy: None is the `nil' object; Ellipsis represents `...' in slices.",
   '__import__': <function __import__>,
   '__loader__': _frozen_importlib.BuiltinImporter,
   '__name__': 'builtins',
   '__package__': '',
   '__spec__': ModuleSpec(name='builtins', loader=<class '_frozen_importlib.BuiltinImporter'>),
   'abs': <function abs>,
   'all': <function all>,
   'any': <function any>,
   'ascii': <function ascii>,
   'bin': <function bin>,
   'bool': bool,
   'bytearray': bytearray,
   'bytes': bytes,
   'callable': <function callable>,
   'chr': <function chr>,
   'classmethod': classmethod,
   'compile': <function compile>,
   'complex': complex,
   'copyright': Copyright (c) 2001-2015 Python Software Foundation.
   All Rights Reserved.
   
   Copyright (c) 2000 BeOpen.com.
   All Rights Reserved.
   
   Copyright (c) 1995-2001 Corporation for National Research Initiatives.
   All Rights Reserved.
   
   Copyright (c) 1991-1995 Stichting Mathematisch Centrum, Amsterdam.
   All Rights Reserved.,
   'credits':     Thanks to CWI, CNRI, BeOpen.com, Zope Corporation and a cast of thousands
       for supporting Python development.  See www.python.org for more information.,
   'delattr': <function delattr>,
   'dict': dict,
   'dir': <function dir>,
   'divmod': <function divmod>,
   'dreload': <function IPython.lib.deepreload._dreload>,
   'enumerate': enumerate,
   'eval': <function eval>,
   'exec': <function exec>,
   'filter': filter,
   'float': float,
   'format': <function format>,
   'frozenset': frozenset,
   'get_ipython': <bound method ZMQInteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>,
   'getattr': <function getattr>,
   'globals': <function globals>,
   'hasattr': <function hasattr>,
   'hash': <function hash>,
   'help': Type help() for interactive help, or help(object) for help about object.,
   'hex': <function hex>,
   'id': <function id>,
   'input': <bound method IPythonKernel.raw_input of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
   'int': int,
   'isinstance': <function isinstance>,
   'issubclass': <function issubclass>,
   'iter': <function iter>,
   'len': <function len>,
   'license': See https://www.python.org/psf/license/,
   'list': list,
   'locals': <function locals>,
   'map': map,
   'max': <function max>,
   'memoryview': memoryview,
   'min': <function min>,
   'next': <function next>,
   'object': object,
   'oct': <function oct>,
   'open': <function io.open>,
   'ord': <function ord>,
   'pow': <function pow>,
   'print': <function print>,
   'property': property,
   'range': range,
   'repr': <function repr>,
   'reversed': reversed,
   'round': <function round>,
   'set': set,
   'setattr': <function setattr>,
   'slice': slice,
   'sorted': <function sorted>,
   'staticmethod': staticmethod,
   'str': str,
   'sum': <function sum>,
   'super': super,
   'tuple': tuple,
   'type': type,
   'vars': <function vars>,
   'zip': zip},
  '__cached__': '/home/pasha/.local/lib/python3.4/site-packages/IPython/lib/__pycache__/deepreload.cpython-34.pyc',
  '__doc__': "\nProvides a reload() function that acts recursively.\n\nPython's normal :func:`python:reload` function only reloads the module that it's\npassed. The :func:`reload` function in this module also reloads everything\nimported from that module, which is useful when you're changing files deep\ninside a package.\n\nTo use this as your default reload function, type this for Python 2::\n\n    import __builtin__\n    from IPython.lib import deepreload\n    __builtin__.reload = deepreload.reload\n\nOr this for Python 3::\n\n    import builtins\n    from IPython.lib import deepreload\n    builtins.reload = deepreload.reload\n\nA reference to the original :func:`python:reload` is stored in this module as\n:data:`original_reload`, so you can restore it later.\n\nThis code is almost entirely based on knee.py, which is a Python\nre-implementation of hierarchical module import.\n",
  '__file__': '/home/pasha/.local/lib/python3.4/site-packages/IPython/lib/deepreload.py',
  '__loader__': <_frozen_importlib.SourceFileLoader at 0x7f51c0186160>,
  '__name__': 'IPython.lib.deepreload',
  '__package__': 'IPython.lib',
  '__spec__': ModuleSpec(name='IPython.lib.deepreload', loader=<_frozen_importlib.SourceFileLoader object at 0x7f51c0186160>, origin='/home/pasha/.local/lib/python3.4/site-packages/IPython/lib/deepreload.py'),
  '_dreload': <function IPython.lib.deepreload._dreload>,
  'add_submodule': <function IPython.lib.deepreload.add_submodule>,
  'builtin_mod': <module 'builtins' (built-in)>,
  'builtin_mod_name': 'builtins',
  'contextmanager': <function contextlib.contextmanager>,
  'deep_import_hook': <function IPython.lib.deepreload.deep_import_hook>,
  'deep_reload_hook': <function IPython.lib.deepreload.deep_reload_hook>,
  'ensure_fromlist': <function IPython.lib.deepreload.ensure_fromlist>,
  'found_now': {},
  'get_parent': <function IPython.lib.deepreload.get_parent>,
  'imp': <module 'imp' from '/usr/lib64/python3.4/imp.py'>,
  'import_submodule': <function IPython.lib.deepreload.import_submodule>,
  'load_next': <function IPython.lib.deepreload.load_next>,
  'modules_reloading': {},
  'original_import': <function __import__>,
  'original_reload': <function imp.reload>,
  'print_function': _Feature((2, 6, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 65536),
  'reload': <function IPython.lib.deepreload.reload>,
  'replace_import_hook': <function IPython.lib.deepreload.replace_import_hook>,
  'sys': <module 'sys' (built-in)>,
  'warn': <function _warnings.warn>},
 ("\n    parent, name = get_parent(globals, level)\n\n    Return the package that an import is being performed in.  If globals comes\n    from the module foo.bar.bat (not itself a package), this returns the\n    sys.modules entry for foo.bar.  If globals is from a package's __init__.py,\n    the package's entry in sys.modules is returned.\n\n    If globals doesn't come from a package or a module in a package, or a\n    corresponding entry is not found in sys.modules, None is returned.\n    ",
  None,
  '',
  '__package__',
  'rindex',
  '__package__ set to non-string',
  0,
  'Attempted relative import in non-package',
  '__name__',
  '__path__',
  '.',
  1,
  'attempted relative import beyond top-level package',
  "Parent module '%.200s' not found while handling absolute import",
  "Parent module '%.200s' not loaded, cannot perform relative import",
  (None, ''),
  (None, ''),
  (None, ''),
  (None, ''),
  -1),
 <function IPython.lib.deepreload.replace_import_hook>,
 {'__wrapped__': <function IPython.lib.deepreload.replace_import_hook>},
 <function IPython.lib.deepreload.get_parent>,
 <function IPython.lib.deepreload.load_next>,
 <function IPython.lib.deepreload.import_submodule>,
 <function IPython.lib.deepreload.add_submodule>,
 <function IPython.lib.deepreload.ensure_fromlist>,
 <function IPython.lib.deepreload.deep_import_hook>,
 <function IPython.lib.deepreload.deep_reload_hook>,
 <function IPython.lib.deepreload.reload>,
 (('sys', 'os.path', 'builtins', '__main__'),),
 <function IPython.lib.deepreload._dreload>,
 <IPython.core.oinspect.Inspector at 0x7f51c016ef60>,
 {'color_table': {'': <IPython.utils.coloransi.ColorScheme at 0x7f51c72739e8>,
   'LightBG': <IPython.utils.coloransi.ColorScheme at 0x7f51c7273a20>,
   'Linux': <IPython.utils.coloransi.ColorScheme at 0x7f51c72739e8>,
   'NoColor': <IPython.utils.coloransi.ColorScheme at 0x7f51c7273978>},
  'format': <bound method Parser.format of <IPython.utils.PyColorize.Parser object at 0x7f51c016efd0>>,
  'parser': <IPython.utils.PyColorize.Parser at 0x7f51c016efd0>,
  'str_detail_level': 0},
 <IPython.utils.PyColorize.Parser at 0x7f51c016efd0>,
 {'color_table': {'': <IPython.utils.coloransi.ColorScheme at 0x7f51c72739e8>,
   'LightBG': <IPython.utils.coloransi.ColorScheme at 0x7f51c7273a20>,
   'Linux': <IPython.utils.coloransi.ColorScheme at 0x7f51c72739e8>,
   'NoColor': <IPython.utils.coloransi.ColorScheme at 0x7f51c7273978>},
  'out': 'str'},
 <bound method Parser.format of <IPython.utils.PyColorize.Parser object at 0x7f51c016efd0>>,
 <IPython.utils.contexts.NoOpContext at 0x7f51c0186048>,
 <module 'IPython.core.completerlib' from '/home/pasha/.local/lib/python3.4/site-packages/IPython/core/completerlib.py'>,
 {'TIMEOUT_GIVEUP': 20,
  'TIMEOUT_STORAGE': 2,
  'TryNext': IPython.core.error.TryNext,
  '__builtins__': {'ArithmeticError': ArithmeticError,
   'AssertionError': AssertionError,
   'AttributeError': AttributeError,
   'BaseException': BaseException,
   'BlockingIOError': BlockingIOError,
   'BrokenPipeError': BrokenPipeError,
   'BufferError': BufferError,
   'BytesWarning': BytesWarning,
   'ChildProcessError': ChildProcessError,
   'ConnectionAbortedError': ConnectionAbortedError,
   'ConnectionError': ConnectionError,
   'ConnectionRefusedError': ConnectionRefusedError,
   'ConnectionResetError': ConnectionResetError,
   'DeprecationWarning': DeprecationWarning,
   'EOFError': EOFError,
   'Ellipsis': Ellipsis,
   'EnvironmentError': OSError,
   'Exception': Exception,
   'False': False,
   'FileExistsError': FileExistsError,
   'FileNotFoundError': FileNotFoundError,
   'FloatingPointError': FloatingPointError,
   'FutureWarning': FutureWarning,
   'GeneratorExit': GeneratorExit,
   'IOError': OSError,
   'ImportError': ImportError,
   'ImportWarning': ImportWarning,
   'IndentationError': IndentationError,
   'IndexError': IndexError,
   'InterruptedError': InterruptedError,
   'IsADirectoryError': IsADirectoryError,
   'KeyError': KeyError,
   'KeyboardInterrupt': KeyboardInterrupt,
   'LookupError': LookupError,
   'MemoryError': MemoryError,
   'NameError': NameError,
   'None': None,
   'NotADirectoryError': NotADirectoryError,
   'NotImplemented': NotImplemented,
   'NotImplementedError': NotImplementedError,
   'OSError': OSError,
   'OverflowError': OverflowError,
   'PendingDeprecationWarning': PendingDeprecationWarning,
   'PermissionError': PermissionError,
   'ProcessLookupError': ProcessLookupError,
   'ReferenceError': ReferenceError,
   'ResourceWarning': ResourceWarning,
   'RuntimeError': RuntimeError,
   'RuntimeWarning': RuntimeWarning,
   'StopIteration': StopIteration,
   'SyntaxError': SyntaxError,
   'SyntaxWarning': SyntaxWarning,
   'SystemError': SystemError,
   'SystemExit': SystemExit,
   'TabError': TabError,
   'TimeoutError': TimeoutError,
   'True': True,
   'TypeError': TypeError,
   'UnboundLocalError': UnboundLocalError,
   'UnicodeDecodeError': UnicodeDecodeError,
   'UnicodeEncodeError': UnicodeEncodeError,
   'UnicodeError': UnicodeError,
   'UnicodeTranslateError': UnicodeTranslateError,
   'UnicodeWarning': UnicodeWarning,
   'UserWarning': UserWarning,
   'ValueError': ValueError,
   'Warning': Warning,
   'ZeroDivisionError': ZeroDivisionError,
   '__IPYTHON__': True,
   '__IPYTHON__active': 'Deprecated, check for __IPYTHON__',
   '__build_class__': <function __build_class__>,
   '__debug__': True,
   '__doc__': "Built-in functions, exceptions, and other objects.\n\nNoteworthy: None is the `nil' object; Ellipsis represents `...' in slices.",
   '__import__': <function __import__>,
   '__loader__': _frozen_importlib.BuiltinImporter,
   '__name__': 'builtins',
   '__package__': '',
   '__spec__': ModuleSpec(name='builtins', loader=<class '_frozen_importlib.BuiltinImporter'>),
   'abs': <function abs>,
   'all': <function all>,
   'any': <function any>,
   'ascii': <function ascii>,
   'bin': <function bin>,
   'bool': bool,
   'bytearray': bytearray,
   'bytes': bytes,
   'callable': <function callable>,
   'chr': <function chr>,
   'classmethod': classmethod,
   'compile': <function compile>,
   'complex': complex,
   'copyright': Copyright (c) 2001-2015 Python Software Foundation.
   All Rights Reserved.
   
   Copyright (c) 2000 BeOpen.com.
   All Rights Reserved.
   
   Copyright (c) 1995-2001 Corporation for National Research Initiatives.
   All Rights Reserved.
   
   Copyright (c) 1991-1995 Stichting Mathematisch Centrum, Amsterdam.
   All Rights Reserved.,
   'credits':     Thanks to CWI, CNRI, BeOpen.com, Zope Corporation and a cast of thousands
       for supporting Python development.  See www.python.org for more information.,
   'delattr': <function delattr>,
   'dict': dict,
   'dir': <function dir>,
   'divmod': <function divmod>,
   'dreload': <function IPython.lib.deepreload._dreload>,
   'enumerate': enumerate,
   'eval': <function eval>,
   'exec': <function exec>,
   'filter': filter,
   'float': float,
   'format': <function format>,
   'frozenset': frozenset,
   'get_ipython': <bound method ZMQInteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>,
   'getattr': <function getattr>,
   'globals': <function globals>,
   'hasattr': <function hasattr>,
   'hash': <function hash>,
   'help': Type help() for interactive help, or help(object) for help about object.,
   'hex': <function hex>,
   'id': <function id>,
   'input': <bound method IPythonKernel.raw_input of <ipykernel.ipkernel.IPythonKernel object at 0x7f51c1221278>>,
   'int': int,
   'isinstance': <function isinstance>,
   'issubclass': <function issubclass>,
   'iter': <function iter>,
   'len': <function len>,
   'license': See https://www.python.org/psf/license/,
   'list': list,
   'locals': <function locals>,
   'map': map,
   'max': <function max>,
   'memoryview': memoryview,
   'min': <function min>,
   'next': <function next>,
   'object': object,
   'oct': <function oct>,
   'open': <function io.open>,
   'ord': <function ord>,
   'pow': <function pow>,
   'print': <function print>,
   'property': property,
   'range': range,
   'repr': <function repr>,
   'reversed': reversed,
   'round': <function round>,
   'set': set,
   'setattr': <function setattr>,
   'slice': slice,
   'sorted': <function sorted>,
   'staticmethod': staticmethod,
   'str': str,
   'sum': <function sum>,
   'super': super,
   'tuple': tuple,
   'type': type,
   'vars': <function vars>,
   'zip': zip},
  '__cached__': '/home/pasha/.local/lib/python3.4/site-packages/IPython/core/__pycache__/completerlib.cpython-34.pyc',
  '__doc__': 'Implementations for various useful completers.\n\nThese are all loaded by default by IPython.\n',
  '__file__': '/home/pasha/.local/lib/python3.4/site-packages/IPython/core/completerlib.py',
  '__loader__': <_frozen_importlib.SourceFileLoader at 0x7f51c0186470>,
  '__name__': 'IPython.core.completerlib',
  '__package__': 'IPython.core',
  '__spec__': ModuleSpec(name='IPython.core.completerlib', loader=<_frozen_importlib.SourceFileLoader object at 0x7f51c0186470>, origin='/home/pasha/.local/lib/python3.4/site-packages/IPython/core/completerlib.py'),
  '_suffixes': ['.py', '.pyc', '.cpython-34m.so', '.abi3.so', '.so'],
  'all_suffixes': <function importlib.machinery.all_suffixes>,
  'arg_split': <function IPython.utils._process_common.arg_split>,
  'cd_completer': <function IPython.core.completerlib.cd_completer>,
  'compress_user': <function IPython.core.completer.compress_user>,
  'expand_user': <function IPython.core.completer.expand_user>,
  'get_ipython': <function IPython.core.getipython.get_ipython>,
  'get_root_modules': <function IPython.core.completerlib.get_root_modules>,
  'glob': <module 'glob' from '/usr/lib64/python3.4/glob.py'>,
  'import_re': re.compile(r'(?P<name>[a-zA-Z_][a-zA-Z0-9_]*?)(?P<package>[/\\]__init__)?(?P<suffix>\.py|\.pyc|\.cpython\-34m\.so|\.abi3\.so|\.so)$',
  re.UNICODE),
  'inspect': <module 'inspect' from '/usr/lib64/python3.4/inspect.py'>,
  'is_importable': <function IPython.core.completerlib.is_importable>,
  'magic_run_completer': <function IPython.core.completerlib.magic_run_completer>,
  'magic_run_re': re.compile(r'.*(\.ipy|\.ipynb|\.py[w]?)$', re.UNICODE),
  'module_completer': <function IPython.core.completerlib.module_completer>,
  'module_completion': <function IPython.core.completerlib.module_completion>,
  'module_list': <function IPython.core.completerlib.module_list>,
  'os': <module 'os' from '/usr/lib64/python3.4/os.py'>,
  'print_function': _Feature((2, 6, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 65536),
  'quick_completer': <function IPython.core.completerlib.quick_completer>,
  're': <module 're' from '/usr/lib64/python3.4/re.py'>,
  'reset_completer': <function IPython.core.completerlib.reset_completer>,
  'string_types': (str,),
  'sys': <module 'sys' (built-in)>,
  'time': <function time.time>,
  'try_import': <function IPython.core.completerlib.try_import>,
  'zipimporter': zipimport.zipimporter},
 ("\n    Returns a list containing the names of all the modules available in the\n    folders of the pythonpath.\n\n    ip.db['rootmodules_cache'] maps sys.path entries to list of modules.\n    ",
  'rootmodules_cache',
  False,
  '__init__',
  '',
  '.',
  True,
  '\nCaching the list of root modules, please wait!',
  "(This will only be done once - type '%rehashx' to reset cache!)\n",
  'This is taking too long, we give up.\n',
  ('', '.')),
 ("\n    Returns a list containing the completion possibilities for an import line.\n\n    The line looks like this :\n    'import xml.d'\n    'from xml.dom import'\n    ",
  ' ',
  3,
  0,
  'from',
  'import ',
  '%aimport',
  'import',
  1,
  '.',
  2,
  None,
  True,
  <code object <listcomp> at 0x7f51c0189810, file "/home/pasha/.local/lib/python3.4/site-packages/IPython/core/completerlib.py", line 233>,
  'module_completion.<locals>.<listcomp>',
  frozenset({'%aimport', 'from', 'import'}),
  -1),
 frozenset({'%aimport', 'from', 'import'}),
 ['.py', '.pyc', '.cpython-34m.so', '.abi3.so', '.so'],
 [None, 'name', 'package', 'suffix'],
 [None, None],
 <function IPython.core.completerlib.module_list>,
 <function IPython.core.completerlib.get_root_modules>,
 <function IPython.core.completerlib.is_importable>,
 <function IPython.core.completerlib.try_import>,
 <function IPython.core.completerlib.quick_completer>,
 <function IPython.core.completerlib.module_completion>,
 <function IPython.core.completerlib.module_completer>,
 <function IPython.core.completerlib.magic_run_completer>,
 <function IPython.core.completerlib.cd_completer>,
 <function IPython.core.completerlib.reset_completer>,
 <IPython.core.completer.IPCompleter at 0x7f51c0186080>,
 {'_cross_validation_lock': False,
  '_trait_notifiers': {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
  '_trait_validators': {},
  '_trait_values': {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
   'greedy': False,
   'limit_to__all__': False,
   'merge_completions': True,
   'omit__names': 2,
   'parent': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>},
  'clean_glob': <bound method IPCompleter._clean_glob of <IPython.core.completer.IPCompleter object at 0x7f51c0186080>>,
  'custom_completers': <Strdispatch {'%run': <IPython.core.hooks.CommandChainDispatcher object at 0x7f51c0186fd0>, 'from': <IPython.core.hooks.CommandChainDispatcher object at 0x7f51c0186e80>, '%reset': <IPython.core.hooks.CommandChainDispatcher object at 0x7f51c01863c8>, '%aimport': <IPython.core.hooks.CommandChainDispatcher object at 0x7f51c0186f28>, 'import': <IPython.core.hooks.CommandChainDispatcher object at 0x7f51c0186e48>, '%cd': <IPython.core.hooks.CommandChainDispatcher object at 0x7f51c0186358>}, {}>,
  'docstring_kwd_re': re.compile(r'[\s|\[]*(\w+)(?:\s*=\s*.*)', re.UNICODE),
  'docstring_sig_re': re.compile(r'^[\w|\s.]+\(([^)]*)\).*', re.UNICODE),
  'dumb_terminal': False,
  'glob': <function glob.glob>,
  'global_namespace': {'In': ['',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
    "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    'def pick(l: list, index: int) -> int:\n    return l[index]',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
    'pick([1, 2, 3], 2)',
    "pick([1, 2, 3], '2')",
    'import gc',
    'import gc\nпс',
    'import gc\ngc',
    'import gc\ngc.garbage',
    'gc.get_objects()'],
   'Out': {14: 3, 15: 3, 19: <module 'gc' (built-in)>, 20: []},
   '_': [],
   '_14': 3,
   '_15': 3,
   '_19': <module 'gc' (built-in)>,
   '_20': [],
   '__': <module 'gc' (built-in)>,
   '___': 3,
   '__builtin__': <module 'builtins' (built-in)>,
   '__builtins__': <module 'builtins' (built-in)>,
   '__doc__': 'Automatically created module for IPython interactive environment',
   '__loader__': None,
   '__name__': '__main__',
   '__package__': None,
   '__spec__': None,
   '_dh': ['/home/pasha/machine-learning.coursera/LearnInProgress/final.assignment/Kaggle'],
   '_i': 'import gc\ngc.garbage',
   '_i1': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
   '_i10': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_i11': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   '_i12': 'def pick(l: list, index: int) -> int:\n    return l[index]',
   '_i13': 'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
   '_i14': 'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
   '_i15': 'pick([1, 2, 3], 2)',
   '_i16': "pick([1, 2, 3], '2')",
   '_i17': 'import gc',
   '_i18': 'import gc\nпс',
   '_i19': 'import gc\ngc',
   '_i2': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
   '_i20': 'import gc\ngc.garbage',
   '_i21': 'gc.get_objects()',
   '_i3': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
   '_i4': "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   '_i5': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   '_i6': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_i7': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_i8': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_i9': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_ih': ['',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
    "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    'def pick(l: list, index: int) -> int:\n    return l[index]',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
    'pick([1, 2, 3], 2)',
    "pick([1, 2, 3], '2')",
    'import gc',
    'import gc\nпс',
    'import gc\ngc',
    'import gc\ngc.garbage',
    'gc.get_objects()'],
   '_ii': 'import gc\ngc',
   '_iii': 'import gc\nпс',
   '_oh': {14: 3, 15: 3, 19: <module 'gc' (built-in)>, 20: []},
   '_sh': <module 'IPython.core.shadowns' from '/home/pasha/.local/lib/python3.4/site-packages/IPython/core/shadowns.py'>,
   'exit': <IPython.core.autocall.ZMQExitAutocall at 0x7f51c016ef98>,
   'gc': <module 'gc' (built-in)>,
   'get_ipython': <bound method ZMQInteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>,
   'pick': <function __main__.pick>,
   'quit': <IPython.core.autocall.ZMQExitAutocall at 0x7f51c016ef98>,
   'v': 3,
   'x': {1: False, 3: True}},
  'magic_escape': '%',
  'matchers': [<bound method IPCompleter.python_matches of <IPython.core.completer.IPCompleter object at 0x7f51c0186080>>,
   <bound method IPCompleter.file_matches of <IPython.core.completer.IPCompleter object at 0x7f51c0186080>>,
   <bound method IPCompleter.magic_matches of <IPython.core.completer.IPCompleter object at 0x7f51c0186080>>,
   <bound method IPCompleter.python_func_kw_matches of <IPython.core.completer.IPCompleter object at 0x7f51c0186080>>,
   <bound method IPCompleter.dict_key_matches of <IPython.core.completer.IPCompleter object at 0x7f51c0186080>>],
  'matches': [],
  'namespace': {'In': ['',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
    "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    'def pick(l: list, index: int) -> int:\n    return l[index]',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
    'pick([1, 2, 3], 2)',
    "pick([1, 2, 3], '2')",
    'import gc',
    'import gc\nпс',
    'import gc\ngc',
    'import gc\ngc.garbage',
    'gc.get_objects()'],
   'Out': {14: 3, 15: 3, 19: <module 'gc' (built-in)>, 20: []},
   '_': [],
   '_14': 3,
   '_15': 3,
   '_19': <module 'gc' (built-in)>,
   '_20': [],
   '__': <module 'gc' (built-in)>,
   '___': 3,
   '__builtin__': <module 'builtins' (built-in)>,
   '__builtins__': <module 'builtins' (built-in)>,
   '__doc__': 'Automatically created module for IPython interactive environment',
   '__loader__': None,
   '__name__': '__main__',
   '__package__': None,
   '__spec__': None,
   '_dh': ['/home/pasha/machine-learning.coursera/LearnInProgress/final.assignment/Kaggle'],
   '_i': 'import gc\ngc.garbage',
   '_i1': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
   '_i10': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_i11': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   '_i12': 'def pick(l: list, index: int) -> int:\n    return l[index]',
   '_i13': 'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
   '_i14': 'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
   '_i15': 'pick([1, 2, 3], 2)',
   '_i16': "pick([1, 2, 3], '2')",
   '_i17': 'import gc',
   '_i18': 'import gc\nпс',
   '_i19': 'import gc\ngc',
   '_i2': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
   '_i20': 'import gc\ngc.garbage',
   '_i21': 'gc.get_objects()',
   '_i3': 'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
   '_i4': "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   '_i5': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
   '_i6': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_i7': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_i8': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_i9': "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
   '_ih': ['',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print x[v]\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception, e:\n        print e\n        pass',
    'x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print e\n        pass',
    "x = {1: False, 2: True} # no 3\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('\\tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...tcontinue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n#        pass",
    "x = {1: False, 3: True} # no 2!\n\nfor v in [1,2,3]:\n    try:\n        print (x[v])\n        print ('...continue')\n    except Exception as e:\n        print ('Exception happened', e)\n        pass",
    'def pick(l: list, index: int) -> int:\n    return l[index]',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3])',
    'def pick(l: list, index: int) -> int:\n    return l[index]\n\npick([1, 2, 3], 2)',
    'pick([1, 2, 3], 2)',
    "pick([1, 2, 3], '2')",
    'import gc',
    'import gc\nпс',
    'import gc\ngc',
    'import gc\ngc.garbage',
    'gc.get_objects()'],
   '_ii': 'import gc\ngc',
   '_iii': 'import gc\nпс',
   '_oh': {14: 3, 15: 3, 19: <module 'gc' (built-in)>, 20: []},
   '_sh': <module 'IPython.core.shadowns' from '/home/pasha/.local/lib/python3.4/site-packages/IPython/core/shadowns.py'>,
   'exit': <IPython.core.autocall.ZMQExitAutocall at 0x7f51c016ef98>,
   'gc': <module 'gc' (built-in)>,
   'get_ipython': <bound method ZMQInteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>,
   'pick': <function __main__.pick>,
   'quit': <IPython.core.autocall.ZMQExitAutocall at 0x7f51c016ef98>,
   'v': 3,
   'x': {1: False, 3: True}},
  'readline': None,
  'shell': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>,
  'space_name_re': re.compile(r'([^\\] )', re.UNICODE),
  'splitter': <IPython.core.completer.CompletionSplitter at 0x7f51c01860b8>,
  'use_main_ns': 0},
 {'config': {'change': [<traitlets.traitlets.ObserveHandler at 0x7f51c93fca58>]}},
 <IPython.core.completer.CompletionSplitter at 0x7f51c01860b8>,
 [None],
 {'config': {'IPKernelApp': {'connection_file': '/home/pasha/.local/share/jupyter/runtime/kernel-5f9aca5a-28c1-45e8-a46e-1a30a486cf58.json'}},
  'greedy': False,
  'limit_to__all__': False,
  'merge_completions': True,
  'omit__names': 2,
  'parent': <ipykernel.zmqshell.ZMQInteractiveShell at 0x7f51c12210b8>},
 [],
 [None, None],
 <bound method IPCompleter._clean_glob of <IPython.core.completer.IPCompleter object at 0x7f51c0186080>>,
 [None, None],
 [None, None],
 [<bound method IPCompleter.python_matches of <IPython.core.completer.IPCompleter object at 0x7f51c0186080>>,
  <bound method IPCompleter.file_matches of <IPython.core.completer.IPCompleter object at 0x7f51c0186080>>,
  <bound method IPCompleter.magic_matches of <IPython.core.completer.IPCompleter object at 0x7f51c0186080>>,
  <bound method IPCompleter.python_func_kw_matches of <IPython.core.completer.IPCompleter object at 0x7f51c0186080>>,
  <bound method IPCompleter.dict_key_matches of <IPython.core.completer.IPCompleter object at 0x7f51c0186080>>],
 <Strdispatch {'%run': <IPython.core.hooks.CommandChainDispatcher object at 0x7f51c0186fd0>, 'from': <IPython.core.hooks.CommandChainDispatcher object at 0x7f51c0186e80>, '%reset': <IPython.core.hooks.CommandChainDispatcher object at 0x7f51c01863c8>, '%aimport': <IPython.core.hooks.CommandChainDispatcher object at 0x7f51c0186f28>, 'import': <IPython.core.hooks.CommandChainDispatcher object at 0x7f51c0186e48>, '%cd': <IPython.core.hooks.CommandChainDispatcher object at 0x7f51c0186358>}, {}>,
 {'regexs': {},
  'strs': {'%aimport': <IPython.core.hooks.CommandChainDispatcher at 0x7f51c0186f28>,
   '%cd': <IPython.core.hooks.CommandChainDispatcher at 0x7f51c0186358>,
   '%reset': <IPython.core.hooks.CommandChainDispatcher at 0x7f51c01863c8>,
   '%run': <IPython.core.hooks.CommandChainDispatcher at 0x7f51c0186fd0>,
   'from': <IPython.core.hooks.CommandChainDispatcher at 0x7f51c0186e80>,
   'import': <IPython.core.hooks.CommandChainDispatcher at 0x7f51c0186e48>}},
 {'complete_command': <Strdispatch {'%run': <IPython.core.hooks.CommandChainDispatcher object at 0x7f51c0186fd0>, 'from': <IPython.core.hooks.CommandChainDispatcher object at 0x7f51c0186e80>, '%reset': <IPython.core.hooks.CommandChainDispatcher object at 0x7f51c01863c8>, '%aimport': <IPython.core.hooks.CommandChainDispatcher object at 0x7f51c0186f28>, 'import': <IPython.core.hooks.CommandChainDispatcher object at 0x7f51c0186e48>, '%cd': <IPython.core.hooks.CommandChainDispatcher object at 0x7f51c0186358>}, {}>},
 {'%aimport': <IPython.core.hooks.CommandChainDispatcher at 0x7f51c0186f28>,
  '%cd': <IPython.core.hooks.CommandChainDispatcher at 0x7f51c0186358>,
  '%reset': <IPython.core.hooks.CommandChainDispatcher at 0x7f51c01863c8>,
  '%run': <IPython.core.hooks.CommandChainDispatcher at 0x7f51c0186fd0>,
  'from': <IPython.core.hooks.CommandChainDispatcher at 0x7f51c0186e80>,
  'import': <IPython.core.hooks.CommandChainDispatcher at 0x7f51c0186e48>},
 <IPython.core.hooks.CommandChainDispatcher at 0x7f51c0186e80>,
 {'chain': [(50,
    <bound method ZMQInteractiveShell.module_completer of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>)]},
 <IPython.core.hooks.CommandChainDispatcher at 0x7f51c0186f28>,
 {'chain': [(50,
    <bound method ZMQInteractiveShell.module_completer of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>)]},
 <IPython.core.hooks.CommandChainDispatcher at 0x7f51c0186fd0>,
 {'chain': [(50,
    <bound method ZMQInteractiveShell.magic_run_completer of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f51c12210b8>>)]},
 <IPython.core.hooks.CommandChainDispatcher at 0x7f51c0186358>,
 ...]

%magic¶

https://ipython.org/ipython-doc/3/interactive/magics.html

In [24]:

%lsmagic

Out[24]:

Available line magics:
%alias  %alias_magic  %autocall  %automagic  %autosave  %bookmark  %cat  %cd  %clear  %colors  %config  %connect_info  %cp  %debug  %dhist  %dirs  %doctest_mode  %ed  %edit  %env  %gui  %hist  %history  %install_default_config  %install_ext  %install_profiles  %killbgscripts  %ldir  %less  %lf  %lk  %ll  %load  %load_ext  %loadpy  %logoff  %logon  %logstart  %logstate  %logstop  %ls  %lsmagic  %lx  %macro  %magic  %man  %matplotlib  %mkdir  %more  %mv  %notebook  %page  %pastebin  %pdb  %pdef  %pdoc  %pfile  %pinfo  %pinfo2  %popd  %pprint  %precision  %profile  %prun  %psearch  %psource  %pushd  %pwd  %pycat  %pylab  %qtconsole  %quickref  %recall  %rehashx  %reload_ext  %rep  %rerun  %reset  %reset_selective  %rm  %rmdir  %run  %save  %sc  %set_env  %store  %sx  %system  %tb  %time  %timeit  %unalias  %unload_ext  %who  %who_ls  %whos  %xdel  %xmode

Available cell magics:
%%!  %%HTML  %%SVG  %%bash  %%capture  %%debug  %%file  %%html  %%javascript  %%latex  %%perl  %%prun  %%pypy  %%python  %%python2  %%python3  %%ruby  %%script  %%sh  %%svg  %%sx  %%system  %%time  %%timeit  %%writefile

Automagic is ON, % prefix IS NOT needed for line magics.

In [25]:

%magic

In [26]:

%timeit range(1000)

The slowest run took 19.35 times longer than the fastest. This could mean that an intermediate result is being cached.
1000000 loops, best of 3: 660 ns per loop

In [32]:

%time range(1000)

CPU times: user 0 ns, sys: 0 ns, total: 0 ns
Wall time: 761 µs

Out[32]:

range(0, 1000)

In [27]:

%pinfo x

In [28]:

%pinfo2 x

In [30]:

%pprint

Pretty printing has been turned ON

In [31]:

%prun range(1000)

Table of Contents

Functions¶

Pass functions (Closure)¶

Dependant default values¶

Typed arguments¶

ООП¶

Class, instance, default (!) static vars¶

Instance variables by :¶

init of parent must be called always!¶

Global constants¶

Call method by its string name¶

getattr¶

Class instance by its string name¶

function objectByClassName¶

Language constructions¶

Exceptions¶

Eval¶

Time measure¶

String format¶

Escape¶

Garbage Collection¶

%magic¶