s/this/self

IPython/utils/eventful.py

@@ -1,299 +1,299 b''
 """Contains eventful dict and list implementations."""
 
 # void function used as a callback placeholder.
 def _void(*p, **k): return None
 
 class EventfulDict(dict):
     """Eventful dictionary.
 
     This class inherits from the Python intrinsic dictionary class, dict.  It
     adds events to the get, set, and del actions and optionally allows you to
     intercept and cancel these actions.  The eventfulness isn't recursive.  In
     other words, if you add a dict as a child, the events of that dict won't be
     listened to.  If you find you need something recursive, listen to the `add`
     and `set` methods, and then cancel `dict` values from being set, and instead
     set `EventfulDict`s that wrap those `dict`s.  Then you can wire the events
     to the same handlers if necessary.
 
     See the on_events, on_add, on_set, and on_del methods for registering 
     event handlers."""
 
     def __init__(self, *args, **kwargs):
         """Public constructor"""
         self._add_callback = _void
         self._del_callback = _void
         self._set_callback = _void
         dict.__init__(self, *args, **kwargs)
 
     def on_events(self, add_callback=None, set_callback=None, del_callback=None):
         """Register callbacks for add, set, and del actions.
 
         See the doctstrings for on_(add/set/del) for details about each 
         callback.
 
         add_callback: [callback = None]
         set_callback: [callback = None]
         del_callback: [callback = None]"""
         self.on_add(add_callback)
         self.on_set(set_callback)
         self.on_del(del_callback)
 
     def on_add(self, callback):
         """Register a callback for when an item is added to the dict.
 
         Allows the listener to detect when items are added to the dictionary and
         optionally cancel the addition.
 
         callback: callable or None
             If you want to ignore the addition event, pass None as the callback.
             The callback should have a signature of callback(key, value).  The
             callback should return a boolean True if the additon should be
             canceled, False or None otherwise."""
         self._add_callback = callback if callable(callback) else _void
 
     def on_del(self, callback):
         """Register a callback for when an item is deleted from the dict.
 
         Allows the listener to detect when items are deleted from the dictionary
         and optionally cancel the deletion.
 
         callback: callable or None
             If you want to ignore the deletion event, pass None as the callback.
             The callback should have a signature of callback(key).  The
             callback should return a boolean True if the deletion should be
             canceled, False or None otherwise."""
         self._del_callback = callback if callable(callback) else _void
         
     def on_set(self, callback):
         """Register a callback for when an item is changed in the dict.
 
         Allows the listener to detect when items are changed in the dictionary
         and optionally cancel the change.
 
         callback: callable or None
             If you want to ignore the change event, pass None as the callback.
             The callback should have a signature of callback(key, value).  The
             callback should return a boolean True if the change should be
             canceled, False or None otherwise."""
         self._set_callback = callback if callable(callback) else _void
         
     def pop(self, key):
         """Returns the value of an item in the dictionary and then deletes the
         item from the dictionary."""
         if self._can_del(key):
             return dict.pop(self, key)
         else:
             raise Exception('Cannot `pop`, deletion of key "{}" failed.'.format(key))
 
     def popitem(self):
         """Pop the next key/value pair from the dictionary."""
         key = next(iter(self))
         return key, self.pop(key)
 
     def update(self, other_dict):
         """Copy the key/value pairs from another dictionary into this dictionary,
         overwriting any conflicting keys in this dictionary."""
         for (key, value) in other_dict.items():
             self[key] = value
             
     def clear(self):
         """Clear the dictionary."""
         for key in list(self.keys()):
             del self[key]
 
     def __setitem__(self, key, value):
         if (key in self and self._can_set(key, value)) or \
         (key not in self and self._can_add(key, value)):
             return dict.__setitem__(self, key, value)
         
     def __delitem__(self, key):
         if self._can_del(key):
             return dict.__delitem__(self, key)
 
     def _can_add(self, key, value):
         """Check if the item can be added to the dict."""
         return not bool(self._add_callback(key, value))
 
     def _can_del(self, key):
         """Check if the item can be deleted from the dict."""
         return not bool(self._del_callback(key))
 
     def _can_set(self, key, value):
         """Check if the item can be changed in the dict."""
         return not bool(self._set_callback(key, value))
 
 
 class EventfulList(list):
     """Eventful list.
 
     This class inherits from the Python intrinsic `list` class.  It adds events 
     that allow you to listen for actions that modify the list.  You can 
     optionally cancel the actions.
 
     See the on_del, on_set, on_insert, on_sort, and on_reverse methods for
     registering an event handler.
 
     Some of the method docstrings were taken from the Python documentation at
     https://docs.python.org/2/tutorial/datastructures.html"""
 
     def __init__(self, *pargs, **kwargs):
         """Public constructor"""
         self._insert_callback = _void
         self._set_callback = _void
         self._del_callback = _void
         self._sort_callback = _void
         self._reverse_callback = _void
         list.__init__(self, *pargs, **kwargs)
 
     def on_events(self, insert_callback=None, set_callback=None, 
         del_callback=None, reverse_callback=None, sort_callback=None):
         """Register callbacks for add, set, and del actions.
 
         See the doctstrings for on_(insert/set/del/reverse/sort) for details 
         about each callback.
 
         insert_callback: [callback = None]
         set_callback: [callback = None]
         del_callback: [callback = None]
         reverse_callback: [callback = None]
         sort_callback: [callback = None]"""
-        this.on_insert(insert_callback)
-        this.on_set(set_callback)
-        this.on_del(del_callback)
-        this.on_reverse(reverse_callback)
-        this.on_sort(sort_callback)
+        self.on_insert(insert_callback)
+        self.on_set(set_callback)
+        self.on_del(del_callback)
+        self.on_reverse(reverse_callback)
+        self.on_sort(sort_callback)
 
     def on_insert(self, callback):
         """Register a callback for when an item is inserted into the list.
 
         Allows the listener to detect when items are inserted into the list and
         optionally cancel the insertion.
 
         callback: callable or None
             If you want to ignore the insertion event, pass None as the callback.
             The callback should have a signature of callback(index, value).  The
             callback should return a boolean True if the insertion should be
             canceled, False or None otherwise."""
         self._insert_callback = callback if callable(callback) else _void
         
     def on_del(self, callback):
         """Register a callback for item deletion.
 
         Allows the listener to detect when items are deleted from the list and
         optionally cancel the deletion.
 
         callback: callable or None
             If you want to ignore the deletion event, pass None as the callback.
             The callback should have a signature of callback(index).  The
             callback should return a boolean True if the deletion should be
             canceled, False or None otherwise."""
         self._del_callback = callback if callable(callback) else _void
         
     def on_set(self, callback):
         """Register a callback for items are set.
 
         Allows the listener to detect when items are set and optionally cancel 
         the setting.  Note, `set` is also called when one or more items are
         added to the end of the list.
 
         callback: callable or None
             If you want to ignore the set event, pass None as the callback.
             The callback should have a signature of callback(index, value).  The
             callback should return a boolean True if the set should be
             canceled, False or None otherwise."""
         self._set_callback = callback if callable(callback) else _void
         
     def on_reverse(self, callback):
         """Register a callback for list reversal.
 
         callback: callable or None
             If you want to ignore the reverse event, pass None as the callback.
             The callback should have a signature of callback().  The
             callback should return a boolean True if the reverse should be
             canceled, False or None otherwise."""
         self._reverse_callback = callback if callable(callback) else _void
         
     def on_sort(self, callback):
         """Register a callback for sortting of the list.
 
         callback: callable or None
             If you want to ignore the sort event, pass None as the callback.
             The callback signature should match that of Python list's `.sort` 
             method or `callback(*pargs, **kwargs)` as a catch all. The callback 
             should return a boolean True if the reverse should be canceled, 
             False or None otherwise."""
         self._sort_callback = callback if callable(callback) else _void
         
     def append(self, x):
         """Add an item to the end of the list."""
         self[len(self):] = [x]
 
     def extend(self, L):
         """Extend the list by appending all the items in the given list."""
         self[len(self):] = L
 
     def remove(self, x):
         """Remove the first item from the list whose value is x. It is an error 
         if there is no such item."""
         del self[self.index(x)]
         
     def pop(self, i=None):
         """Remove the item at the given position in the list, and return it. If 
         no index is specified, a.pop() removes and returns the last item in the 
         list."""
         if i is None:
             i = len(self) - 1
         val = self[i]
         del self[i]
         return val
 
     def reverse(self):
         """Reverse the elements of the list, in place."""
         if self._can_reverse():
             list.reverse(self)
     
     def insert(self, index, value):
         """Insert an item at a given position. The first argument is the index 
         of the element before which to insert, so a.insert(0, x) inserts at the 
         front of the list, and a.insert(len(a), x) is equivalent to 
         a.append(x)."""
         if self._can_insert(index, value):
             list.insert(self, index, value)
 
     def sort(self, *pargs, **kwargs):
         """Sort the items of the list in place (the arguments can be used for 
         sort customization, see Python's sorted() for their explanation)."""
         if self._can_sort(*pargs, **kwargs):
             list.sort(self, *pargs, **kwargs)
 
     def __delitem__(self, index):
         if self._can_del(index):
             list.__delitem__(self, index)
 
     def __setitem__(self, index, value):
         if self._can_set(index, value):
             list.__setitem__(self, index, value)
 
     def __setslice__(self, start, end, value):
         if self._can_set(slice(start, end), value):
             list.__setslice__(self, start, end, value)
     
     def _can_insert(self, index, value):
         """Check if the item can be inserted."""
         return not bool(self._insert_callback(index, value))
 
     def _can_del(self, index):
         """Check if the item can be deleted."""
         return not bool(self._del_callback(index))
 
     def _can_set(self, index, value):
         """Check if the item can be set."""
         return not bool(self._set_callback(index, value))
 
     def _can_reverse(self):
         """Check if the list can be reversed."""
         return not bool(self._reverse_callback())
 
     def _can_sort(self, *pargs, **kwargs):
         """Check if the list can be sorted."""
         return not bool(self._sort_callback(*pargs, **kwargs))