Merge pull request #7554 from jdfreder/interact-fix

Use Output widget with Interact

IPython/html/widgets/interaction.py

@@ -1,344 +1,349 b''
 """Interact with functions using widgets."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from __future__ import print_function
 
 try:  # Python >= 3.3
     from inspect import signature, Parameter
 except ImportError:
     from IPython.utils.signatures import signature, Parameter
 from inspect import getcallargs
 
 from IPython.core.getipython import get_ipython
 from IPython.html.widgets import (Widget, Text,
     FloatSlider, IntSlider, Checkbox, Dropdown,
-    Box, Button, DOMWidget)
+    Box, Button, DOMWidget, Output)
 from IPython.display import display, clear_output
 from IPython.utils.py3compat import string_types, unicode_type
 from IPython.utils.traitlets import HasTraits, Any, Unicode
 
 empty = Parameter.empty
 
 
 def _matches(o, pattern):
     """Match a pattern of types in a sequence."""
     if not len(o) == len(pattern):
         return False
     comps = zip(o,pattern)
     return all(isinstance(obj,kind) for obj,kind in comps)
 
 
 def _get_min_max_value(min, max, value=None, step=None):
     """Return min, max, value given input values with possible None."""
     if value is None:
         if not max > min:
             raise ValueError('max must be greater than min: (min={0}, max={1})'.format(min, max))
         value = min + abs(min-max)/2
         value = type(min)(value)
     elif min is None and max is None:
         if value == 0.0:
             min, max, value = 0.0, 1.0, 0.5
         elif value == 0:
             min, max, value = 0, 1, 0
         elif isinstance(value, (int, float)):
             min, max = (-value, 3*value) if value > 0 else (3*value, -value)
         else:
             raise TypeError('expected a number, got: %r' % value)
     else:
         raise ValueError('unable to infer range, value from: ({0}, {1}, {2})'.format(min, max, value))
     if step is not None:
         # ensure value is on a step
         r = (value - min) % step
         value = value - r
     return min, max, value
 
 def _widget_abbrev_single_value(o):
     """Make widgets from single values, which can be used as parameter defaults."""
     if isinstance(o, string_types):
         return Text(value=unicode_type(o))
     elif isinstance(o, dict):
         return Dropdown(values=o)
     elif isinstance(o, bool):
         return Checkbox(value=o)
     elif isinstance(o, float):
         min, max, value = _get_min_max_value(None, None, o)
         return FloatSlider(value=o, min=min, max=max)
     elif isinstance(o, int):
         min, max, value = _get_min_max_value(None, None, o)
         return IntSlider(value=o, min=min, max=max)
     else:
         return None
 
 def _widget_abbrev(o):
     """Make widgets from abbreviations: single values, lists or tuples."""
     float_or_int = (float, int)
     if isinstance(o, (list, tuple)):
         if o and all(isinstance(x, string_types) for x in o):
             return Dropdown(values=[unicode_type(k) for k in o])
         elif _matches(o, (float_or_int, float_or_int)):
             min, max, value = _get_min_max_value(o[0], o[1])
             if all(isinstance(_, int) for _ in o):
                 cls = IntSlider
             else:
                 cls = FloatSlider
             return cls(value=value, min=min, max=max)
         elif _matches(o, (float_or_int, float_or_int, float_or_int)):
             step = o[2]
             if step <= 0:
                 raise ValueError("step must be >= 0, not %r" % step)
             min, max, value = _get_min_max_value(o[0], o[1], step=step)
             if all(isinstance(_, int) for _ in o):
                 cls = IntSlider
             else:
                 cls = FloatSlider
             return cls(value=value, min=min, max=max, step=step)
     else:
         return _widget_abbrev_single_value(o)
 
 def _widget_from_abbrev(abbrev, default=empty):
     """Build a Widget instance given an abbreviation or Widget."""
     if isinstance(abbrev, Widget) or isinstance(abbrev, fixed):
         return abbrev
 
     widget = _widget_abbrev(abbrev)
     if default is not empty and isinstance(abbrev, (list, tuple, dict)):
         # if it's not a single-value abbreviation,
         # set the initial value from the default
         try:
             widget.value = default
         except Exception:
             # ignore failure to set default
             pass
     if widget is None:
         raise ValueError("%r cannot be transformed to a Widget" % (abbrev,))
     return widget
 
 def _yield_abbreviations_for_parameter(param, kwargs):
     """Get an abbreviation for a function parameter."""
     name = param.name
     kind = param.kind
     ann = param.annotation
     default = param.default
     not_found = (name, empty, empty)
     if kind in (Parameter.POSITIONAL_OR_KEYWORD, Parameter.KEYWORD_ONLY):
         if name in kwargs:
             value = kwargs.pop(name)
         elif ann is not empty:
             value = ann
         elif default is not empty:
             value = default
         else:
             yield not_found
         yield (name, value, default)
     elif kind == Parameter.VAR_KEYWORD:
         # In this case name=kwargs and we yield the items in kwargs with their keys.
         for k, v in kwargs.copy().items():
             kwargs.pop(k)
             yield k, v, empty
 
 def _find_abbreviations(f, kwargs):
     """Find the abbreviations for a function and kwargs passed to interact."""
     new_kwargs = []
     for param in signature(f).parameters.values():
         for name, value, default in _yield_abbreviations_for_parameter(param, kwargs):
             if value is empty:
                 raise ValueError('cannot find widget or abbreviation for argument: {!r}'.format(name))
             new_kwargs.append((name, value, default))
     return new_kwargs
 
 def _widgets_from_abbreviations(seq):
     """Given a sequence of (name, abbrev) tuples, return a sequence of Widgets."""
     result = []
     for name, abbrev, default in seq:
         widget = _widget_from_abbrev(abbrev, default)
         if not widget.description:
             widget.description = name
         widget._kwarg = name
         result.append(widget)
     return result
 
 def interactive(__interact_f, **kwargs):
     """
     Builds a group of interactive widgets tied to a function and places the
     group into a Box container.
 
     Returns
     -------
     container : a Box instance containing multiple widgets
 
     Parameters
     ----------
     __interact_f : function
         The function to which the interactive widgets are tied. The **kwargs
         should match the function signature.
     **kwargs : various, optional
         An interactive widget is created for each keyword argument that is a
         valid widget abbreviation.
     """
     f = __interact_f
     co = kwargs.pop('clear_output', True)
     manual = kwargs.pop('__manual', False)
     kwargs_widgets = []
     container = Box()
     container.result = None
     container.args = []
     container.kwargs = dict()
     kwargs = kwargs.copy()
 
     new_kwargs = _find_abbreviations(f, kwargs)
     # Before we proceed, let's make sure that the user has passed a set of args+kwargs
     # that will lead to a valid call of the function. This protects against unspecified
     # and doubly-specified arguments.
     getcallargs(f, **{n:v for n,v,_ in new_kwargs})
     # Now build the widgets from the abbreviations.
     kwargs_widgets.extend(_widgets_from_abbreviations(new_kwargs))
 
     # This has to be done as an assignment, not using container.children.append,
     # so that traitlets notices the update. We skip any objects (such as fixed) that
     # are not DOMWidgets.
     c = [w for w in kwargs_widgets if isinstance(w, DOMWidget)]
 
     # If we are only to run the function on demand, add a button to request this
     if manual:
         manual_button = Button(description="Run %s" % f.__name__)
         c.append(manual_button)
+
+    # Use an output widget to capture the output of interact.
+    output = Output()
+    c.append(output)
     container.children = c
 
     # Build the callback
     def call_f(name=None, old=None, new=None):
-        container.kwargs = {}
-        for widget in kwargs_widgets:
-            value = widget.value
-            container.kwargs[widget._kwarg] = value
-        if co:
-            clear_output(wait=True)
-        if manual:
-            manual_button.disabled = True
-        try:
-            container.result = f(**container.kwargs)
-        except Exception as e:
-            ip = get_ipython()
-            if ip is None:
-                container.log.warn("Exception in interact callback: %s", e, exc_info=True)
-            else:
-                ip.showtraceback()
-        finally:
+        with output:
+            container.kwargs = {}
+            for widget in kwargs_widgets:
+                value = widget.value
+                container.kwargs[widget._kwarg] = value
+            if co:
+                clear_output(wait=True)
             if manual:
-                manual_button.disabled = False
+                manual_button.disabled = True
+            try:
+                container.result = f(**container.kwargs)
+            except Exception as e:
+                ip = get_ipython()
+                if ip is None:
+                    container.log.warn("Exception in interact callback: %s", e, exc_info=True)
+                else:
+                    ip.showtraceback()
+            finally:
+                if manual:
+                    manual_button.disabled = False
 
     # Wire up the widgets
     # If we are doing manual running, the callback is only triggered by the button
     # Otherwise, it is triggered for every trait change received
     # On-demand running also suppresses running the function with the initial parameters
     if manual:
         manual_button.on_click(call_f)
     else:
         for widget in kwargs_widgets:
             widget.on_trait_change(call_f, 'value')
 
         container.on_displayed(lambda _: call_f(None, None, None))
 
     return container
 
 def interact(__interact_f=None, **kwargs):
     """
     Displays interactive widgets which are tied to a function.
     Expects the first argument to be a function. Parameters to this function are
     widget abbreviations passed in as keyword arguments (**kwargs). Can be used
     as a decorator (see examples).
 
     Returns
     -------
     f : __interact_f with interactive widget attached to it.
 
     Parameters
     ----------
     __interact_f : function
         The function to which the interactive widgets are tied. The **kwargs
         should match the function signature. Passed to :func:`interactive()`
     **kwargs : various, optional
         An interactive widget is created for each keyword argument that is a
         valid widget abbreviation. Passed to :func:`interactive()`
 
     Examples
     --------
     Renders an interactive text field that shows the greeting with the passed in
     text.
 
     1. Invocation of interact as a function
        def greeting(text="World"):
            print "Hello {}".format(text)
        interact(greeting, text="IPython Widgets")
         
     2. Invocation of interact as a decorator
        @interact
        def greeting(text="World"):
            print "Hello {}".format(text)
         
     3. Invocation of interact as a decorator with named parameters
        @interact(text="IPython Widgets")
        def greeting(text="World"):
            print "Hello {}".format(text)
         
     Renders an interactive slider widget and prints square of number.
 
     1. Invocation of interact as a function
        def square(num=1):
            print "{} squared is {}".format(num, num*num)
        interact(square, num=5)
 
     2. Invocation of interact as a decorator
        @interact
        def square(num=2):
            print "{} squared is {}".format(num, num*num)
         
     3. Invocation of interact as a decorator with named parameters
        @interact(num=5)
        def square(num=2):
            print "{} squared is {}".format(num, num*num)
     """
     # positional arg support in: https://gist.github.com/8851331
     if __interact_f is not None:
         # This branch handles the cases 1 and 2
         # 1. interact(f, **kwargs)
         # 2. @interact
         #    def f(*args, **kwargs):
         #        ...
         f = __interact_f
         w = interactive(f, **kwargs)
         try:
             f.widget = w
         except AttributeError:
             # some things (instancemethods) can't have attributes attached,
             # so wrap in a lambda
             f = lambda *args, **kwargs: __interact_f(*args, **kwargs)
             f.widget = w
         display(w)
         return f
     else:
         # This branch handles the case 3
         # @interact(a=30, b=40)
         # def f(*args, **kwargs):
         #     ...
         def dec(f):
             return interact(f, **kwargs)
         return dec
 
 def interact_manual(__interact_f=None, **kwargs):
     """interact_manual(f, **kwargs)
     
     As `interact()`, generates widgets for each argument, but rather than running
     the function after each widget change, adds a "Run" button and waits for it
     to be clicked. Useful if the function is long-running and has several
     parameters to change.
     """
     return interact(__interact_f, __manual=True, **kwargs)
 
 class fixed(HasTraits):
     """A pseudo-widget whose value is fixed and never synced to the client."""
     value = Any(help="Any Python object")
     description = Unicode('', help="Any Python object")
     def __init__(self, value, **kwargs):
         super(fixed, self).__init__(value=value, **kwargs)

IPython/html/widgets/tests/test_interaction.py

@@ -1,635 +1,636 b''
 """Test interact and interactive."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from __future__ import print_function
 
 from collections import OrderedDict
 
 import nose.tools as nt
 import IPython.testing.tools as tt
 
 from IPython.kernel.comm import Comm
 from IPython.html import widgets
 from IPython.html.widgets import interact, interactive, Widget, interaction
 from IPython.utils.py3compat import annotate
 
 #-----------------------------------------------------------------------------
 # Utility stuff
 #-----------------------------------------------------------------------------
 
 class DummyComm(Comm):
     comm_id = 'a-b-c-d'
     
     def open(self, *args, **kwargs):
         pass
     
     def send(self, *args, **kwargs):
         pass
     
     def close(self, *args, **kwargs):
         pass
 
 _widget_attrs = {}
 displayed = []
 undefined = object()
 
 def setup():
     _widget_attrs['_comm_default'] = getattr(Widget, '_comm_default', undefined)
     Widget._comm_default = lambda self: DummyComm()
     _widget_attrs['_ipython_display_'] = Widget._ipython_display_
     def raise_not_implemented(*args, **kwargs):
         raise NotImplementedError()
     Widget._ipython_display_ = raise_not_implemented
 
 def teardown():
     for attr, value in _widget_attrs.items():
         if value is undefined:
             delattr(Widget, attr)
         else:
             setattr(Widget, attr, value)
 
 def f(**kwargs):
     pass
 
 def clear_display():
     global displayed
     displayed = []
 
 def record_display(*args):
     displayed.extend(args)
 
 #-----------------------------------------------------------------------------
 # Actual tests
 #-----------------------------------------------------------------------------
 
 def check_widget(w, **d):
     """Check a single widget against a dict"""
     for attr, expected in d.items():
         if attr == 'cls':
             nt.assert_is(w.__class__, expected)
         else:
             value = getattr(w, attr)
             nt.assert_equal(value, expected,
                 "%s.%s = %r != %r" % (w.__class__.__name__, attr, value, expected)
             )
 
 def check_widgets(container, **to_check):
     """Check that widgets are created as expected"""
     # build a widget dictionary, so it matches
     widgets = {}
     for w in container.children:
-        widgets[w.description] = w
+        if hasattr(w, 'description'):
+            widgets[w.description] = w
     
     for key, d in to_check.items():
         nt.assert_in(key, widgets)
         check_widget(widgets[key], **d)
     
 
 def test_single_value_string():
     a = u'hello'
     c = interactive(f, a=a)
     w = c.children[0]
     check_widget(w,
         cls=widgets.Text,
         description='a',
         value=a,
     )
 
 def test_single_value_bool():
     for a in (True, False):
         c = interactive(f, a=a)
         w = c.children[0]
         check_widget(w,
             cls=widgets.Checkbox,
             description='a',
             value=a,
         )
 
 def test_single_value_dict():
     for d in [
         dict(a=5),
         dict(a=5, b='b', c=dict),
     ]:
         c = interactive(f, d=d)
         w = c.children[0]
         check_widget(w,
             cls=widgets.Dropdown,
             description='d',
             values=d,
             value=next(iter(d.values())),
         )
 
 def test_single_value_float():
     for a in (2.25, 1.0, -3.5):
         c = interactive(f, a=a)
         w = c.children[0]
         check_widget(w,
             cls=widgets.FloatSlider,
             description='a',
             value=a,
             min= -a if a > 0 else 3*a,
             max= 3*a if a > 0 else -a,
             step=0.1,
             readout=True,
         )
 
 def test_single_value_int():
     for a in (1, 5, -3):
         c = interactive(f, a=a)
-        nt.assert_equal(len(c.children), 1)
+        nt.assert_equal(len(c.children), 2)
         w = c.children[0]
         check_widget(w,
             cls=widgets.IntSlider,
             description='a',
             value=a,
             min= -a if a > 0 else 3*a,
             max= 3*a if a > 0 else -a,
             step=1,
             readout=True,
         )
 
 def test_list_tuple_2_int():
     with nt.assert_raises(ValueError):
         c = interactive(f, tup=(1,1))
     with nt.assert_raises(ValueError):
         c = interactive(f, tup=(1,-1))
     for min, max in [ (0,1), (1,10), (1,2), (-5,5), (-20,-19) ]:
         c = interactive(f, tup=(min, max), lis=[min, max])
-        nt.assert_equal(len(c.children), 2)
+        nt.assert_equal(len(c.children), 3)
         d = dict(
             cls=widgets.IntSlider,
             min=min,
             max=max,
             step=1,
             readout=True,
         )
         check_widgets(c, tup=d, lis=d)
 
 def test_list_tuple_3_int():
     with nt.assert_raises(ValueError):
         c = interactive(f, tup=(1,2,0))
     with nt.assert_raises(ValueError):
         c = interactive(f, tup=(1,2,-1))
     for min, max, step in [ (0,2,1), (1,10,2), (1,100,2), (-5,5,4), (-100,-20,4) ]:
         c = interactive(f, tup=(min, max, step), lis=[min, max, step])
-        nt.assert_equal(len(c.children), 2)
+        nt.assert_equal(len(c.children), 3)
         d = dict(
             cls=widgets.IntSlider,
             min=min,
             max=max,
             step=step,
             readout=True,
         )
         check_widgets(c, tup=d, lis=d)
 
 def test_list_tuple_2_float():
     with nt.assert_raises(ValueError):
         c = interactive(f, tup=(1.0,1.0))
     with nt.assert_raises(ValueError):
         c = interactive(f, tup=(0.5,-0.5))
     for min, max in [ (0.5, 1.5), (1.1,10.2), (1,2.2), (-5.,5), (-20,-19.) ]:
         c = interactive(f, tup=(min, max), lis=[min, max])
-        nt.assert_equal(len(c.children), 2)
+        nt.assert_equal(len(c.children), 3)
         d = dict(
             cls=widgets.FloatSlider,
             min=min,
             max=max,
             step=.1,
             readout=True,
         )
         check_widgets(c, tup=d, lis=d)
 
 def test_list_tuple_3_float():
     with nt.assert_raises(ValueError):
         c = interactive(f, tup=(1,2,0.0))
     with nt.assert_raises(ValueError):
         c = interactive(f, tup=(-1,-2,1.))
     with nt.assert_raises(ValueError):
         c = interactive(f, tup=(1,2.,-1.))
     for min, max, step in [ (0.,2,1), (1,10.,2), (1,100,2.), (-5.,5.,4), (-100,-20.,4.) ]:
         c = interactive(f, tup=(min, max, step), lis=[min, max, step])
-        nt.assert_equal(len(c.children), 2)
+        nt.assert_equal(len(c.children), 3)
         d = dict(
             cls=widgets.FloatSlider,
             min=min,
             max=max,
             step=step,
             readout=True,
         )
         check_widgets(c, tup=d, lis=d)
 
 def test_list_tuple_str():
     values = ['hello', 'there', 'guy']
     first = values[0]
     c = interactive(f, tup=tuple(values), lis=list(values))
-    nt.assert_equal(len(c.children), 2)
+    nt.assert_equal(len(c.children), 3)
     d = dict(
         cls=widgets.Dropdown,
         value=first,
         values=values
     )
     check_widgets(c, tup=d, lis=d)
 
 def test_list_tuple_invalid():
     for bad in [
         (),
         (5, 'hi'),
         ('hi', 5),
         ({},),
         (None,),
     ]:
         with nt.assert_raises(ValueError):
             print(bad) # because there is no custom message in assert_raises
             c = interactive(f, tup=bad)
 
 def test_defaults():
     @annotate(n=10)
     def f(n, f=4.5, g=1):
         pass
     
     c = interactive(f)
     check_widgets(c,
         n=dict(
             cls=widgets.IntSlider,
             value=10,
         ),
         f=dict(
             cls=widgets.FloatSlider,
             value=4.5,
         ),
         g=dict(
             cls=widgets.IntSlider,
             value=1,
         ),
     )
 
 def test_default_values():
     @annotate(n=10, f=(0, 10.), g=5, h={'a': 1, 'b': 2}, j=['hi', 'there'])
     def f(n, f=4.5, g=1, h=2, j='there'):
         pass
     
     c = interactive(f)
     check_widgets(c,
         n=dict(
             cls=widgets.IntSlider,
             value=10,
         ),
         f=dict(
             cls=widgets.FloatSlider,
             value=4.5,
         ),
         g=dict(
             cls=widgets.IntSlider,
             value=5,
         ),
         h=dict(
             cls=widgets.Dropdown,
             values={'a': 1, 'b': 2},
             value=2
         ),
         j=dict(
             cls=widgets.Dropdown,
             values=['hi', 'there'],
             value='there'
         ),
     )
 
 def test_default_out_of_bounds():
     @annotate(f=(0, 10.), h={'a': 1}, j=['hi', 'there'])
     def f(f='hi', h=5, j='other'):
         pass
     
     c = interactive(f)
     check_widgets(c,
         f=dict(
             cls=widgets.FloatSlider,
             value=5.,
         ),
         h=dict(
             cls=widgets.Dropdown,
             values={'a': 1},
             value=1,
         ),
         j=dict(
             cls=widgets.Dropdown,
             values=['hi', 'there'],
             value='hi',
         ),
     )
 
 def test_annotations():
     @annotate(n=10, f=widgets.FloatText())
     def f(n, f):
         pass
     
     c = interactive(f)
     check_widgets(c,
         n=dict(
             cls=widgets.IntSlider,
             value=10,
         ),
         f=dict(
             cls=widgets.FloatText,
         ),
     )
 
 def test_priority():
     @annotate(annotate='annotate', kwarg='annotate')
     def f(kwarg='default', annotate='default', default='default'):
         pass
     
     c = interactive(f, kwarg='kwarg')
     check_widgets(c,
         kwarg=dict(
             cls=widgets.Text,
             value='kwarg',
         ),
         annotate=dict(
             cls=widgets.Text,
             value='annotate',
         ),
     )
 
 @nt.with_setup(clear_display)
 def test_decorator_kwarg():
     with tt.monkeypatch(interaction, 'display', record_display):
         @interact(a=5)
         def foo(a):
             pass
     nt.assert_equal(len(displayed), 1)
     w = displayed[0].children[0]
     check_widget(w,
         cls=widgets.IntSlider,
         value=5,
     )
 
 @nt.with_setup(clear_display)
 def test_interact_instancemethod():
     class Foo(object):
         def show(self, x):
             print(x)
 
     f = Foo()
     
     with tt.monkeypatch(interaction, 'display', record_display):
         g = interact(f.show, x=(1,10))
     nt.assert_equal(len(displayed), 1)
     w = displayed[0].children[0]
     check_widget(w,
         cls=widgets.IntSlider,
         value=5,
     )
 
 @nt.with_setup(clear_display)
 def test_decorator_no_call():
     with tt.monkeypatch(interaction, 'display', record_display):
         @interact
         def foo(a='default'):
             pass
     nt.assert_equal(len(displayed), 1)
     w = displayed[0].children[0]
     check_widget(w,
         cls=widgets.Text,
         value='default',
     )
 
 @nt.with_setup(clear_display)
 def test_call_interact():
     def foo(a='default'):
         pass
     with tt.monkeypatch(interaction, 'display', record_display):
         ifoo = interact(foo)
     nt.assert_equal(len(displayed), 1)
     w = displayed[0].children[0]
     check_widget(w,
         cls=widgets.Text,
         value='default',
     )
 
 @nt.with_setup(clear_display)
 def test_call_interact_kwargs():
     def foo(a='default'):
         pass
     with tt.monkeypatch(interaction, 'display', record_display):
         ifoo = interact(foo, a=10)
     nt.assert_equal(len(displayed), 1)
     w = displayed[0].children[0]
     check_widget(w,
         cls=widgets.IntSlider,
         value=10,
     )
 
 @nt.with_setup(clear_display)
 def test_call_decorated_on_trait_change():
     """test calling @interact decorated functions"""
     d = {}
     with tt.monkeypatch(interaction, 'display', record_display):
         @interact
         def foo(a='default'):
             d['a'] = a
             return a
     nt.assert_equal(len(displayed), 1)
     w = displayed[0].children[0]
     check_widget(w,
         cls=widgets.Text,
         value='default',
     )
     # test calling the function directly
     a = foo('hello')
     nt.assert_equal(a, 'hello')
     nt.assert_equal(d['a'], 'hello')
     
     # test that setting trait values calls the function
     w.value = 'called'
     nt.assert_equal(d['a'], 'called')
 
 @nt.with_setup(clear_display)
 def test_call_decorated_kwargs_on_trait_change():
     """test calling @interact(foo=bar) decorated functions"""
     d = {}
     with tt.monkeypatch(interaction, 'display', record_display):
         @interact(a='kwarg')
         def foo(a='default'):
             d['a'] = a
             return a
     nt.assert_equal(len(displayed), 1)
     w = displayed[0].children[0]
     check_widget(w,
         cls=widgets.Text,
         value='kwarg',
     )
     # test calling the function directly
     a = foo('hello')
     nt.assert_equal(a, 'hello')
     nt.assert_equal(d['a'], 'hello')
     
     # test that setting trait values calls the function
     w.value = 'called'
     nt.assert_equal(d['a'], 'called')
 
 def test_fixed():
     c = interactive(f, a=widgets.fixed(5), b='text')
-    nt.assert_equal(len(c.children), 1)
+    nt.assert_equal(len(c.children), 2)
     w = c.children[0]
     check_widget(w,
         cls=widgets.Text,
         value='text',
         description='b',
     )
 
 def test_default_description():
     c = interactive(f, b='text')
     w = c.children[0]
     check_widget(w,
         cls=widgets.Text,
         value='text',
         description='b',
     )
 
 def test_custom_description():
     d = {}
     def record_kwargs(**kwargs):
         d.clear()
         d.update(kwargs)
     
     c = interactive(record_kwargs, b=widgets.Text(value='text', description='foo'))
     w = c.children[0]
     check_widget(w,
         cls=widgets.Text,
         value='text',
         description='foo',
     )
     w.value = 'different text'
     nt.assert_equal(d, {'b': 'different text'})
 
 def test_interact_manual_button():
     c = interactive(f, __manual=True)
     w = c.children[0]
     check_widget(w, cls=widgets.Button)
 
 def test_interact_manual_nocall():
     callcount = 0
     def calltest(testarg):
         callcount += 1
     c = interactive(calltest, testarg=5, __manual=True)
     c.children[0].value = 10
     nt.assert_equal(callcount, 0)
 
 def test_int_range_logic():
     irsw = widgets.IntRangeSlider
     w = irsw(value=(2, 4), min=0, max=6)
     check_widget(w, cls=irsw, value=(2, 4), min=0, max=6)
     w.value = (4, 2)
     check_widget(w, cls=irsw, value=(2, 4), min=0, max=6)
     w.value = (-1, 7)
     check_widget(w, cls=irsw, value=(0, 6), min=0, max=6)
     w.min = 3
     check_widget(w, cls=irsw, value=(3, 6), min=3, max=6)
     w.max = 3
     check_widget(w, cls=irsw, value=(3, 3), min=3, max=3)
     
     w.min = 0
     w.max = 6
     w.lower = 2
     w.upper = 4
     check_widget(w, cls=irsw, value=(2, 4), min=0, max=6)
     w.value = (0, 1) #lower non-overlapping range
     check_widget(w, cls=irsw, value=(0, 1), min=0, max=6)
     w.value = (5, 6) #upper non-overlapping range
     check_widget(w, cls=irsw, value=(5, 6), min=0, max=6)
     w.value = (-1, 4) #semi out-of-range
     check_widget(w, cls=irsw, value=(0, 4), min=0, max=6)
     w.lower = 2
     check_widget(w, cls=irsw, value=(2, 4), min=0, max=6)
     w.value = (-2, -1) #wholly out of range
     check_widget(w, cls=irsw, value=(0, 0), min=0, max=6)
     w.value = (7, 8)
     check_widget(w, cls=irsw, value=(6, 6), min=0, max=6)
     
     with nt.assert_raises(ValueError):
         w.min = 7
     with nt.assert_raises(ValueError):
         w.max = -1
     with nt.assert_raises(ValueError):
         w.lower = 5
     with nt.assert_raises(ValueError):
         w.upper = 1
     
     w = irsw(min=2, max=3)
     check_widget(w, min=2, max=3)
     w = irsw(min=100, max=200)
     check_widget(w, lower=125, upper=175, value=(125, 175))
     
     with nt.assert_raises(ValueError):
         irsw(value=(2, 4), lower=3)
     with nt.assert_raises(ValueError):
         irsw(value=(2, 4), upper=3)
     with nt.assert_raises(ValueError):
         irsw(value=(2, 4), lower=3, upper=3)
     with nt.assert_raises(ValueError):
         irsw(min=2, max=1)
     with nt.assert_raises(ValueError):
         irsw(lower=5)
     with nt.assert_raises(ValueError):
         irsw(upper=5)
     
 
 def test_float_range_logic():
     frsw = widgets.FloatRangeSlider
     w = frsw(value=(.2, .4), min=0., max=.6)
     check_widget(w, cls=frsw, value=(.2, .4), min=0., max=.6)
     w.value = (.4, .2)
     check_widget(w, cls=frsw, value=(.2, .4), min=0., max=.6)
     w.value = (-.1, .7)
     check_widget(w, cls=frsw, value=(0., .6), min=0., max=.6)
     w.min = .3
     check_widget(w, cls=frsw, value=(.3, .6), min=.3, max=.6)
     w.max = .3
     check_widget(w, cls=frsw, value=(.3, .3), min=.3, max=.3)
     
     w.min = 0.
     w.max = .6
     w.lower = .2
     w.upper = .4
     check_widget(w, cls=frsw, value=(.2, .4), min=0., max=.6)
     w.value = (0., .1) #lower non-overlapping range
     check_widget(w, cls=frsw, value=(0., .1), min=0., max=.6)
     w.value = (.5, .6) #upper non-overlapping range
     check_widget(w, cls=frsw, value=(.5, .6), min=0., max=.6)
     w.value = (-.1, .4) #semi out-of-range
     check_widget(w, cls=frsw, value=(0., .4), min=0., max=.6)
     w.lower = .2
     check_widget(w, cls=frsw, value=(.2, .4), min=0., max=.6)
     w.value = (-.2, -.1) #wholly out of range
     check_widget(w, cls=frsw, value=(0., 0.), min=0., max=.6)
     w.value = (.7, .8)
     check_widget(w, cls=frsw, value=(.6, .6), min=.0, max=.6)
     
     with nt.assert_raises(ValueError):
         w.min = .7
     with nt.assert_raises(ValueError):
         w.max = -.1
     with nt.assert_raises(ValueError):
         w.lower = .5
     with nt.assert_raises(ValueError):
         w.upper = .1
     
     w = frsw(min=2, max=3)
     check_widget(w, min=2, max=3)
     w = frsw(min=1., max=2.)
     check_widget(w, lower=1.25, upper=1.75, value=(1.25, 1.75))
     
     with nt.assert_raises(ValueError):
         frsw(value=(2, 4), lower=3)
     with nt.assert_raises(ValueError):
         frsw(value=(2, 4), upper=3)
     with nt.assert_raises(ValueError):
         frsw(value=(2, 4), lower=3, upper=3)
     with nt.assert_raises(ValueError):
         frsw(min=.2, max=.1)
     with nt.assert_raises(ValueError):
         frsw(lower=5)
     with nt.assert_raises(ValueError):
         frsw(upper=5)

IPython/html/widgets/widget_output.py

@@ -1,78 +1,88 b''
 """Output class.  
 
 Represents a widget that can be used to display output within the widget area.
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from .widget import DOMWidget
 import sys
 from IPython.utils.traitlets import Unicode, List
 from IPython.display import clear_output
 from IPython.testing.skipdoctest import skip_doctest
 from IPython.kernel.zmq.session import Message
 
 @skip_doctest
 class Output(DOMWidget):
     """Widget used as a context manager to display output.
 
     This widget can capture and display stdout, stderr, and rich output.  To use
     it, create an instance of it and display it.  Then use it as a context
     manager.  Any output produced while in it's context will be captured and
     displayed in it instead of the standard output area.
 
     Example
         from IPython.html import widgets
         from IPython.display import display
         out = widgets.Output()
         display(out)
         
         print('prints to output area')
 
         with out:
             print('prints to output widget')"""
     _view_name = Unicode('OutputView', sync=True)
 
+    def __init__(self, *args, **kwargs):
+        super(Output, self).__init__(*args, **kwargs)
+        from IPython import get_ipython
+        ip = get_ipython()
+        if ip is not None and hasattr(ip, 'kernel'):
+            self._kernel = ip.kernel
+        else:
+            self._kernel = None
+
     def clear_output(self, *pargs, **kwargs):
         with self:
             clear_output(*pargs, **kwargs)
 
     def __enter__(self):
         """Called upon entering output widget context manager."""
-        self._flush()
-        kernel = get_ipython().kernel
-        session = kernel.session
-        send = session.send
-        self._original_send = send
-        self._session = session
-
-        def send_hook(stream, msg_or_type, content=None, parent=None, ident=None,
-             buffers=None, track=False, header=None, metadata=None): 
-
-            # Handle both prebuild messages and unbuilt messages.
-            if isinstance(msg_or_type, (Message, dict)):
-                msg_type = msg_or_type['msg_type']
-                msg = dict(msg_or_type)
-            else:
-                msg_type = msg_or_type
-                msg = session.msg(msg_type, content=content, parent=parent, 
-                    header=header, metadata=metadata)
-
-            # If this is a message type that we want to forward, forward it.
-            if stream is kernel.iopub_socket and msg_type in ['clear_output', 'stream', 'display_data']:
-                self.send(msg)
-            else: 
-                send(stream, msg, ident=ident, buffers=buffers, track=track)
-
-        session.send = send_hook
+        if self._kernel is not None:
+            self._flush()
+            session = self._kernel.session
+            send = session.send
+            self._original_send = send
+            self._session = session
+
+            def send_hook(stream, msg_or_type, content=None, parent=None, ident=None,
+                 buffers=None, track=False, header=None, metadata=None): 
+
+                # Handle both prebuild messages and unbuilt messages.
+                if isinstance(msg_or_type, (Message, dict)):
+                    msg_type = msg_or_type['msg_type']
+                    msg = dict(msg_or_type)
+                else:
+                    msg_type = msg_or_type
+                    msg = session.msg(msg_type, content=content, parent=parent, 
+                        header=header, metadata=metadata)
+
+                # If this is a message type that we want to forward, forward it.
+                if stream is self._kernel.iopub_socket and msg_type in ['clear_output', 'stream', 'display_data']:
+                    self.send(msg)
+                else: 
+                    send(stream, msg, ident=ident, buffers=buffers, track=track)
+
+            session.send = send_hook
 
     def __exit__(self, exception_type, exception_value, traceback):
         """Called upon exiting output widget context manager."""
-        self._flush()
-        self._session.send = self._original_send
+        if self._kernel is not None:
+            self._flush()
+            self._session.send = self._original_send
 
     def _flush(self):
         """Flush stdout and stderr buffers."""
         sys.stdout.flush()
         sys.stderr.flush()