move DeprecatedClass to widgets, where it's used

avoids need to add warn to genutils

IPython/html/widgets/deprecated.py

@@ -0,0 +1,22 b''
+"""Decorator for warning about deprecated widget classes"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+from warnings import warn
+
+
+def DeprecatedClass(base, class_name):
+    """Warn about a deprecated class on instantiation"""
+    # Hook the init method of the base class.
+    def init_hook(self, *pargs, **kwargs):
+        base.__init__(self, *pargs, **kwargs)
+
+        # Warn once per class.
+        if base not in DeprecatedClass._warned_classes:
+            DeprecatedClass._warned_classes.append(base)
+            warn('"{}" is deprecated, please use "{}" instead.'.format(
+                class_name, base.__name__))
+    return type(class_name, (base,), {'__init__': init_hook})
+
+DeprecatedClass._warned_classes = []

IPython/html/widgets/widget_bool.py

@@ -1,89 +1,80 b''
 """Bool class.  
 
 Represents a boolean using a widget.
 """
-#-----------------------------------------------------------------------------
-# Copyright (c) 2013, the IPython Development Team.
-#
+
+# Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
-#
-# The full license is in the file COPYING.txt, distributed with this software.
-#-----------------------------------------------------------------------------
 
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
 from .widget import DOMWidget, register
 from IPython.utils.traitlets import Unicode, Bool, CaselessStrEnum
-from IPython.utils.warn import DeprecatedClass
+from .deprecated import DeprecatedClass
+
 
-#-----------------------------------------------------------------------------
-# Classes
-#-----------------------------------------------------------------------------
 class _Bool(DOMWidget):
     """A base class for creating widgets that represent booleans."""
     value = Bool(False, help="Bool value", sync=True)
     description = Unicode('', help="Description of the boolean (label).", sync=True)
     disabled = Bool(False, help="Enable or disable user changes.", sync=True)
 
     def __init__(self, value=None, **kwargs):
         if value is not None:
             kwargs['value'] = value
         super(_Bool, self).__init__(**kwargs)
 
 @register('IPython.Checkbox')
 class Checkbox(_Bool):
     """Displays a boolean `value` in the form of a checkbox.
 
        Parameters
        ----------
        value : {True,False}
            value of the checkbox: True-checked, False-unchecked
        description : str
 	   description displayed next to the checkbox
 """
     _view_name = Unicode('CheckboxView', sync=True)
 
 
 @register('IPython.ToggleButton')
 class ToggleButton(_Bool):
     """Displays a boolean `value` in the form of a toggle button.
 
        Parameters
        ----------
        value : {True,False}
            value of the toggle button: True-pressed, False-unpressed
        description : str
 	   description displayed next to the button
        tooltip: str
            tooltip caption of the toggle button
        icon: str
            font-awesome icon name
 """
     _view_name = Unicode('ToggleButtonView', sync=True)
     tooltip = Unicode(help="Tooltip caption of the toggle button.", sync=True)
     icon = Unicode('', help= "Font-awesome icon.", sync=True)
 
     button_style = CaselessStrEnum(
         values=['primary', 'success', 'info', 'warning', 'danger', ''],
         default_value='', allow_none=True, sync=True, help="""Use a
         predefined styling for the button.""")
 
 
 @register('IPython.Valid')
 class Valid(_Bool):
 
     """Displays a boolean `value` in the form of a green check (True / valid)
     or a red cross (False / invalid).
 
     Parameters
     ----------
     value: {True,False}
         value of the Valid widget
 """
     readout = Unicode(help="Message displayed when the value is False", sync=True)
     _view_name = Unicode('ValidView', sync=True)
 
 # Remove in IPython 4.0
 CheckboxWidget = DeprecatedClass(Checkbox, 'CheckboxWidget')
 ToggleButtonWidget = DeprecatedClass(ToggleButton, 'ToggleButtonWidget')

IPython/html/widgets/widget_box.py

@@ -1,107 +1,107 b''
 """Box class.  
 
 Represents a container that can be used to group other widgets.
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from .widget import DOMWidget, Widget, register
 from IPython.utils.traitlets import Unicode, Tuple, TraitError, Int, CaselessStrEnum
-from IPython.utils.warn import DeprecatedClass
+from .deprecated import DeprecatedClass
 
 def _widget_to_json(x):
     if isinstance(x, dict):
         return {k: _widget_to_json(v) for k, v in x.items()}
     elif isinstance(x, (list, tuple)):
         return [_widget_to_json(v) for v in x]
     elif isinstance(x, Widget):
         return "IPY_MODEL_" + x.model_id
     else:
         return x
 
 def _json_to_widget(x):
     if isinstance(x, dict):
         return {k: _json_to_widget(v) for k, v in x.items()}
     elif isinstance(x, (list, tuple)):
         return [_json_to_widget(v) for v in x]
     elif isinstance(x, string_types) and x.startswith('IPY_MODEL_') and x[10:] in Widget.widgets:
         return Widget.widgets[x[10:]]
     else:
         return x
 
 widget_serialization = {
     'from_json': _json_to_widget,
     'to_json': _widget_to_json
 }
 
 
 @register('IPython.Box')
 class Box(DOMWidget):
     """Displays multiple widgets in a group."""
     _model_name = Unicode('BoxModel', sync=True)
     _view_name = Unicode('BoxView', sync=True)
 
     # Child widgets in the container.
     # Using a tuple here to force reassignment to update the list.
     # When a proper notifying-list trait exists, that is what should be used here.
     children = Tuple(sync=True, **widget_serialization)
     
     _overflow_values = ['visible', 'hidden', 'scroll', 'auto', 'initial', 'inherit', '']
     overflow_x = CaselessStrEnum(
         values=_overflow_values, 
         default_value='', sync=True, help="""Specifies what
         happens to content that is too large for the rendered region.""")
     overflow_y = CaselessStrEnum(
         values=_overflow_values, 
         default_value='', sync=True, help="""Specifies what
         happens to content that is too large for the rendered region.""")
 
     box_style = CaselessStrEnum(
         values=['success', 'info', 'warning', 'danger', ''], 
         default_value='', allow_none=True, sync=True, help="""Use a
         predefined styling for the box.""")
 
     def __init__(self, children = (), **kwargs):
         kwargs['children'] = children
         super(Box, self).__init__(**kwargs)
         self.on_displayed(Box._fire_children_displayed)
 
     def _fire_children_displayed(self):
         for child in self.children:
             child._handle_displayed()
 
 
 @register('IPython.FlexBox')
 class FlexBox(Box):
     """Displays multiple widgets using the flexible box model."""
     _view_name = Unicode('FlexBoxView', sync=True)
     orientation = CaselessStrEnum(values=['vertical', 'horizontal'], default_value='vertical', sync=True)
     flex = Int(0, sync=True, help="""Specify the flexible-ness of the model.""")
     def _flex_changed(self, name, old, new):
         new = min(max(0, new), 2)
         if self.flex != new:
             self.flex = new
 
     _locations = ['start', 'center', 'end', 'baseline', 'stretch']
     pack = CaselessStrEnum(
         values=_locations, 
         default_value='start', sync=True)
     align = CaselessStrEnum(
         values=_locations, 
         default_value='start', sync=True)
 
 
 def VBox(*pargs, **kwargs):
     """Displays multiple widgets vertically using the flexible box model."""
     kwargs['orientation'] = 'vertical'
     return FlexBox(*pargs, **kwargs)
 
 def HBox(*pargs, **kwargs):
     """Displays multiple widgets horizontally using the flexible box model."""
     kwargs['orientation'] = 'horizontal'
     return FlexBox(*pargs, **kwargs)
 
 
 # Remove in IPython 4.0
 ContainerWidget = DeprecatedClass(Box, 'ContainerWidget')

IPython/html/widgets/widget_button.py

@@ -1,82 +1,73 b''
 """Button class.  
 
 Represents a button in the frontend using a widget.  Allows user to listen for
 click events on the button and trigger backend code when the clicks are fired.
 """
-#-----------------------------------------------------------------------------
-# Copyright (c) 2013, the IPython Development Team.
-#
+
+# Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
-#
-# The full license is in the file COPYING.txt, distributed with this software.
-#-----------------------------------------------------------------------------
 
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
 from .widget import DOMWidget, CallbackDispatcher, register
 from IPython.utils.traitlets import Unicode, Bool, CaselessStrEnum
-from IPython.utils.warn import DeprecatedClass
+from .deprecated import DeprecatedClass
+
 
-#-----------------------------------------------------------------------------
-# Classes
-#-----------------------------------------------------------------------------
 @register('IPython.Button')
 class Button(DOMWidget):
     """Button widget.
        This widget has an `on_click` method that allows you to listen for the 
        user clicking on the button.  The click event itself is stateless.
 
        Parameters
        ----------
        description : str
            description displayed next to the button
        tooltip: str
            tooltip caption of the toggle button
        icon: str
            font-awesome icon name
     """
     _view_name = Unicode('ButtonView', sync=True)
 
     # Keys
     description = Unicode('', help="Button label.", sync=True)
     tooltip = Unicode(help="Tooltip caption of the button.", sync=True)
     disabled = Bool(False, help="Enable or disable user changes.", sync=True)
     icon = Unicode('', help= "Font-awesome icon.", sync=True)
 
     button_style = CaselessStrEnum(
         values=['primary', 'success', 'info', 'warning', 'danger', ''], 
         default_value='', allow_none=True, sync=True, help="""Use a
         predefined styling for the button.""")
     
     def __init__(self, **kwargs):
         """Constructor"""
         super(Button, self).__init__(**kwargs)
         self._click_handlers = CallbackDispatcher()
         self.on_msg(self._handle_button_msg)
 
     def on_click(self, callback, remove=False):
         """Register a callback to execute when the button is clicked.
 
         The callback will be called with one argument,
         the clicked button widget instance.
 
         Parameters
         ----------
         remove : bool (optional)
             Set to true to remove the callback from the list of callbacks."""
         self._click_handlers.register_callback(callback, remove=remove)
 
     def _handle_button_msg(self, _, content, buffers):
         """Handle a msg from the front-end.
 
         Parameters
         ----------
         content: dict
             Content of the msg."""
         if content.get('event', '') == 'click':
             self._click_handlers(self)
 
 
 # Remove in IPython 4.0
 ButtonWidget = DeprecatedClass(Button, 'ButtonWidget')

IPython/html/widgets/widget_float.py

@@ -1,296 +1,287 b''
 """Float class.
 
 Represents an unbounded float using a widget.
 """
-#-----------------------------------------------------------------------------
-# Copyright (c) 2013, the IPython Development Team.
-#
+
+# Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
-#
-# The full license is in the file COPYING.txt, distributed with this software.
-#-----------------------------------------------------------------------------
 
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
 from .widget import DOMWidget, register
 from .trait_types import Color
 from IPython.utils.traitlets import (Unicode, CFloat, Bool, CaselessStrEnum,
                                      Tuple, TraitError)
-from IPython.utils.warn import DeprecatedClass
+from .deprecated import DeprecatedClass
+
 
-#-----------------------------------------------------------------------------
-# Classes
-#-----------------------------------------------------------------------------
 class _Float(DOMWidget):
     value = CFloat(0.0, help="Float value", sync=True)
     disabled = Bool(False, help="Enable or disable user changes", sync=True)
     description = Unicode(help="Description of the value this widget represents", sync=True)
 
     def __init__(self, value=None, **kwargs):
         if value is not None:
             kwargs['value'] = value
         super(_Float, self).__init__(**kwargs)
 
 
 class _BoundedFloat(_Float):
     max = CFloat(100.0, help="Max value", sync=True)
     min = CFloat(0.0, help="Min value", sync=True)
     step = CFloat(0.1, help="Minimum step to increment the value (ignored by some views)", sync=True)
 
     def __init__(self, *pargs, **kwargs):
         """Constructor"""
         super(_BoundedFloat, self).__init__(*pargs, **kwargs)
 
     def _value_validate(self, value, trait):
         """Cap and floor value"""
         if self.min > value or self.max < value:
             value = min(max(value, self.min), self.max)
         return value
 
     def _min_validate(self, min, trait):
         """Enforce min <= value <= max"""
         if min > self.max:
             raise TraitError("Setting min > max")
         if min > self.value:
             self.value = min
         return min
 
     def _max_validate(self, max, trait):
         """Enforce min <= value <= max"""
         if max < self.min:
             raise TraitError("setting max < min")
         if max < self.value:
             self.value = max
         return max
 
 
 @register('IPython.FloatText')
 class FloatText(_Float):
     """ Displays a float value within a textbox. For a textbox in
 	which the value must be within a specific range, use BoundedFloatText.
 
 	Parameters
 	----------
 	value : float
 	    value displayed
 	description : str
 	    description displayed next to the text box
 	color : str Unicode color code (eg. '#C13535'), optional
 	    color of the value displayed
     """
     _view_name = Unicode('FloatTextView', sync=True)
 
 
 @register('IPython.BoundedFloatText')
 class BoundedFloatText(_BoundedFloat):
     """ Displays a float value within a textbox. Value must be within the range specified.
 	For a textbox in which the value doesn't need to be within a specific range, use FloatText.
 
 	Parameters
 	----------
 	value : float
 	    value displayed
 	min : float
 	    minimal value of the range of possible values displayed
 	max : float
 	    maximal value of the range of possible values displayed
 	description : str
 	    description displayed next to the textbox  
 	color : str Unicode color code (eg. '#C13535'), optional
 	    color of the value displayed   
     """
     _view_name = Unicode('FloatTextView', sync=True)
 
 
 @register('IPython.FloatSlider')
 class FloatSlider(_BoundedFloat):
     """ Slider/trackbar of floating values with the specified range.
 
 	Parameters
 	----------
 	value : float
 	    position of the slider
 	min : float
 	    minimal position of the slider
 	max : float
 	    maximal position of the slider
 	step : float
 	    step of the trackbar
 	description : str
 	    name of the slider
 	orientation : {'vertical', 'horizontal}, optional
             default is horizontal
 	readout : {True, False}, optional
 	    default is True, display the current value of the slider next to it		
 	slider_color : str Unicode color code (eg. '#C13535'), optional 
 	    color of the slider 
 	color : str Unicode color code (eg. '#C13535'), optional
 	    color of the value displayed (if readout == True)
     """
     _view_name = Unicode('FloatSliderView', sync=True)
     orientation = CaselessStrEnum(values=['horizontal', 'vertical'], 
         default_value='horizontal', help="Vertical or horizontal.", sync=True)
     _range = Bool(False, help="Display a range selector", sync=True)
     readout = Bool(True, help="Display the current value of the slider next to it.", sync=True)
     slider_color = Color(None, allow_none=True, sync=True)
 
 
 @register('IPython.FloatProgress')
 class FloatProgress(_BoundedFloat):
     """ Displays a progress bar.
 
     Parameters
     -----------
     value : float
 	position within the range of the progress bar
     min : float
 	minimal position of the slider
     max : float
 	maximal position of the slider
     step : float
 	step of the progress bar
     description : str
 	name of the progress bar
     bar_style: {'success', 'info', 'warning', 'danger', ''}, optional
 	color of the progress bar, default is '' (blue)
 	colors are: 'success'-green, 'info'-light blue, 'warning'-orange, 'danger'-red
 """
     _view_name = Unicode('ProgressView', sync=True)
 
     bar_style = CaselessStrEnum(
         values=['success', 'info', 'warning', 'danger', ''], 
         default_value='', allow_none=True, sync=True, help="""Use a
         predefined styling for the progess bar.""")
 
 class _FloatRange(_Float):
     value = Tuple(CFloat, CFloat, default_value=(0.0, 1.0), help="Tuple of (lower, upper) bounds", sync=True)
     lower = CFloat(0.0, help="Lower bound", sync=False)
     upper = CFloat(1.0, help="Upper bound", sync=False)
     
     def __init__(self, *pargs, **kwargs):
         value_given = 'value' in kwargs
         lower_given = 'lower' in kwargs
         upper_given = 'upper' in kwargs
         if value_given and (lower_given or upper_given):
             raise ValueError("Cannot specify both 'value' and 'lower'/'upper' for range widget")
         if lower_given != upper_given:
             raise ValueError("Must specify both 'lower' and 'upper' for range widget")
         
         DOMWidget.__init__(self, *pargs, **kwargs)
         
         # ensure the traits match, preferring whichever (if any) was given in kwargs
         if value_given:
             self.lower, self.upper = self.value
         else:
             self.value = (self.lower, self.upper)
         
         self.on_trait_change(self._validate, ['value', 'upper', 'lower'])
     
     def _validate(self, name, old, new):
         if name == 'value':
             self.lower, self.upper = min(new), max(new)
         elif name == 'lower':
             self.value = (new, self.value[1])
         elif name == 'upper':
             self.value = (self.value[0], new)
 
 class _BoundedFloatRange(_FloatRange):
     step = CFloat(1.0, help="Minimum step that the value can take (ignored by some views)", sync=True)
     max = CFloat(100.0, help="Max value", sync=True)
     min = CFloat(0.0, help="Min value", sync=True)
     
     def __init__(self, *pargs, **kwargs):
         any_value_given = 'value' in kwargs or 'upper' in kwargs or 'lower' in kwargs
         _FloatRange.__init__(self, *pargs, **kwargs)
         
         # ensure a minimal amount of sanity
         if self.min > self.max:
             raise ValueError("min must be <= max")
         
         if any_value_given:
             # if a value was given, clamp it within (min, max)
             self._validate("value", None, self.value)
         else:
             # otherwise, set it to 25-75% to avoid the handles overlapping
             self.value = (0.75*self.min + 0.25*self.max,
                           0.25*self.min + 0.75*self.max)
         # callback already set for 'value', 'lower', 'upper'
         self.on_trait_change(self._validate, ['min', 'max'])
 
 
     def _validate(self, name, old, new):
         if name == "min":
             if new > self.max:
                 raise ValueError("setting min > max")
             self.min = new
         elif name == "max":
             if new < self.min:
                 raise ValueError("setting max < min")
             self.max = new
         
         low, high = self.value
         if name == "value":
             low, high = min(new), max(new)
         elif name == "upper":
             if new < self.lower:
                 raise ValueError("setting upper < lower")
             high = new
         elif name == "lower":
             if new > self.upper:
                 raise ValueError("setting lower > upper")
             low = new
         
         low = max(self.min, min(low, self.max))
         high = min(self.max, max(high, self.min))
         
         # determine the order in which we should update the
         # lower, upper traits to avoid a temporary inverted overlap
         lower_first = high < self.lower
         
         self.value = (low, high)
         if lower_first:
             self.lower = low
             self.upper = high
         else:
             self.upper = high
             self.lower = low
 
 
 @register('IPython.FloatRangeSlider')
 class FloatRangeSlider(_BoundedFloatRange):
     """ Slider/trackbar for displaying a floating value range (within the specified range of values).
 
 	Parameters
 	----------
 	value : float tuple
 	    range of the slider displayed
 	min : float
 	    minimal position of the slider
 	max : float
 	    maximal position of the slider
 	step : float
 	    step of the trackbar
 	description : str
 	    name of the slider
 	orientation : {'vertical', 'horizontal}, optional
             default is horizontal
 	readout : {True, False}, optional
 	    default is True, display the current value of the slider next to it		
 	slider_color : str Unicode color code (eg. '#C13535'), optional 
 	    color of the slider 
 	color : str Unicode color code (eg. '#C13535'), optional
 	    color of the value displayed (if readout == True)
     """
     _view_name = Unicode('FloatSliderView', sync=True)
     orientation = CaselessStrEnum(values=['horizontal', 'vertical'], 
         default_value='horizontal', help="Vertical or horizontal.", sync=True)
     _range = Bool(True, help="Display a range selector", sync=True)
     readout = Bool(True, help="Display the current value of the slider next to it.", sync=True)
     slider_color = Color(None, allow_none=True, sync=True)
 
 # Remove in IPython 4.0
 FloatTextWidget = DeprecatedClass(FloatText, 'FloatTextWidget')
 BoundedFloatTextWidget = DeprecatedClass(BoundedFloatText, 'BoundedFloatTextWidget')
 FloatSliderWidget = DeprecatedClass(FloatSlider, 'FloatSliderWidget')
 FloatProgressWidget = DeprecatedClass(FloatProgress, 'FloatProgressWidget')

IPython/html/widgets/widget_image.py

@@ -1,47 +1,37 b''
 """Image class.  
 
 Represents an image in the frontend using a widget.
 """
-#-----------------------------------------------------------------------------
-# Copyright (c) 2013, the IPython Development Team.
-#
+
+# Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
-#
-# The full license is in the file COPYING.txt, distributed with this software.
-#-----------------------------------------------------------------------------
 
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
 import base64
 
 from .widget import DOMWidget, register
 from IPython.utils.traitlets import Unicode, CUnicode, Bytes
-from IPython.utils.warn import DeprecatedClass
+from .deprecated import DeprecatedClass
 
-#-----------------------------------------------------------------------------
-# Classes
-#-----------------------------------------------------------------------------
 @register('IPython.Image')
 class Image(DOMWidget):
     """Displays an image as a widget.
 
     The `value` of this widget accepts a byte string.  The byte string is the raw
     image data that you want the browser to display.  You can explicitly define
     the format of the byte string using the `format` trait (which defaults to
     "png")."""
     _view_name = Unicode('ImageView', sync=True)
     
     # Define the custom state properties to sync with the front-end
     format = Unicode('png', sync=True)
     width = CUnicode(sync=True)
     height = CUnicode(sync=True)
     _b64value = Unicode(sync=True)
     
     value = Bytes()
     def _value_changed(self, name, old, new):
         self._b64value = base64.b64encode(new)
 
 
 # Remove in IPython 4.0
 ImageWidget = DeprecatedClass(Image, 'ImageWidget')

IPython/html/widgets/widget_int.py

@@ -1,207 +1,198 b''
 """Int class.
 
 Represents an unbounded int using a widget.
 """
-#-----------------------------------------------------------------------------
-# Copyright (c) 2013, the IPython Development Team.
-#
+
+# Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
-#
-# The full license is in the file COPYING.txt, distributed with this software.
-#-----------------------------------------------------------------------------
 
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
 from .widget import DOMWidget, register
 from .trait_types import Color
 from IPython.utils.traitlets import (Unicode, CInt, Bool, CaselessStrEnum,
                                      Tuple, TraitError)
-from IPython.utils.warn import DeprecatedClass
+from .deprecated import DeprecatedClass
+
 
-#-----------------------------------------------------------------------------
-# Classes
-#-----------------------------------------------------------------------------
 class _Int(DOMWidget):
     """Base class used to create widgets that represent an int."""
     value = CInt(0, help="Int value", sync=True)
     disabled = Bool(False, help="Enable or disable user changes", sync=True)
     description = Unicode(help="Description of the value this widget represents", sync=True)
 
     def __init__(self, value=None, **kwargs):
         if value is not None:
             kwargs['value'] = value
         super(_Int, self).__init__(**kwargs)
 
 
 class _BoundedInt(_Int):
     """Base class used to create widgets that represent a int that is bounded
     by a minium and maximum."""
     step = CInt(1, help="Minimum step to increment the value (ignored by some views)", sync=True)
     max = CInt(100, help="Max value", sync=True)
     min = CInt(0, help="Min value", sync=True)
 
     def __init__(self, *pargs, **kwargs):
         """Constructor"""
         super(_BoundedInt, self).__init__(*pargs, **kwargs)
 
     def _value_validate(self, value, trait):
         """Cap and floor value"""
         if self.min > value or self.max < value:
             value = min(max(value, self.min), self.max)
         return value
 
     def _min_validate(self, min, trait):
         """Enforce min <= value <= max"""
         if min > self.max:
             raise TraitError("Setting min > max")
         if min > self.value:
             self.value = min
         return min
 
     def _max_validate(self, max, trait):
         """Enforce min <= value <= max"""
         if max < self.min:
             raise TraitError("setting max < min")
         if max < self.value:
             self.value = max
         return max
 
 @register('IPython.IntText')
 class IntText(_Int):
     """Textbox widget that represents a int."""
     _view_name = Unicode('IntTextView', sync=True)
 
 
 @register('IPython.BoundedIntText')
 class BoundedIntText(_BoundedInt):
     """Textbox widget that represents a int bounded by a minimum and maximum value."""
     _view_name = Unicode('IntTextView', sync=True)
 
 
 @register('IPython.IntSlider')
 class IntSlider(_BoundedInt):
     """Slider widget that represents a int bounded by a minimum and maximum value."""
     _view_name = Unicode('IntSliderView', sync=True)
     orientation = CaselessStrEnum(values=['horizontal', 'vertical'], 
         default_value='horizontal', help="Vertical or horizontal.", sync=True)
     _range = Bool(False, help="Display a range selector", sync=True)
     readout = Bool(True, help="Display the current value of the slider next to it.", sync=True)
     slider_color = Color(None, allow_none=True, sync=True)
 
 
 @register('IPython.IntProgress')
 class IntProgress(_BoundedInt):
     """Progress bar that represents a int bounded by a minimum and maximum value."""
     _view_name = Unicode('ProgressView', sync=True)
 
     bar_style = CaselessStrEnum(
         values=['success', 'info', 'warning', 'danger', ''], 
         default_value='', allow_none=True, sync=True, help="""Use a
         predefined styling for the progess bar.""")
 
 class _IntRange(_Int):
     value = Tuple(CInt, CInt, default_value=(0, 1), help="Tuple of (lower, upper) bounds", sync=True)
     lower = CInt(0, help="Lower bound", sync=False)
     upper = CInt(1, help="Upper bound", sync=False)
     
     def __init__(self, *pargs, **kwargs):
         value_given = 'value' in kwargs
         lower_given = 'lower' in kwargs
         upper_given = 'upper' in kwargs
         if value_given and (lower_given or upper_given):
             raise ValueError("Cannot specify both 'value' and 'lower'/'upper' for range widget")
         if lower_given != upper_given:
             raise ValueError("Must specify both 'lower' and 'upper' for range widget")
         
         super(_IntRange, self).__init__(*pargs, **kwargs)
         
         # ensure the traits match, preferring whichever (if any) was given in kwargs
         if value_given:
             self.lower, self.upper = self.value
         else:
             self.value = (self.lower, self.upper)
 
         self.on_trait_change(self._validate, ['value', 'upper', 'lower'])
     
     def _validate(self, name, old, new):
         if name == 'value':
             self.lower, self.upper = min(new), max(new)
         elif name == 'lower':
             self.value = (new, self.value[1])
         elif name == 'upper':
             self.value = (self.value[0], new)
 
 class _BoundedIntRange(_IntRange):
     step = CInt(1, help="Minimum step that the value can take (ignored by some views)", sync=True)
     max = CInt(100, help="Max value", sync=True)
     min = CInt(0, help="Min value", sync=True)
 
     def __init__(self, *pargs, **kwargs):
         any_value_given = 'value' in kwargs or 'upper' in kwargs or 'lower' in kwargs
         _IntRange.__init__(self, *pargs, **kwargs)
         
         # ensure a minimal amount of sanity
         if self.min > self.max:
             raise ValueError("min must be <= max")
         
         if any_value_given:
             # if a value was given, clamp it within (min, max)
             self._validate("value", None, self.value)
         else:
             # otherwise, set it to 25-75% to avoid the handles overlapping
             self.value = (0.75*self.min + 0.25*self.max,
                           0.25*self.min + 0.75*self.max)
         # callback already set for 'value', 'lower', 'upper'
         self.on_trait_change(self._validate, ['min', 'max'])
 
     def _validate(self, name, old, new):
         if name == "min":
             if new > self.max:
                 raise ValueError("setting min > max")
         elif name == "max":
             if new < self.min:
                 raise ValueError("setting max < min")
         
         low, high = self.value
         if name == "value":
             low, high = min(new), max(new)
         elif name == "upper":
             if new < self.lower:
                 raise ValueError("setting upper < lower")
             high = new
         elif name == "lower":
             if new > self.upper:
                 raise ValueError("setting lower > upper")
             low = new
         
         low = max(self.min, min(low, self.max))
         high = min(self.max, max(high, self.min))
         
         # determine the order in which we should update the
         # lower, upper traits to avoid a temporary inverted overlap
         lower_first = high < self.lower
         
         self.value = (low, high)
         if lower_first:
             self.lower = low
             self.upper = high
         else:
             self.upper = high
             self.lower = low
 
 @register('IPython.IntRangeSlider')
 class IntRangeSlider(_BoundedIntRange):
     """Slider widget that represents a pair of ints between a minimum and maximum value."""
     _view_name = Unicode('IntSliderView', sync=True)
     orientation = CaselessStrEnum(values=['horizontal', 'vertical'], 
         default_value='horizontal', help="Vertical or horizontal.", sync=True)
     _range = Bool(True, help="Display a range selector", sync=True)
     readout = Bool(True, help="Display the current value of the slider next to it.", sync=True)
     slider_color = Color(None, allow_none=True, sync=True)
 
 # Remove in IPython 4.0
 IntTextWidget = DeprecatedClass(IntText, 'IntTextWidget')
 BoundedIntTextWidget = DeprecatedClass(BoundedIntText, 'BoundedIntTextWidget')
 IntSliderWidget = DeprecatedClass(IntSlider, 'IntSliderWidget')
 IntProgressWidget = DeprecatedClass(IntProgress, 'IntProgressWidget')

IPython/html/widgets/widget_selection.py

@@ -1,248 +1,238 b''
 """Selection classes.
 
 Represents an enumeration using a widget.
 """
-#-----------------------------------------------------------------------------
-# Copyright (c) 2013, the IPython Development Team.
-#
-# Distributed under the terms of the Modified BSD License.
-#
-# The full license is in the file COPYING.txt, distributed with this software.
-#-----------------------------------------------------------------------------
 
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
 from collections import OrderedDict
 from threading import Lock
 
 from .widget import DOMWidget, register
 from IPython.utils.traitlets import (
     Unicode, Bool, Any, Dict, TraitError, CaselessStrEnum, Tuple, List
 )
 from IPython.utils.py3compat import unicode_type
-from IPython.utils.warn import DeprecatedClass
+from .deprecated import DeprecatedClass
+
 
-#-----------------------------------------------------------------------------
-# SelectionWidget
-#-----------------------------------------------------------------------------
 class _Selection(DOMWidget):
     """Base class for Selection widgets
     
     ``options`` can be specified as a list or dict. If given as a list,
     it will be transformed to a dict of the form ``{str(value):value}``.
 
     When programmatically setting the value, a reverse lookup is performed
     among the options to set the value of ``selected_label`` accordingly. The
     reverse lookup uses the equality operator by default, but an other
     predicate may be provided via the ``equals`` argument. For example, when
     dealing with numpy arrays, one may set equals=np.array_equal.
     """
     
     value = Any(help="Selected value")
     selected_label = Unicode(help="The label of the selected value", sync=True)
     options = Any(help="""List of (key, value) tuples or dict of values that the
         user can select.
     
     The keys of this list are the strings that will be displayed in the UI,
     representing the actual Python choices.
     
     The keys of this list are also available as _options_labels.
     """)
     
     _options_dict = Dict()
     _options_labels = Tuple(sync=True)
     _options_values = Tuple()
 
     disabled = Bool(False, help="Enable or disable user changes", sync=True)
     description = Unicode(help="Description of the value this widget represents", sync=True)
         
     def __init__(self, *args, **kwargs):
         self.value_lock = Lock()
         self.options_lock = Lock()
         self.equals = kwargs.pop('equals', lambda x, y: x == y)
         self.on_trait_change(self._options_readonly_changed, ['_options_dict', '_options_labels', '_options_values', '_options'])
         if 'options' in kwargs:
             self.options = kwargs.pop('options')
         DOMWidget.__init__(self, *args, **kwargs)
         self._value_in_options()
     
     def _make_options(self, x):
         # If x is a dict, convert it to list format.
         if isinstance(x, (OrderedDict, dict)):
             return [(k, v) for k, v in x.items()]
         
         # Make sure x is a list or tuple.
         if not isinstance(x, (list, tuple)):
             raise ValueError('x')
         
         # If x is an ordinary list, use the option values as names.
         for y in x:
             if not isinstance(y, (list, tuple)) or len(y) < 2:
                 return [(i, i) for i in x]
         
         # Value is already in the correct format.
         return x
 
     def _options_changed(self, name, old, new):
         """Handles when the options tuple has been changed.
 
         Setting options implies setting option labels from the keys of the dict.
         """
         if self.options_lock.acquire(False):
             try:
                 self.options = new
 
                 options = self._make_options(new)
                 self._options_dict = {i[0]: i[1] for i in options}
                 self._options_labels = [i[0] for i in options]
                 self._options_values = [i[1] for i in options]
                 self._value_in_options()
             finally:
                 self.options_lock.release()
         
     def _value_in_options(self):
         # ensure that the chosen value is one of the choices
     
         if self._options_values:
             if self.value not in self._options_values:
                 self.value = next(iter(self._options_values))
 
     def _options_readonly_changed(self, name, old, new):
         if not self.options_lock.locked():
             raise TraitError("`.%s` is a read-only trait. Use the `.options` tuple instead." % name)
 
     def _value_changed(self, name, old, new):
         """Called when value has been changed"""
         if self.value_lock.acquire(False):
             try:
                 # Reverse dictionary lookup for the value name
                 for k, v in self._options_dict.items():
                     if self.equals(new, v):
                         # set the selected value name
                         self.selected_label = k
                         return
                 # undo the change, and raise KeyError
                 self.value = old
                 raise KeyError(new)
             finally:
                 self.value_lock.release()
 
     def _selected_label_changed(self, name, old, new):
         """Called when the value name has been changed (typically by the frontend)."""
         if self.value_lock.acquire(False):
             try:
                 self.value = self._options_dict[new]
             finally:
                 self.value_lock.release()
 
 
 class _MultipleSelection(_Selection):
     """Base class for MultipleSelection widgets.
 
     As with ``_Selection``, ``options`` can be specified as a list or dict. If
     given as a list, it will be transformed to a dict of the form
     ``{str(value): value}``.
 
     Despite their names, ``value`` (and ``selected_label``) will be tuples, even
     if only a single option is selected.
     """
 
     value = Tuple(help="Selected values")
     selected_labels = Tuple(help="The labels of the selected options",
                             sync=True)
 
     @property
     def selected_label(self):
         raise AttributeError(
             "Does not support selected_label, use selected_labels")
 
     def _value_in_options(self):
         # ensure that the chosen value is one of the choices
         if self.options:
             old_value = self.value or []
             new_value = []
             for value in old_value:
                 if value in self._options_dict.values():
                     new_value.append(value)
             if new_value:
                 self.value = new_value
             else:
                 self.value = [next(iter(self._options_dict.values()))]
 
     def _value_changed(self, name, old, new):
         """Called when value has been changed"""
         if self.value_lock.acquire(False):
             try:
                 self.selected_labels = [
                     self._options_labels[self._options_values.index(v)]
                     for v in new
                 ]
             except:
                 self.value = old
                 raise KeyError(new)
             finally:
                 self.value_lock.release()
 
     def _selected_labels_changed(self, name, old, new):
         """Called when the selected label has been changed (typically by the
         frontend)."""
         if self.value_lock.acquire(False):
             try:
                 self.value = [self._options_dict[name] for name in new]
             finally:
                 self.value_lock.release()
 
 
 @register('IPython.ToggleButtons')
 class ToggleButtons(_Selection):
     """Group of toggle buttons that represent an enumeration.  Only one toggle
     button can be toggled at any point in time.""" 
     _view_name = Unicode('ToggleButtonsView', sync=True)
     tooltips = List(Unicode(), sync=True)
     icons = List(Unicode(), sync=True)
 
     button_style = CaselessStrEnum(
         values=['primary', 'success', 'info', 'warning', 'danger', ''], 
         default_value='', allow_none=True, sync=True, help="""Use a
         predefined styling for the buttons.""")
 
 @register('IPython.Dropdown')
 class Dropdown(_Selection):
     """Allows you to select a single item from a dropdown."""
     _view_name = Unicode('DropdownView', sync=True)
 
     button_style = CaselessStrEnum(
         values=['primary', 'success', 'info', 'warning', 'danger', ''], 
         default_value='', allow_none=True, sync=True, help="""Use a
         predefined styling for the buttons.""")
 
 @register('IPython.RadioButtons')
 class RadioButtons(_Selection):
     """Group of radio buttons that represent an enumeration.  Only one radio
     button can be toggled at any point in time.""" 
     _view_name = Unicode('RadioButtonsView', sync=True)
     
 
 
 @register('IPython.Select')
 class Select(_Selection):
     """Listbox that only allows one item to be selected at any given time."""
     _view_name = Unicode('SelectView', sync=True)
 
 
 @register('IPython.SelectMultiple')
 class SelectMultiple(_MultipleSelection):
     """Listbox that allows many items to be selected at any given time.
     Despite their names, inherited from ``_Selection``, the currently chosen
     option values, ``value``, or their labels, ``selected_labels`` must both be
     updated with a list-like object."""
     _view_name = Unicode('SelectMultipleView', sync=True)
 
 
 # Remove in IPython 4.0
 ToggleButtonsWidget = DeprecatedClass(ToggleButtons, 'ToggleButtonsWidget')
 DropdownWidget = DeprecatedClass(Dropdown, 'DropdownWidget')
 RadioButtonsWidget = DeprecatedClass(RadioButtons, 'RadioButtonsWidget')
 SelectWidget = DeprecatedClass(Select, 'SelectWidget')

IPython/html/widgets/widget_selectioncontainer.py

@@ -1,68 +1,58 b''
 """SelectionContainer class.  
 
 Represents a multipage container that can be used to group other widgets into
 pages.
 """
-#-----------------------------------------------------------------------------
-# Copyright (c) 2013, the IPython Development Team.
-#
+
+# Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
-#
-# The full license is in the file COPYING.txt, distributed with this software.
-#-----------------------------------------------------------------------------
 
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
 from .widget_box import Box, register
 from IPython.utils.traitlets import Unicode, Dict, CInt
-from IPython.utils.warn import DeprecatedClass
+from .deprecated import DeprecatedClass
 
-#-----------------------------------------------------------------------------
-# Classes
-#-----------------------------------------------------------------------------
 class _SelectionContainer(Box):
     """Base class used to display multiple child widgets."""
     _titles = Dict(help="Titles of the pages", sync=True)
     selected_index = CInt(0, sync=True)
 
     # Public methods
     def set_title(self, index, title):
         """Sets the title of a container page.
 
         Parameters
         ----------
         index : int
             Index of the container page
         title : unicode
             New title"""
         self._titles[index] = title
         self.send_state('_titles')
 
     def get_title(self, index):
         """Gets the title of a container pages.
 
         Parameters
         ----------
         index : int
             Index of the container page"""
         if index in self._titles:
             return self._titles[index]
         else:
             return None
 
 @register('IPython.Accordion')
 class Accordion(_SelectionContainer):
     """Displays children each on a separate accordion page."""
     _view_name = Unicode('AccordionView', sync=True)
 
 
 @register('IPython.Tab')
 class Tab(_SelectionContainer):
     """Displays children each on a separate accordion tab."""
     _view_name = Unicode('TabView', sync=True)
 
 
 # Remove in IPython 4.0
 AccordionWidget = DeprecatedClass(Accordion, 'AccordionWidget')
 TabWidget = DeprecatedClass(Tab, 'TabWidget')

IPython/html/widgets/widget_string.py

@@ -1,95 +1,86 b''
 """String class.  
 
 Represents a unicode string using a widget.
 """
-#-----------------------------------------------------------------------------
-# Copyright (c) 2013, the IPython Development Team.
-#
+
+# Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
-#
-# The full license is in the file COPYING.txt, distributed with this software.
-#-----------------------------------------------------------------------------
 
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
 from .widget import DOMWidget, CallbackDispatcher, register
 from IPython.utils.traitlets import Unicode, Bool
-from IPython.utils.warn import DeprecatedClass
+from .deprecated import DeprecatedClass
+
 
-#-----------------------------------------------------------------------------
-# Classes
-#-----------------------------------------------------------------------------
 class _String(DOMWidget):
     """Base class used to create widgets that represent a string."""
     value = Unicode(help="String value", sync=True)
     disabled = Bool(False, help="Enable or disable user changes", sync=True)
     description = Unicode(help="Description of the value this widget represents", sync=True)
     placeholder = Unicode("", help="Placeholder text to display when nothing has been typed", sync=True)
 
     def __init__(self, value=None, **kwargs):
         if value is not None:
             kwargs['value'] = value
         super(_String, self).__init__(**kwargs)
 
 @register('IPython.HTML')
 class HTML(_String):
     """Renders the string `value` as HTML."""
     _view_name = Unicode('HTMLView', sync=True)
 
 
 @register('IPython.Latex')
 class Latex(_String):
     """Renders math inside the string `value` as Latex (requires $ $ or $$ $$ 
     and similar latex tags)."""
     _view_name = Unicode('LatexView', sync=True)
 
 
 @register('IPython.Textarea')
 class Textarea(_String):
     """Multiline text area widget."""
     _view_name = Unicode('TextareaView', sync=True)
 
     def scroll_to_bottom(self):
         self.send({"method": "scroll_to_bottom"})
 
 
 @register('IPython.Text')
 class Text(_String):
     """Single line textbox widget."""
     _view_name = Unicode('TextView', sync=True)
 
     def __init__(self, *args, **kwargs):
         super(Text, self).__init__(*args, **kwargs)
         self._submission_callbacks = CallbackDispatcher()
         self.on_msg(self._handle_string_msg)
 
     def _handle_string_msg(self, _, content):
         """Handle a msg from the front-end.
 
         Parameters
         ----------
         content: dict
             Content of the msg."""
         if content.get('event', '') == 'submit':
             self._submission_callbacks(self)
 
     def on_submit(self, callback, remove=False):
         """(Un)Register a callback to handle text submission.
 
         Triggered when the user clicks enter.
 
         Parameters
         ----------
         callback: callable
             Will be called with exactly one argument: the Widget instance
         remove: bool (optional)
             Whether to unregister the callback"""
         self._submission_callbacks.register_callback(callback, remove=remove)
 
 
 # Remove in IPython 4.0
 HTMLWidget = DeprecatedClass(HTML, 'HTMLWidget')
 LatexWidget = DeprecatedClass(Latex, 'LatexWidget')
 TextareaWidget = DeprecatedClass(Textarea, 'TextareaWidget')
 TextWidget = DeprecatedClass(Text, 'TextWidget')

IPython/utils/warn.py

@@ -1,81 +1,57 b''
 # encoding: utf-8
 """
 Utilities for warnings.  Shoudn't we just use the built in warnings module.
 """
 
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2011  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.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
 from __future__ import print_function
 
 import sys
-import warnings
 
 from IPython.utils import io
 
-#-----------------------------------------------------------------------------
-# Code
-#-----------------------------------------------------------------------------
 
 def warn(msg,level=2,exit_val=1):
     """Standard warning printer. Gives formatting consistency.
 
     Output is sent to io.stderr (sys.stderr by default).
 
     Options:
 
     -level(2): allows finer control:
       0 -> Do nothing, dummy function.
       1 -> Print message.
       2 -> Print 'WARNING:' + message. (Default level).
       3 -> Print 'ERROR:' + message.
       4 -> Print 'FATAL ERROR:' + message and trigger a sys.exit(exit_val).
 
     -exit_val (1): exit value returned by sys.exit() for a level 4
     warning. Ignored for all other levels."""
 
     if level>0:
         header = ['','','WARNING: ','ERROR: ','FATAL ERROR: ']
         print(header[level], msg, sep='', file=io.stderr)
         if level == 4:
             print('Exiting.\n', file=io.stderr)
             sys.exit(exit_val)
 
             
 def info(msg):
     """Equivalent to warn(msg,level=1)."""
 
     warn(msg,level=1)
 
     
 def error(msg):
     """Equivalent to warn(msg,level=3)."""
 
     warn(msg,level=3)
 
     
 def fatal(msg,exit_val=1):
     """Equivalent to warn(msg,exit_val=exit_val,level=4)."""
 
     warn(msg,exit_val=exit_val,level=4)
 
-
-def DeprecatedClass(base, class_name):
-    # Hook the init method of the base class.
-    def init_hook(self, *pargs, **kwargs):
-        base.__init__(self, *pargs, **kwargs)
-
-        # Warn once per class.
-        if base not in DeprecatedClass._warned_classes:
-            DeprecatedClass._warned_classes.append(base)
-            warn('"{}" is deprecated, please use "{}" instead.'.format(
-                class_name, base.__name__))
-    return type(class_name, (base,), {'__init__': init_hook})
-DeprecatedClass._warned_classes = []