use jslink, jsdlink for frontend link functions

IPython/html/widgets/__init__.py

@@ -1,38 +1,38 b''
 from .widget import Widget, DOMWidget, CallbackDispatcher, register
 
 from .widget_bool import Checkbox, ToggleButton
 from .widget_button import Button
 from .widget_box import Box, FlexBox, HBox, VBox
 from .widget_float import FloatText, BoundedFloatText, FloatSlider, FloatProgress, FloatRangeSlider
 from .widget_image import Image
 from .widget_int import IntText, BoundedIntText, IntSlider, IntProgress, IntRangeSlider
 from .widget_output import Output
 from .widget_selection import RadioButtons, ToggleButtons, Dropdown, Select
 from .widget_selectioncontainer import Tab, Accordion
 from .widget_string import HTML, Latex, Text, Textarea
 from .interaction import interact, interactive, fixed, interact_manual
-from .widget_link import Link, link, DirectionalLink, directional_link, dlink
+from .widget_link import jslink, jsdlink, Link, DirectionalLink
 
 # Deprecated classes
 from .widget_bool import CheckboxWidget, ToggleButtonWidget
 from .widget_button import ButtonWidget
 from .widget_box import ContainerWidget
 from .widget_float import FloatTextWidget, BoundedFloatTextWidget, FloatSliderWidget, FloatProgressWidget
 from .widget_image import ImageWidget
 from .widget_int import IntTextWidget, BoundedIntTextWidget, IntSliderWidget, IntProgressWidget
 from .widget_selection import RadioButtonsWidget, ToggleButtonsWidget, DropdownWidget, SelectWidget
 from .widget_selectioncontainer import TabWidget, AccordionWidget
 from .widget_string import HTMLWidget, LatexWidget, TextWidget, TextareaWidget
 
 # We use warn_explicit so we have very brief messages without file or line numbers.
 # The concern is that file or line numbers will confuse the interactive user.
 # To ignore this warning, do:
 #
 #     from warnings import filterwarnings
 #     filterwarnings('ignore', module='IPython.html.widgets')
 
 from warnings import warn_explicit
 __warningregistry__ = {}
 warn_explicit("IPython widgets are experimental and may change in the future.",
               FutureWarning, '', 0, module = 'IPython.html.widgets',
               registry = __warningregistry__, module_globals = globals)

IPython/html/widgets/tests/test_link.py

@@ -1,39 +1,39 b''
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import nose.tools as nt
 
-from .. import link, dlink, ToggleButton
+from .. import jslink, jsdlink, ToggleButton
 from .test_interaction import setup, teardown
 
-def test_link_args():
+def test_jslink_args():
     with nt.assert_raises(TypeError):
-        link()
+        jslink()
     w1 = ToggleButton()
     with nt.assert_raises(TypeError):
-        link((w1, 'value'))
+        jslink((w1, 'value'))
     
     w2 = ToggleButton()
-    link((w1, 'value'), (w2, 'value'))
+    jslink((w1, 'value'), (w2, 'value'))
 
     with nt.assert_raises(TypeError):
-        link((w1, 'value'), (w2, 'nosuchtrait'))
+        jslink((w1, 'value'), (w2, 'nosuchtrait'))
 
     with nt.assert_raises(TypeError):
-        link((w1, 'value'), (w2, 'traits'))
+        jslink((w1, 'value'), (w2, 'traits'))
 
-def test_dlink_args():
+def test_jsdlink_args():
     with nt.assert_raises(TypeError):
-        dlink()
+        jsdlink()
     w1 = ToggleButton()
     with nt.assert_raises(TypeError):
-        dlink((w1, 'value'))
+        jsdlink((w1, 'value'))
     
     w2 = ToggleButton()
-    dlink((w1, 'value'), (w2, 'value'))
+    jsdlink((w1, 'value'), (w2, 'value'))
 
     with nt.assert_raises(TypeError):
-        dlink((w1, 'value'), (w2, 'nosuchtrait'))
+        jsdlink((w1, 'value'), (w2, 'nosuchtrait'))
 
     with nt.assert_raises(TypeError):
-        dlink((w1, 'value'), (w2, 'traits'))
+        jsdlink((w1, 'value'), (w2, 'traits'))

IPython/html/widgets/widget_link.py

@@ -1,112 +1,111 b''
 """Link and DirectionalLink classes.
 
 Propagate changes between widgets on the javascript side
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from .widget import Widget
 from IPython.testing.skipdoctest import skip_doctest
 from IPython.utils.traitlets import Unicode, Tuple, List,Instance, TraitError
 
 class WidgetTraitTuple(Tuple):
     """Traitlet for validating a single (Widget, 'trait_name') pair"""
     
     def __init__(self, **kwargs):
         super(WidgetTraitTuple, self).__init__(Instance(Widget), Unicode, **kwargs)
     
     def validate_elements(self, obj, value):
         value = super(WidgetTraitTuple, self).validate_elements(obj, value)
         widget, trait_name = value
         trait = widget.traits().get(trait_name)
         trait_repr = "%s.%s" % (widget.__class__.__name__, trait_name)
         # Can't raise TraitError because the parent will swallow the message
         # and throw it away in a new, less informative TraitError
         if trait is None:
             raise TypeError("No such trait: %s" % trait_repr)
         elif not trait.get_metadata('sync'):
             raise TypeError("%s cannot be synced" % trait_repr)
         
         return value
 
 
 class Link(Widget):
     """Link Widget
     
     one trait:
     widgets, a list of (widget, 'trait_name') tuples which should be linked in the frontend.
     """
     _model_name = Unicode('LinkModel', sync=True)
     widgets = List(WidgetTraitTuple, sync=True)
 
     def __init__(self, widgets, **kwargs):
         if len(widgets) < 2:
             raise TypeError("Require at least two widgets to link")
         kwargs['widgets'] = widgets
         super(Link, self).__init__(**kwargs)
 
     # for compatibility with traitlet links
     def unlink(self):
         self.close()
 
 
 @skip_doctest
-def link(*args):
+def jslink(*args):
     """Link traits from different widgets together on the frontend so they remain in sync.
 
     Parameters
     ----------
     *args : two or more (Widget, 'trait_name') tuples that should be kept in sync.
 
     Examples
     --------
 
     >>> c = link((widget1, 'value'), (widget2, 'value'), (widget3, 'value'))
     """
     return Link(widgets=args)
 
 
 class DirectionalLink(Widget):
     """A directional link
     
     source: a (Widget, 'trait_name') tuple for the source trait
     targets: one or more (Widget, 'trait_name') tuples that should be updated
     when the source trait changes.
     """
     _model_name = Unicode('DirectionalLinkModel', sync=True)
     targets = List(WidgetTraitTuple, sync=True)
     source = WidgetTraitTuple(sync=True)
 
     # Does not quite behave like other widgets but reproduces
     # the behavior of IPython.utils.traitlets.directional_link
     def __init__(self, source, targets, **kwargs):
         if len(targets) < 1:
             raise TypeError("Require at least two widgets to link")
         
         kwargs['source'] = source
         kwargs['targets'] = targets
         super(DirectionalLink, self).__init__(**kwargs)
 
     # for compatibility with traitlet links
     def unlink(self):
         self.close()
 
 @skip_doctest
-def directional_link(source, *targets):
+def jsdlink(source, *targets):
     """Link the trait of a source widget with traits of target widgets in the frontend.
 
     Parameters
     ----------
     source : a (Widget, 'trait_name') tuple for the source trait
     *targets : one or more (Widget, 'trait_name') tuples that should be updated
     when the source trait changes.
 
     Examples
     --------
 
     >>> c = dlink((src_widget, 'value'), (tgt_widget1, 'value'), (tgt_widget2, 'value'))
     """
     return DirectionalLink(source=source, targets=targets)
 
-dlink = directional_link