Get widgets from function annotations and default arguments.

Also, preserve the order of function parameters from the signature where
possible.

This uses a backport of the Python 3.3 signature machinery that @minrk
found and improved.

IPython/utils/signatures.py

@@ -0,0 +1,819 b''
+"""Function signature objects for callables
+
+Back port of Python 3.3's function signature tools from the inspect module,
+modified to be compatible with Python 2.6, 2.7 and 3.2+.
+"""
+
+#-----------------------------------------------------------------------------
+#  Python 3.3 stdlib inspect.py is public domain
+# 
+#  Backports Copyright (C) 2013 Aaron Iles
+#  Used under Apache License Version 2.0
+#
+#  Further Changes are Copyright (C) 2013 The IPython Development Team
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#-----------------------------------------------------------------------------
+
+from __future__ import absolute_import, division, print_function
+import itertools
+import functools
+import re
+import types
+
+
+# patch for single-file
+# we don't support 2.6, so we can just import OrderedDict
+from collections import OrderedDict
+
+__version__ = '0.3'
+# end patch
+
+__all__ = ['BoundArguments', 'Parameter', 'Signature', 'signature']
+
+
+_WrapperDescriptor = type(type.__call__)
+_MethodWrapper = type(all.__call__)
+
+_NonUserDefinedCallables = (_WrapperDescriptor,
+                            _MethodWrapper,
+                            types.BuiltinFunctionType)
+
+
+def formatannotation(annotation, base_module=None):
+    if isinstance(annotation, type):
+        if annotation.__module__ in ('builtins', '__builtin__', base_module):
+            return annotation.__name__
+        return annotation.__module__+'.'+annotation.__name__
+    return repr(annotation)
+
+
+def _get_user_defined_method(cls, method_name, *nested):
+    try:
+        if cls is type:
+            return
+        meth = getattr(cls, method_name)
+        for name in nested:
+            meth = getattr(meth, name, meth)
+    except AttributeError:
+        return
+    else:
+        if not isinstance(meth, _NonUserDefinedCallables):
+            # Once '__signature__' will be added to 'C'-level
+            # callables, this check won't be necessary
+            return meth
+
+
+def signature(obj):
+    '''Get a signature object for the passed callable.'''
+
+    if not callable(obj):
+        raise TypeError('{0!r} is not a callable object'.format(obj))
+
+    if isinstance(obj, types.MethodType):
+        # In this case we skip the first parameter of the underlying
+        # function (usually `self` or `cls`).
+        sig = signature(obj.__func__)
+        return sig.replace(parameters=tuple(sig.parameters.values())[1:])
+
+    try:
+        sig = obj.__signature__
+    except AttributeError:
+        pass
+    else:
+        if sig is not None:
+            return sig
+
+    try:
+        # Was this function wrapped by a decorator?
+        wrapped = obj.__wrapped__
+    except AttributeError:
+        pass
+    else:
+        return signature(wrapped)
+
+    if isinstance(obj, types.FunctionType):
+        return Signature.from_function(obj)
+
+    if isinstance(obj, functools.partial):
+        sig = signature(obj.func)
+
+        new_params = OrderedDict(sig.parameters.items())
+
+        partial_args = obj.args or ()
+        partial_keywords = obj.keywords or {}
+        try:
+            ba = sig.bind_partial(*partial_args, **partial_keywords)
+        except TypeError as ex:
+            msg = 'partial object {0!r} has incorrect arguments'.format(obj)
+            raise ValueError(msg)
+
+        for arg_name, arg_value in ba.arguments.items():
+            param = new_params[arg_name]
+            if arg_name in partial_keywords:
+                # We set a new default value, because the following code
+                # is correct:
+                #
+                #   >>> def foo(a): print(a)
+                #   >>> print(partial(partial(foo, a=10), a=20)())
+                #   20
+                #   >>> print(partial(partial(foo, a=10), a=20)(a=30))
+                #   30
+                #
+                # So, with 'partial' objects, passing a keyword argument is
+                # like setting a new default value for the corresponding
+                # parameter
+                #
+                # We also mark this parameter with '_partial_kwarg'
+                # flag.  Later, in '_bind', the 'default' value of this
+                # parameter will be added to 'kwargs', to simulate
+                # the 'functools.partial' real call.
+                new_params[arg_name] = param.replace(default=arg_value,
+                                                     _partial_kwarg=True)
+
+            elif (param.kind not in (_VAR_KEYWORD, _VAR_POSITIONAL) and
+                            not param._partial_kwarg):
+                new_params.pop(arg_name)
+
+        return sig.replace(parameters=new_params.values())
+
+    sig = None
+    if isinstance(obj, type):
+        # obj is a class or a metaclass
+
+        # First, let's see if it has an overloaded __call__ defined
+        # in its metaclass
+        call = _get_user_defined_method(type(obj), '__call__')
+        if call is not None:
+            sig = signature(call)
+        else:
+            # Now we check if the 'obj' class has a '__new__' method
+            new = _get_user_defined_method(obj, '__new__')
+            if new is not None:
+                sig = signature(new)
+            else:
+                # Finally, we should have at least __init__ implemented
+                init = _get_user_defined_method(obj, '__init__')
+                if init is not None:
+                    sig = signature(init)
+    elif not isinstance(obj, _NonUserDefinedCallables):
+        # An object with __call__
+        # We also check that the 'obj' is not an instance of
+        # _WrapperDescriptor or _MethodWrapper to avoid
+        # infinite recursion (and even potential segfault)
+        call = _get_user_defined_method(type(obj), '__call__', 'im_func')
+        if call is not None:
+            sig = signature(call)
+
+    if sig is not None:
+        return sig
+
+    if isinstance(obj, types.BuiltinFunctionType):
+        # Raise a nicer error message for builtins
+        msg = 'no signature found for builtin function {0!r}'.format(obj)
+        raise ValueError(msg)
+
+    raise ValueError('callable {0!r} is not supported by signature'.format(obj))
+
+
+class _void(object):
+    '''A private marker - used in Parameter & Signature'''
+
+
+class _empty(object):
+    pass
+
+
+class _ParameterKind(int):
+    def __new__(self, *args, **kwargs):
+        obj = int.__new__(self, *args)
+        obj._name = kwargs['name']
+        return obj
+
+    def __str__(self):
+        return self._name
+
+    def __repr__(self):
+        return '<_ParameterKind: {0!r}>'.format(self._name)
+
+
+_POSITIONAL_ONLY        = _ParameterKind(0, name='POSITIONAL_ONLY')
+_POSITIONAL_OR_KEYWORD  = _ParameterKind(1, name='POSITIONAL_OR_KEYWORD')
+_VAR_POSITIONAL         = _ParameterKind(2, name='VAR_POSITIONAL')
+_KEYWORD_ONLY           = _ParameterKind(3, name='KEYWORD_ONLY')
+_VAR_KEYWORD            = _ParameterKind(4, name='VAR_KEYWORD')
+
+
+class Parameter(object):
+    '''Represents a parameter in a function signature.
+
+    Has the following public attributes:
+
+    * name : str
+        The name of the parameter as a string.
+    * default : object
+        The default value for the parameter if specified.  If the
+        parameter has no default value, this attribute is not set.
+    * annotation
+        The annotation for the parameter if specified.  If the
+        parameter has no annotation, this attribute is not set.
+    * kind : str
+        Describes how argument values are bound to the parameter.
+        Possible values: `Parameter.POSITIONAL_ONLY`,
+        `Parameter.POSITIONAL_OR_KEYWORD`, `Parameter.VAR_POSITIONAL`,
+        `Parameter.KEYWORD_ONLY`, `Parameter.VAR_KEYWORD`.
+    '''
+
+    __slots__ = ('_name', '_kind', '_default', '_annotation', '_partial_kwarg')
+
+    POSITIONAL_ONLY         = _POSITIONAL_ONLY
+    POSITIONAL_OR_KEYWORD   = _POSITIONAL_OR_KEYWORD
+    VAR_POSITIONAL          = _VAR_POSITIONAL
+    KEYWORD_ONLY            = _KEYWORD_ONLY
+    VAR_KEYWORD             = _VAR_KEYWORD
+
+    empty = _empty
+
+    def __init__(self, name, kind, default=_empty, annotation=_empty,
+                 _partial_kwarg=False):
+
+        if kind not in (_POSITIONAL_ONLY, _POSITIONAL_OR_KEYWORD,
+                        _VAR_POSITIONAL, _KEYWORD_ONLY, _VAR_KEYWORD):
+            raise ValueError("invalid value for 'Parameter.kind' attribute")
+        self._kind = kind
+
+        if default is not _empty:
+            if kind in (_VAR_POSITIONAL, _VAR_KEYWORD):
+                msg = '{0} parameters cannot have default values'.format(kind)
+                raise ValueError(msg)
+        self._default = default
+        self._annotation = annotation
+
+        if name is None:
+            if kind != _POSITIONAL_ONLY:
+                raise ValueError("None is not a valid name for a "
+                                 "non-positional-only parameter")
+            self._name = name
+        else:
+            name = str(name)
+            if kind != _POSITIONAL_ONLY and not re.match(r'[a-z_]\w*$', name, re.I):
+                msg = '{0!r} is not a valid parameter name'.format(name)
+                raise ValueError(msg)
+            self._name = name
+
+        self._partial_kwarg = _partial_kwarg
+
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def default(self):
+        return self._default
+
+    @property
+    def annotation(self):
+        return self._annotation
+
+    @property
+    def kind(self):
+        return self._kind
+
+    def replace(self, name=_void, kind=_void, annotation=_void,
+                default=_void, _partial_kwarg=_void):
+        '''Creates a customized copy of the Parameter.'''
+
+        if name is _void:
+            name = self._name
+
+        if kind is _void:
+            kind = self._kind
+
+        if annotation is _void:
+            annotation = self._annotation
+
+        if default is _void:
+            default = self._default
+
+        if _partial_kwarg is _void:
+            _partial_kwarg = self._partial_kwarg
+
+        return type(self)(name, kind, default=default, annotation=annotation,
+                          _partial_kwarg=_partial_kwarg)
+
+    def __str__(self):
+        kind = self.kind
+
+        formatted = self._name
+        if kind == _POSITIONAL_ONLY:
+            if formatted is None:
+                formatted = ''
+            formatted = '<{0}>'.format(formatted)
+
+        # Add annotation and default value
+        if self._annotation is not _empty:
+            formatted = '{0}:{1}'.format(formatted,
+                                       formatannotation(self._annotation))
+
+        if self._default is not _empty:
+            formatted = '{0}={1}'.format(formatted, repr(self._default))
+
+        if kind == _VAR_POSITIONAL:
+            formatted = '*' + formatted
+        elif kind == _VAR_KEYWORD:
+            formatted = '**' + formatted
+
+        return formatted
+
+    def __repr__(self):
+        return '<{0} at {1:#x} {2!r}>'.format(self.__class__.__name__,
+                                           id(self), self.name)
+
+    def __hash__(self):
+        msg = "unhashable type: '{0}'".format(self.__class__.__name__)
+        raise TypeError(msg)
+
+    def __eq__(self, other):
+        return (issubclass(other.__class__, Parameter) and
+                self._name == other._name and
+                self._kind == other._kind and
+                self._default == other._default and
+                self._annotation == other._annotation)
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+
+class BoundArguments(object):
+    '''Result of `Signature.bind` call.  Holds the mapping of arguments
+    to the function's parameters.
+
+    Has the following public attributes:
+
+    * arguments : OrderedDict
+        An ordered mutable mapping of parameters' names to arguments' values.
+        Does not contain arguments' default values.
+    * signature : Signature
+        The Signature object that created this instance.
+    * args : tuple
+        Tuple of positional arguments values.
+    * kwargs : dict
+        Dict of keyword arguments values.
+    '''
+
+    def __init__(self, signature, arguments):
+        self.arguments = arguments
+        self._signature = signature
+
+    @property
+    def signature(self):
+        return self._signature
+
+    @property
+    def args(self):
+        args = []
+        for param_name, param in self._signature.parameters.items():
+            if (param.kind in (_VAR_KEYWORD, _KEYWORD_ONLY) or
+                                                    param._partial_kwarg):
+                # Keyword arguments mapped by 'functools.partial'
+                # (Parameter._partial_kwarg is True) are mapped
+                # in 'BoundArguments.kwargs', along with VAR_KEYWORD &
+                # KEYWORD_ONLY
+                break
+
+            try:
+                arg = self.arguments[param_name]
+            except KeyError:
+                # We're done here. Other arguments
+                # will be mapped in 'BoundArguments.kwargs'
+                break
+            else:
+                if param.kind == _VAR_POSITIONAL:
+                    # *args
+                    args.extend(arg)
+                else:
+                    # plain argument
+                    args.append(arg)
+
+        return tuple(args)
+
+    @property
+    def kwargs(self):
+        kwargs = {}
+        kwargs_started = False
+        for param_name, param in self._signature.parameters.items():
+            if not kwargs_started:
+                if (param.kind in (_VAR_KEYWORD, _KEYWORD_ONLY) or
+                                                param._partial_kwarg):
+                    kwargs_started = True
+                else:
+                    if param_name not in self.arguments:
+                        kwargs_started = True
+                        continue
+
+            if not kwargs_started:
+                continue
+
+            try:
+                arg = self.arguments[param_name]
+            except KeyError:
+                pass
+            else:
+                if param.kind == _VAR_KEYWORD:
+                    # **kwargs
+                    kwargs.update(arg)
+                else:
+                    # plain keyword argument
+                    kwargs[param_name] = arg
+
+        return kwargs
+
+    def __hash__(self):
+        msg = "unhashable type: '{0}'".format(self.__class__.__name__)
+        raise TypeError(msg)
+
+    def __eq__(self, other):
+        return (issubclass(other.__class__, BoundArguments) and
+                self.signature == other.signature and
+                self.arguments == other.arguments)
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+
+class Signature(object):
+    '''A Signature object represents the overall signature of a function.
+    It stores a Parameter object for each parameter accepted by the
+    function, as well as information specific to the function itself.
+
+    A Signature object has the following public attributes and methods:
+
+    * parameters : OrderedDict
+        An ordered mapping of parameters' names to the corresponding
+        Parameter objects (keyword-only arguments are in the same order
+        as listed in `code.co_varnames`).
+    * return_annotation : object
+        The annotation for the return type of the function if specified.
+        If the function has no annotation for its return type, this
+        attribute is not set.
+    * bind(*args, **kwargs) -> BoundArguments
+        Creates a mapping from positional and keyword arguments to
+        parameters.
+    * bind_partial(*args, **kwargs) -> BoundArguments
+        Creates a partial mapping from positional and keyword arguments
+        to parameters (simulating 'functools.partial' behavior.)
+    '''
+
+    __slots__ = ('_return_annotation', '_parameters')
+
+    _parameter_cls = Parameter
+    _bound_arguments_cls = BoundArguments
+
+    empty = _empty
+
+    def __init__(self, parameters=None, return_annotation=_empty,
+                 __validate_parameters__=True):
+        '''Constructs Signature from the given list of Parameter
+        objects and 'return_annotation'.  All arguments are optional.
+        '''
+
+        if parameters is None:
+            params = OrderedDict()
+        else:
+            if __validate_parameters__:
+                params = OrderedDict()
+                top_kind = _POSITIONAL_ONLY
+
+                for idx, param in enumerate(parameters):
+                    kind = param.kind
+                    if kind < top_kind:
+                        msg = 'wrong parameter order: {0} before {1}'
+                        msg = msg.format(top_kind, param.kind)
+                        raise ValueError(msg)
+                    else:
+                        top_kind = kind
+
+                    name = param.name
+                    if name is None:
+                        name = str(idx)
+                        param = param.replace(name=name)
+
+                    if name in params:
+                        msg = 'duplicate parameter name: {0!r}'.format(name)
+                        raise ValueError(msg)
+                    params[name] = param
+            else:
+                params = OrderedDict(((param.name, param)
+                                                for param in parameters))
+
+        self._parameters = params
+        self._return_annotation = return_annotation
+
+    @classmethod
+    def from_function(cls, func):
+        '''Constructs Signature for the given python function'''
+
+        if not isinstance(func, types.FunctionType):
+            raise TypeError('{0!r} is not a Python function'.format(func))
+
+        Parameter = cls._parameter_cls
+
+        # Parameter information.
+        func_code = func.__code__
+        pos_count = func_code.co_argcount
+        arg_names = func_code.co_varnames
+        positional = tuple(arg_names[:pos_count])
+        keyword_only_count = getattr(func_code, 'co_kwonlyargcount', 0)
+        keyword_only = arg_names[pos_count:(pos_count + keyword_only_count)]
+        annotations = getattr(func, '__annotations__', {})
+        defaults = func.__defaults__
+        kwdefaults = getattr(func, '__kwdefaults__', None)
+
+        if defaults:
+            pos_default_count = len(defaults)
+        else:
+            pos_default_count = 0
+
+        parameters = []
+
+        # Non-keyword-only parameters w/o defaults.
+        non_default_count = pos_count - pos_default_count
+        for name in positional[:non_default_count]:
+            annotation = annotations.get(name, _empty)
+            parameters.append(Parameter(name, annotation=annotation,
+                                        kind=_POSITIONAL_OR_KEYWORD))
+
+        # ... w/ defaults.
+        for offset, name in enumerate(positional[non_default_count:]):
+            annotation = annotations.get(name, _empty)
+            parameters.append(Parameter(name, annotation=annotation,
+                                        kind=_POSITIONAL_OR_KEYWORD,
+                                        default=defaults[offset]))
+
+        # *args
+        if func_code.co_flags & 0x04:
+            name = arg_names[pos_count + keyword_only_count]
+            annotation = annotations.get(name, _empty)
+            parameters.append(Parameter(name, annotation=annotation,
+                                        kind=_VAR_POSITIONAL))
+
+        # Keyword-only parameters.
+        for name in keyword_only:
+            default = _empty
+            if kwdefaults is not None:
+                default = kwdefaults.get(name, _empty)
+
+            annotation = annotations.get(name, _empty)
+            parameters.append(Parameter(name, annotation=annotation,
+                                        kind=_KEYWORD_ONLY,
+                                        default=default))
+        # **kwargs
+        if func_code.co_flags & 0x08:
+            index = pos_count + keyword_only_count
+            if func_code.co_flags & 0x04:
+                index += 1
+
+            name = arg_names[index]
+            annotation = annotations.get(name, _empty)
+            parameters.append(Parameter(name, annotation=annotation,
+                                        kind=_VAR_KEYWORD))
+
+        return cls(parameters,
+                   return_annotation=annotations.get('return', _empty),
+                   __validate_parameters__=False)
+
+    @property
+    def parameters(self):
+        try:
+            return types.MappingProxyType(self._parameters)
+        except AttributeError:
+            return OrderedDict(self._parameters.items())
+
+    @property
+    def return_annotation(self):
+        return self._return_annotation
+
+    def replace(self, parameters=_void, return_annotation=_void):
+        '''Creates a customized copy of the Signature.
+        Pass 'parameters' and/or 'return_annotation' arguments
+        to override them in the new copy.
+        '''
+
+        if parameters is _void:
+            parameters = self.parameters.values()
+
+        if return_annotation is _void:
+            return_annotation = self._return_annotation
+
+        return type(self)(parameters,
+                          return_annotation=return_annotation)
+
+    def __hash__(self):
+        msg = "unhashable type: '{0}'".format(self.__class__.__name__)
+        raise TypeError(msg)
+
+    def __eq__(self, other):
+        if (not issubclass(type(other), Signature) or
+                    self.return_annotation != other.return_annotation or
+                    len(self.parameters) != len(other.parameters)):
+            return False
+
+        other_positions = dict((param, idx)
+                           for idx, param in enumerate(other.parameters.keys()))
+
+        for idx, (param_name, param) in enumerate(self.parameters.items()):
+            if param.kind == _KEYWORD_ONLY:
+                try:
+                    other_param = other.parameters[param_name]
+                except KeyError:
+                    return False
+                else:
+                    if param != other_param:
+                        return False
+            else:
+                try:
+                    other_idx = other_positions[param_name]
+                except KeyError:
+                    return False
+                else:
+                    if (idx != other_idx or
+                                    param != other.parameters[param_name]):
+                        return False
+
+        return True
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def _bind(self, args, kwargs, partial=False):
+        '''Private method.  Don't use directly.'''
+
+        arguments = OrderedDict()
+
+        parameters = iter(self.parameters.values())
+        parameters_ex = ()
+        arg_vals = iter(args)
+
+        if partial:
+            # Support for binding arguments to 'functools.partial' objects.
+            # See 'functools.partial' case in 'signature()' implementation
+            # for details.
+            for param_name, param in self.parameters.items():
+                if (param._partial_kwarg and param_name not in kwargs):
+                    # Simulating 'functools.partial' behavior
+                    kwargs[param_name] = param.default
+
+        while True:
+            # Let's iterate through the positional arguments and corresponding
+            # parameters
+            try:
+                arg_val = next(arg_vals)
+            except StopIteration:
+                # No more positional arguments
+                try:
+                    param = next(parameters)
+                except StopIteration:
+                    # No more parameters. That's it. Just need to check that
+                    # we have no `kwargs` after this while loop
+                    break
+                else:
+                    if param.kind == _VAR_POSITIONAL:
+                        # That's OK, just empty *args.  Let's start parsing
+                        # kwargs
+                        break
+                    elif param.name in kwargs:
+                        if param.kind == _POSITIONAL_ONLY:
+                            msg = '{arg!r} parameter is positional only, ' \
+                                  'but was passed as a keyword'
+                            msg = msg.format(arg=param.name)
+                            raise TypeError(msg)
+                        parameters_ex = (param,)
+                        break
+                    elif (param.kind == _VAR_KEYWORD or
+                                                param.default is not _empty):
+                        # That's fine too - we have a default value for this
+                        # parameter.  So, lets start parsing `kwargs`, starting
+                        # with the current parameter
+                        parameters_ex = (param,)
+                        break
+                    else:
+                        if partial:
+                            parameters_ex = (param,)
+                            break
+                        else:
+                            msg = '{arg!r} parameter lacking default value'
+                            msg = msg.format(arg=param.name)
+                            raise TypeError(msg)
+            else:
+                # We have a positional argument to process
+                try:
+                    param = next(parameters)
+                except StopIteration:
+                    raise TypeError('too many positional arguments')
+                else:
+                    if param.kind in (_VAR_KEYWORD, _KEYWORD_ONLY):
+                        # Looks like we have no parameter for this positional
+                        # argument
+                        raise TypeError('too many positional arguments')
+
+                    if param.kind == _VAR_POSITIONAL:
+                        # We have an '*args'-like argument, let's fill it with
+                        # all positional arguments we have left and move on to
+                        # the next phase
+                        values = [arg_val]
+                        values.extend(arg_vals)
+                        arguments[param.name] = tuple(values)
+                        break
+
+                    if param.name in kwargs:
+                        raise TypeError('multiple values for argument '
+                                        '{arg!r}'.format(arg=param.name))
+
+                    arguments[param.name] = arg_val
+
+        # Now, we iterate through the remaining parameters to process
+        # keyword arguments
+        kwargs_param = None
+        for param in itertools.chain(parameters_ex, parameters):
+            if param.kind == _POSITIONAL_ONLY:
+                # This should never happen in case of a properly built
+                # Signature object (but let's have this check here
+                # to ensure correct behaviour just in case)
+                raise TypeError('{arg!r} parameter is positional only, '
+                                'but was passed as a keyword'. \
+                                format(arg=param.name))
+
+            if param.kind == _VAR_KEYWORD:
+                # Memorize that we have a '**kwargs'-like parameter
+                kwargs_param = param
+                continue
+
+            param_name = param.name
+            try:
+                arg_val = kwargs.pop(param_name)
+            except KeyError:
+                # We have no value for this parameter.  It's fine though,
+                # if it has a default value, or it is an '*args'-like
+                # parameter, left alone by the processing of positional
+                # arguments.
+                if (not partial and param.kind != _VAR_POSITIONAL and
+                                                    param.default is _empty):
+                    raise TypeError('{arg!r} parameter lacking default value'. \
+                                    format(arg=param_name))
+
+            else:
+                arguments[param_name] = arg_val
+
+        if kwargs:
+            if kwargs_param is not None:
+                # Process our '**kwargs'-like parameter
+                arguments[kwargs_param.name] = kwargs
+            else:
+                raise TypeError('too many keyword arguments')
+
+        return self._bound_arguments_cls(self, arguments)
+
+    def bind(self, *args, **kwargs):
+        '''Get a BoundArguments object, that maps the passed `args`
+        and `kwargs` to the function's signature.  Raises `TypeError`
+        if the passed arguments can not be bound.
+        '''
+        return self._bind(args, kwargs)
+
+    def bind_partial(self, *args, **kwargs):
+        '''Get a BoundArguments object, that partially maps the
+        passed `args` and `kwargs` to the function's signature.
+        Raises `TypeError` if the passed arguments can not be bound.
+        '''
+        return self._bind(args, kwargs, partial=True)
+
+    def __str__(self):
+        result = []
+        render_kw_only_separator = True
+        for idx, param in enumerate(self.parameters.values()):
+            formatted = str(param)
+
+            kind = param.kind
+            if kind == _VAR_POSITIONAL:
+                # OK, we have an '*args'-like parameter, so we won't need
+                # a '*' to separate keyword-only arguments
+                render_kw_only_separator = False
+            elif kind == _KEYWORD_ONLY and render_kw_only_separator:
+                # We have a keyword-only parameter to render and we haven't
+                # rendered an '*args'-like parameter before, so add a '*'
+                # separator to the parameters list ("foo(arg1, *, arg2)" case)
+                result.append('*')
+                # This condition should be only triggered once, so
+                # reset the flag
+                render_kw_only_separator = False
+
+            result.append(formatted)
+
+        rendered = '({0})'.format(', '.join(result))
+
+        if self.return_annotation is not _empty:
+            anno = formatannotation(self.return_annotation)
+            rendered += ' -> {0}'.format(anno)
+
+        return rendered

IPython/html/widgets/interact.py

@@ -13,6 +13,11 b''
 # Imports
 #-----------------------------------------------------------------------------
 
+try:  # Python >= 3.3
+    from inspect import signature, Parameter
+except ImportError:
+    from IPython.utils.signatures import signature, Parameter
+
 from IPython.html.widgets import (Widget, TextWidget,
     FloatSliderWidget, IntSliderWidget, CheckboxWidget, DropdownWidget,
     ContainerWidget)
@@ -48,13 +53,13 b' def _get_min_max_value(min, max, value):'
         elif isinstance(value, int):
             min, max = -value, 3*value
         else:
-            raise TypeError('expected a number, got: %r' % number)
+            raise TypeError('expected a number, got: %r' % value)
     else:
         raise ValueError('unable to infer range, value from: ({0}, {1}, {2})'.format(min, max, value))
     return min, max, value
 
-
-def _widget_abbrev(o):
+def _widget_abbrev_single_value(o):
+    """Make widgets from single values, which can be used written as parameter defaults."""
     if isinstance(o, string_types):
         return TextWidget(value=unicode_type(o))
     elif isinstance(o, dict):
@@ -72,6 +77,9 b' def _widget_abbrev(o):'
     elif isinstance(o, int):
         min, max, value = _get_min_max_value(None, None, o)
         return IntSliderWidget(value=o, min=min, max=max)
+
+def _widget_abbrev(o):
+    """Make widgets from abbreviations: single values, lists or tuples."""
     if isinstance(o, (list, tuple)):
         if _matches(o, (int, int)):
             min, max, value = _get_min_max_value(o[0], o[1], None)
@@ -92,9 +100,45 b' def _widget_abbrev(o):'
             return DropdownWidget(value=unicode_type(o[0]),
                                    values=[unicode_type(k) for k in o])
 
+    else:
+        return _widget_abbrev_single_value(o)
+
+def _widget_or_abbrev(value):
+    if isinstance(value, Widget):
+        return value
+    
+    widget = _widget_abbrev(value)
+    if widget is None:
+        raise ValueError("%r cannot be transformed to a Widget" % value)
+    return widget
+
+def _widget_for_param(param, kwargs):
+    """Get a widget for a parameter.
+    
+    We look for, in this order:
+    - keyword arguments passed to interact[ive]() that match the parameter name.
+    - function annotations
+    - default values
+    
+    Returns an instance of Widget, or None if nothing suitable is found.
+    
+    Raises ValueError if the kwargs or annotation value cannot be made into
+    a widget.
+    """
+    if param.name in kwargs:
+        return _widget_or_abbrev(kwargs.pop(param.name))
+    
+    if param.annotation is not Parameter.empty:
+        return _widget_or_abbrev(param.annotation)
+    
+    if param.default is not Parameter.empty:
+        # Returns None if it's not suitable
+        return _widget_abbrev_single_value(param.default)
+    
+    return None
 
 def interactive(f, **kwargs):
-    """Interact with a function using widgets."""
+    """Build a group of widgets for setting the inputs to a function."""
     
     co = kwargs.pop('clear_output', True)
     # First convert all args to Widget instances
@@ -102,31 +146,37 b' def interactive(f, **kwargs):'
     container = ContainerWidget()
     container.result = None
     container.kwargs = dict()
-    for key, value in kwargs.items():
-        if isinstance(value, Widget):
-            widget = value
-        else:
-            widget = _widget_abbrev(value)
-            if widget is None:
-                raise ValueError("Object cannot be transformed to a Widget")
-        widget.description = key
-        widgets.append((key,widget))
-    widgets.sort(key=lambda e: e[1].__class__.__name__)
-    container.children = [e[1] for e in widgets]
+    
+    # Extract parameters from the function signature
+    for param in signature(f).parameters.values():
+        param_widget = _widget_for_param(param, kwargs)
+        if param_widget is not None:
+            param_widget.description = param.name
+            widgets.append(param_widget)
+    
+    # Extra parameters from keyword args - we assume f takes **kwargs
+    for name, value in sorted(kwargs.items(), key = lambda x: x[0]):
+        widget = _widget_or_abbrev(value)
+        widget.description = name
+        widgets.append(widget)
+    
+    # This has to be done as an assignment, not using container.children.append,
+    # so that traitlets notices the update.
+    container.children = widgets
 
     # Build the callback
     def call_f(name, old, new):
         actual_kwargs = {}
-        for key, widget in widgets:
+        for widget in widgets:
             value = widget.value
-            container.kwargs[key] = value
-            actual_kwargs[key] = value
+            container.kwargs[widget.description] = value
+            actual_kwargs[widget.description] = value
         if co:
             clear_output(wait=True)
         container.result = f(**actual_kwargs)
 
     # Wire up the widgets
-    for key, widget in widgets:
+    for widget in widgets:
         widget.on_trait_change(call_f, 'value')
 
     container.on_displayed(lambda _: call_f(None, None, None))
@@ -134,6 +184,7 b' def interactive(f, **kwargs):'
     return container
 
 def interact(f, **kwargs):
+    """Interact with a function using widgets."""
     w = interactive(f, **kwargs)
     f.widget = w
     display(w)

examples/widgets/Interact.ipynb

@@ -39,7 +39,8 b''
        ]
       }
      ],
-     "prompt_number": 1
+     "prompt_number": 1,
+     "trusted": true
     },
     {
      "cell_type": "code",
@@ -52,7 +53,8 b''
      "language": "python",
      "metadata": {},
      "outputs": [],
-     "prompt_number": 2
+     "prompt_number": 2,
+     "trusted": true
     },
     {
      "cell_type": "heading",
@@ -83,7 +85,8 b''
      "language": "python",
      "metadata": {},
      "outputs": [],
-     "prompt_number": 3
+     "prompt_number": 3,
+     "trusted": true
     },
     {
      "cell_type": "code",
@@ -97,19 +100,20 b''
       {
        "html": [
         "<h3>Arguments:</h3><table>\n",
-        "<tr><td>a</td><td>10</td></tr>\n",
-        "<tr><td>c</td><td>True</td></tr>\n",
         "<tr><td>b</td><td>Hi There</td></tr>\n",
+        "<tr><td>c</td><td>True</td></tr>\n",
+        "<tr><td>a</td><td>10</td></tr>\n",
         "</table>"
        ],
        "metadata": {},
        "output_type": "display_data",
        "text": [
-        "<IPython.core.display.HTML at 0x106c8b6d0>"
+        "<IPython.core.display.HTML at 0x7fe6335b25d0>"
        ]
       }
      ],
-     "prompt_number": 4
+     "prompt_number": 4,
+     "trusted": true
     },
     {
      "cell_type": "markdown",
@@ -127,32 +131,15 b''
       "         Current=(0.,10.,0.01),\n",
       "         z=True,\n",
       "         Text=u'Type here!',\n",
-      "         Algorithm=['This','That','Other'],\n",
+      "         #Algorithm=['This','That','Other'],\n",
       "         a=widgets.FloatSliderWidget(min=-10.0, max=10.0, step=0.1, value=5.0)\n",
       "         )"
      ],
      "language": "python",
      "metadata": {},
-     "outputs": [
-      {
-       "html": [
-        "<h3>Arguments:</h3><table>\n",
-        "<tr><td>a</td><td>0.3</td></tr>\n",
-        "<tr><td>Algorithm</td><td>This</td></tr>\n",
-        "<tr><td>Temp</td><td>5</td></tr>\n",
-        "<tr><td>Text</td><td>Type here!</td></tr>\n",
-        "<tr><td>Current</td><td>5.0</td></tr>\n",
-        "<tr><td>z</td><td>True</td></tr>\n",
-        "</table>"
-       ],
-       "metadata": {},
-       "output_type": "display_data",
-       "text": [
-        "<IPython.core.display.HTML at 0x106c8b6d0>"
-       ]
-      }
-     ],
-     "prompt_number": 5
+     "outputs": [],
+     "prompt_number": 6,
+     "trusted": true
     },
     {
      "cell_type": "markdown",
@@ -186,7 +173,8 b''
      "language": "python",
      "metadata": {},
      "outputs": [],
-     "prompt_number": 6
+     "prompt_number": 6,
+     "trusted": true
     },
     {
      "cell_type": "code",
@@ -197,7 +185,8 b''
      "language": "python",
      "metadata": {},
      "outputs": [],
-     "prompt_number": 7
+     "prompt_number": 7,
+     "trusted": true
     },
     {
      "cell_type": "code",
@@ -209,7 +198,8 b''
      "language": "python",
      "metadata": {},
      "outputs": [],
-     "prompt_number": 8
+     "prompt_number": 8,
+     "trusted": true
     },
     {
      "cell_type": "markdown",
@@ -222,28 +212,45 b''
      "cell_type": "code",
      "collapsed": false,
      "input": [
-      "interact(factorit, n=(2,40))"
+      "factorit(12)"
      ],
      "language": "python",
      "metadata": {},
      "outputs": [
       {
+       "output_type": "stream",
+       "stream": "stderr",
+       "text": [
+        "/home/takluyver/.local/lib/python3.3/site-packages/IPython/core/formatters.py:199: FormatterWarning: Exception in image/png formatter: string argument expected, got 'bytes'\n",
+        "  FormatterWarning,\n"
+       ]
+      },
+      {
        "latex": [
-        "$$x^{21} - 1 = \\left(x - 1\\right) \\left(x^{2} + x + 1\\right) \\left(x^{6} + x^{5} + x^{4} + x^{3} + x^{2} + x + 1\\right) \\left(x^{12} - x^{11} + x^{9} - x^{8} + x^{6} - x^{4} + x^{3} - x + 1\\right)$$"
+        "$$x^{12} - 1 = \\left(x - 1\\right) \\left(x + 1\\right) \\left(x^{2} + 1\\right) \\left(x^{2} - x + 1\\right) \\left(x^{2} + x + 1\\right) \\left(x^{4} - x^{2} + 1\\right)$$"
        ],
        "metadata": {},
        "output_type": "display_data",
-       "png": "iVBORw0KGgoAAAANSUhEUgAAA9AAAAAcBAMAAAB7QkqJAAAAMFBMVEX///8AAAAAAAAAAAAAAAAA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\neTnCfTaX4+L+v6Y93YHXAQyZujC8GDlfAAAAAElFTkSuQmCC\n",
        "text": [
-        " 21               \u239b 2        \u239e \u239b 6    5    4    3    2        \u239e \u239b 12    11    \n",
-        "x   - 1 = (x - 1)\u22c5\u239dx  + x + 1\u23a0\u22c5\u239dx  + x  + x  + x  + x  + x + 1\u23a0\u22c5\u239dx   - x   + x\n",
-        "\n",
-        "9    8    6    4    3        \u239e\n",
-        "  - x  + x  - x  + x  - x + 1\u23a0"
+        " 12                       \u239b 2    \u239e \u239b 2        \u239e \u239b 2        \u239e \u239b 4    2    \u239e\n",
+        "x   - 1 = (x - 1)\u22c5(x + 1)\u22c5\u239dx  + 1\u23a0\u22c5\u239dx  - x + 1\u23a0\u22c5\u239dx  + x + 1\u23a0\u22c5\u239dx  - x  + 1\u23a0"
        ]
       }
      ],
-     "prompt_number": 9
+     "prompt_number": 11,
+     "trusted": true
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "interact(factorit, n=(2,40))"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [],
+     "prompt_number": 9,
+     "trusted": true
     },
     {
      "cell_type": "heading",
@@ -269,7 +276,8 b''
      "language": "python",
      "metadata": {},
      "outputs": [],
-     "prompt_number": 10
+     "prompt_number": 10,
+     "trusted": false
     },
     {
      "cell_type": "markdown",
@@ -287,7 +295,8 b''
      "language": "python",
      "metadata": {},
      "outputs": [],
-     "prompt_number": 11
+     "prompt_number": 11,
+     "trusted": false
     },
     {
      "cell_type": "code",
@@ -304,7 +313,8 b''
      "language": "python",
      "metadata": {},
      "outputs": [],
-     "prompt_number": 12
+     "prompt_number": 12,
+     "trusted": false
     },
     {
      "cell_type": "code",
@@ -324,7 +334,8 b''
        ]
       }
      ],
-     "prompt_number": 13
+     "prompt_number": 13,
+     "trusted": false
     },
     {
      "cell_type": "heading",
@@ -350,7 +361,8 b''
      "language": "python",
      "metadata": {},
      "outputs": [],
-     "prompt_number": 14
+     "prompt_number": 14,
+     "trusted": false
     },
     {
      "cell_type": "code",
@@ -364,7 +376,8 b''
      "language": "python",
      "metadata": {},
      "outputs": [],
-     "prompt_number": 15
+     "prompt_number": 15,
+     "trusted": false
     },
     {
      "cell_type": "code",
@@ -377,29 +390,8 b''
      ],
      "language": "python",
      "metadata": {},
-     "outputs": [
-      {
-       "ename": "TypeError",
-       "evalue": "Labels list must be the same size as the values list.",
-       "output_type": "pyerr",
-       "traceback": [
-        "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
-        "\u001b[0;32m<ipython-input-16-c2e115f84112>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m         generator={'gnp': nx.gnp_random_graph,\n\u001b[1;32m      3\u001b[0m                    \u001b[0;34m'erdos_renyi'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mnx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0merdos_renyi_graph\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m                    'binomial': nx.binomial_graph})\n\u001b[0m",
-        "\u001b[0;32m/Users/bgranger/Documents/Computing/IPython/code/ipython/IPython/html/widgets/interact.py\u001b[0m in \u001b[0;36minteract\u001b[0;34m(f, **kwargs)\u001b[0m\n\u001b[1;32m    135\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    136\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0minteract\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 137\u001b[0;31m     \u001b[0mw\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0minteractive\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    138\u001b[0m     \u001b[0mdisplay\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mw\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-        "\u001b[0;32m/Users/bgranger/Documents/Computing/IPython/code/ipython/IPython/html/widgets/interact.py\u001b[0m in \u001b[0;36minteractive\u001b[0;34m(f, **kwargs)\u001b[0m\n\u001b[1;32m    107\u001b[0m             \u001b[0mwidget\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    108\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 109\u001b[0;31m             \u001b[0mwidget\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_widget_abbrev\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    110\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mwidget\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    111\u001b[0m                 \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Object cannot be transformed to a Widget\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-        "\u001b[0;32m/Users/bgranger/Documents/Computing/IPython/code/ipython/IPython/html/widgets/interact.py\u001b[0m in \u001b[0;36m_widget_abbrev\u001b[0;34m(o)\u001b[0m\n\u001b[1;32m     61\u001b[0m         \u001b[0mlabels\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0municode_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mk\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mo\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     62\u001b[0m         \u001b[0mvalues\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mo\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 63\u001b[0;31m         \u001b[0mw\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mDropdownWidget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalues\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabels\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlabels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     64\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mw\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     65\u001b[0m     \u001b[0;31m# Special case float and int == 0.0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-        "\u001b[0;32m/Users/bgranger/Documents/Computing/IPython/code/ipython/IPython/html/widgets/widget_selection.pyc\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, *pargs, **kwargs)\u001b[0m\n\u001b[1;32m     37\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalue_lock\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mLock\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     38\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mon_trait_change\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_string_value_set\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'_value'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 39\u001b[0;31m         \u001b[0mDOMWidget\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mpargs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     40\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     41\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_labels_changed\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mold\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnew\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-        "\u001b[0;32m/Users/bgranger/Documents/Computing/IPython/code/ipython/IPython/html/widgets/widget.pyc\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, **kwargs)\u001b[0m\n\u001b[1;32m    102\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    103\u001b[0m         \u001b[0;34m\"\"\"Public constructor\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 104\u001b[0;31m         \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mWidget\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    105\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    106\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mon_trait_change\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_handle_property_changed\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkeys\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-        "\u001b[0;32m/Users/bgranger/Documents/Computing/IPython/code/ipython/IPython/config/configurable.pyc\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, **kwargs)\u001b[0m\n\u001b[1;32m    100\u001b[0m         \u001b[0;31m# This should go second so individual keyword arguments override\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    101\u001b[0m         \u001b[0;31m# the values in config.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 102\u001b[0;31m         \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mConfigurable\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    103\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    104\u001b[0m     \u001b[0;31m#-------------------------------------------------------------------------\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-        "\u001b[0;32m/Users/bgranger/Documents/Computing/IPython/code/ipython/IPython/utils/traitlets.pyc\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, *args, **kw)\u001b[0m\n\u001b[1;32m    430\u001b[0m         \u001b[0;31m# notifications.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    431\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mkey\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m \u001b[0;32min\u001b[0m \u001b[0miteritems\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkw\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 432\u001b[0;31m             \u001b[0msetattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    433\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    434\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_notify_trait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mold_value\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnew_value\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-        "\u001b[0;32m/Users/bgranger/Documents/Computing/IPython/code/ipython/IPython/utils/traitlets.pyc\u001b[0m in \u001b[0;36m__set__\u001b[0;34m(self, obj, value)\u001b[0m\n\u001b[1;32m    318\u001b[0m         \u001b[0mobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_trait_values\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew_value\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    319\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mold_value\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0mnew_value\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 320\u001b[0;31m             \u001b[0mobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_notify_trait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mold_value\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnew_value\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    321\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    322\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_validate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-        "\u001b[0;32m/Users/bgranger/Documents/Computing/IPython/code/ipython/IPython/utils/traitlets.pyc\u001b[0m in \u001b[0;36m_notify_trait\u001b[0;34m(self, name, old_value, new_value)\u001b[0m\n\u001b[1;32m    467\u001b[0m                     \u001b[0mc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnew_value\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    468\u001b[0m                 \u001b[0;32melif\u001b[0m \u001b[0mnargs\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0moffset\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 469\u001b[0;31m                     \u001b[0mc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mold_value\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnew_value\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    470\u001b[0m                 \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    471\u001b[0m                     raise TraitError('a trait changed callback '\n",
-        "\u001b[0;32m/Users/bgranger/Documents/Computing/IPython/code/ipython/IPython/html/widgets/widget_selection.pyc\u001b[0m in \u001b[0;36m_labels_changed\u001b[0;34m(self, name, old, new)\u001b[0m\n\u001b[1;32m     45\u001b[0m         value for the value_names Dict.\"\"\"\n\u001b[1;32m     46\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 47\u001b[0;31m             \u001b[0;32mraise\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Labels list must be the same size as the values list.'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     48\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     49\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_values_changed\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mold\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnew\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-        "\u001b[0;31mTypeError\u001b[0m: Labels list must be the same size as the values list."
-       ]
-      }
-     ],
-     "prompt_number": 16
+     "outputs": [],
+     "trusted": true
     },
     {
      "cell_type": "heading",
@@ -426,7 +418,8 b''
      "language": "python",
      "metadata": {},
      "outputs": [],
-     "prompt_number": 18
+     "prompt_number": 18,
+     "trusted": false
     },
     {
      "cell_type": "code",
@@ -437,7 +430,8 b''
      "language": "python",
      "metadata": {},
      "outputs": [],
-     "prompt_number": 19
+     "prompt_number": 19,
+     "trusted": false
     },
     {
      "cell_type": "code",
@@ -513,7 +507,8 b''
        ]
       }
      ],
-     "prompt_number": 20
+     "prompt_number": 20,
+     "trusted": false
     },
     {
      "cell_type": "code",
@@ -534,7 +529,8 b''
      "language": "python",
      "metadata": {},
      "outputs": [],
-     "prompt_number": 21
+     "prompt_number": 21,
+     "trusted": false
     },
     {
      "cell_type": "code",
@@ -545,7 +541,8 b''
      "language": "python",
      "metadata": {},
      "outputs": [],
-     "prompt_number": 22
+     "prompt_number": 22,
+     "trusted": false
     },
     {
      "cell_type": "code",
@@ -612,7 +609,8 b''
        ]
       }
      ],
-     "prompt_number": 24
+     "prompt_number": 24,
+     "trusted": false
     },
     {
      "cell_type": "code",
@@ -636,7 +634,8 b''
        ]
       }
      ],
-     "prompt_number": 25
+     "prompt_number": 25,
+     "trusted": false
     },
     {
      "cell_type": "code",
@@ -704,7 +703,8 b''
        ]
       }
      ],
-     "prompt_number": 26
+     "prompt_number": 26,
+     "trusted": false
     },
     {
      "cell_type": "heading",
@@ -731,7 +731,8 b''
      "language": "python",
      "metadata": {},
      "outputs": [],
-     "prompt_number": 27
+     "prompt_number": 14,
+     "trusted": true
     },
     {
      "cell_type": "code",
@@ -742,14 +743,15 b''
       "    rate = 8000\n",
       "    times = np.linspace(0,max_time,rate*max_time)\n",
       "    signal = np.sin(2*np.pi*f1*times) + np.sin(2*np.pi*f2*times)\n",
-      "    print f1, f2, abs(f1-f2)\n",
+      "    print(f1, f2, abs(f1-f2))\n",
       "    display(Audio(data=signal, rate=rate))\n",
       "    return signal"
      ],
      "language": "python",
      "metadata": {},
      "outputs": [],
-     "prompt_number": 30
+     "prompt_number": 17,
+     "trusted": true
     },
     {
      "cell_type": "code",
@@ -765,14 +767,14 b''
        "output_type": "stream",
        "stream": "stdout",
        "text": [
-        "265.1 250.0 15.1\n"
+        "245.4 250.0 4.599999999999994\n"
        ]
       },
       {
        "html": [
         "\n",
         "                <audio controls=\"controls\" >\n",
-        "                    <source src=\"data:audio/wav;base64,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\" type=\"audio/wav\" />\n",
+        "                    <source src=\"data:audio/wav;base64,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\" type=\"audio/wav\" />\n",
         "                    Your browser does not support the audio element.\n",
         "                </audio>\n",
         "              "
@@ -780,11 +782,12 b''
        "metadata": {},
        "output_type": "display_data",
        "text": [
-        "<IPython.lib.display.Audio at 0x109475e90>"
+        "<IPython.lib.display.Audio at 0x7fdabbc01f90>"
        ]
       }
      ],
-     "prompt_number": 31
+     "prompt_number": 18,
+     "trusted": true
     },
     {
      "cell_type": "code",
@@ -794,7 +797,26 b''
      ],
      "language": "python",
      "metadata": {},
-     "outputs": []
+     "outputs": [
+      {
+       "metadata": {},
+       "output_type": "pyout",
+       "prompt_number": 19,
+       "text": [
+        "[<matplotlib.lines.Line2D at 0x7fdabbc3b390>]"
+       ]
+      },
+      {
+       "metadata": {},
+       "output_type": "display_data",
+       "png": "iVBORw0KGgoAAAANSUhEUgAAAYMAAAEACAYAAABRQBpkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\naNGiRYsWLVq0aNGiRYsWLVq0aFFn/H+LevJkpznBwwAAAABJRU5ErkJggg==\n",
+       "text": [
+        "<matplotlib.figure.Figure at 0x7fdabbc89ed0>"
+       ]
+      }
+     ],
+     "prompt_number": 19,
+     "trusted": true
     }
    ],
    "metadata": {}