Renamed widget python classes to avoid name stomping

IPython/html/widgets/__init__.py

@@ -1,10 +1,10 b''
-from base import Widget, init_widget_js
+from widget import Widget, init_widget_js
 
-from bool import BoolWidget
-from container import ContainerWidget
-from float import FloatWidget
-from float_range import FloatRangeWidget
-from int import IntWidget
-from int_range import IntRangeWidget
-from selection import SelectionWidget
-from string import StringWidget
+from widget_bool import BoolWidget
+from widget_container import ContainerWidget
+from widget_float import FloatWidget
+from widget_float_range import FloatRangeWidget
+from widget_int import IntWidget
+from widget_int_range import IntRangeWidget
+from widget_selection import SelectionWidget
+from widget_string import StringWidget

IPython/html/widgets/widget.py

@@ -1,164 +1,165 b''
 from copy import copy
 from glob import glob
 import uuid
 import sys
 import os
 
 import IPython
 from IPython.kernel.comm import Comm
 from IPython.config import LoggingConfigurable
 from IPython.utils.traitlets import Unicode, Dict, List
 from IPython.display import Javascript, display
 from IPython.utils.py3compat import string_types
 
 def init_widget_js():
     path = os.path.split(os.path.abspath( __file__ ))[0]
     for filepath in glob(os.path.join(path, "*.py")):
         filename = os.path.split(filepath)[1]
         name = filename.rsplit('.', 1)[0]
-        if not (name == 'base' or name == '__init__'):
-            js_path = 'static/notebook/js/widgets/%s.js' % name
+        if not (name == 'widget' or name == '__init__') and name.startswith('widget_'):
+            # Remove 'widget_' from the start of the name before compiling the path.
+            js_path = 'static/notebook/js/widgets/%s.js' % name[7:]
             display(Javascript(data='$.getScript("%s");' % js_path))  
 
 
 class Widget(LoggingConfigurable):
 
     ### Public declarations
     target_name = Unicode('widget')
     default_view_name = Unicode()
     
     
     ### Private/protected declarations
     _keys = []
     _property_lock = False
     _parent = None
     _children = []
     _css = Dict()
     
     
     ### Public constructor
     def __init__(self, parent=None, **kwargs):
         super(Widget, self).__init__(**kwargs)
         
         self._children = []
         if parent is not None:
             parent._children.append(self)
         self._parent = parent
         self.comm = None
         
         # Register after init to allow default values to be specified
         self.on_trait_change(self._handle_property_changed, self.keys)
         
         
     def __del__(self):
         self.close()
     
     def close(self):
         self.comm.close()
         del self.comm
     
     
     ### Properties
     def _get_parent(self):
         return self._parent
     parent = property(_get_parent)
     
     
     def _get_children(self):
         return copy(self._children)
     children = property(_get_children)
     
     
     def _get_keys(self):
         keys = ['_css']
         keys.extend(self._keys)
         return keys
     keys = property(_get_keys)
     
     def _get_css(self, key, selector=""):
         if selector in self._css and key in self._css[selector]:
             return self._css[selector][key]
         else:
             return None
     def _set_css(self, value, key, selector=""):
         if selector not in self._css:
             self._css[selector] = {}
             
         # Only update the property if it has changed.
         if not (key in self._css[selector] and value in self._css[selector][key]):
             self._css[selector][key] = value
             self.send_state() # Send new state to client.
             
     css = property(_get_css, _set_css)
     
     
     ### Event handlers
     def _handle_msg(self, msg):
         
         # Handle backbone sync methods
         sync_method = msg['content']['data']['sync_method']
         sync_data = msg['content']['data']['sync_data']
         if sync_method.lower() in ['create', 'update']:
             self._handle_recieve_state(sync_data)
     
     
     def _handle_recieve_state(self, sync_data):
         self._property_lock = True
         try:
             
             # Use _keys instead of keys - Don't get retrieve the css from the client side.
             for name in self._keys:
                 if name in sync_data:
                     setattr(self, name, sync_data[name])
         finally:
             self._property_lock = False
     
     
     def _handle_property_changed(self, name, old, new):
         if not self._property_lock and self.comm is not None:
             # TODO: Validate properties.
             # Send new state to frontend
             self.send_state()
 
 
     def _handle_close(self):
         self.comm = None
     
     
     ### Public methods
     def _repr_widget_(self, view_name=None):
         if not view_name:
             view_name = self.default_view_name
         
         # Create a comm.
         if self.comm is None:
             self.comm = Comm(target_name=self.target_name)
             self.comm.on_msg(self._handle_msg)
             self.comm.on_close(self._handle_close)
         
         # Make sure model is syncronized
         self.send_state()
             
         # Show view.
         if self.parent is None:
             self.comm.send({"method": "show", "view_name": view_name})
         else:
             self.comm.send({"method": "show", 
                             "view_name": view_name,
                             "parent": self.parent.comm.comm_id})
         
         # Now show children if any.
         for child in self.children:
             child._repr_widget_()
         return None
 
 
     def send_state(self):
         state = {}
         for key in self.keys:
             try:
                 state[key] = getattr(self, key)
             except Exception as e:
                 pass # Eat errors, nom nom nom
         self.comm.send({"method": "update",
                         "state": state})