Fix pylint/pep8 issues

8 files changed, 154 insertions, 135 deletions

diff --git a/src/jarabe/journal/browse/lazymodel.py b/src/jarabe/journal/browse/lazymodel.py
index 8e5c12e..d590fbc 100644
--- a/src/jarabe/journal/browse/lazymodel.py
+++ b/src/jarabe/journal/browse/lazymodel.py
@@ -18,10 +18,13 @@ import gtk
 import logging
 from gobject import GObject, SIGNAL_RUN_FIRST, TYPE_PYOBJECT
 
+
 class Source(GObject):
+
     __gsignals__ = {
             'objects-updated': (SIGNAL_RUN_FIRST, None, []),
-            'row-delayed-fetch': (SIGNAL_RUN_FIRST, None, 2*[TYPE_PYOBJECT]) }
+            'row-delayed-fetch': (SIGNAL_RUN_FIRST, None, 2 * [TYPE_PYOBJECT]),
+            }
 
     def get_count(self):
         """ Returns number of objects """
@@ -46,28 +49,36 @@ class Source(GObject):
         """ Set current order """
         pass
 
+
 class LazyModel(gtk.GenericTreeModel):
-    def __init__(self, columns, calc_columns={}):
+
+    def __init__(self, columns, calc_columns=None):
         """ columns/calc_columns = {field_name: (column_num, column_type)} """
         gtk.GenericTreeModel.__init__(self)
 
-        self._columns_by_name = {}
-        self._columns_by_num = {}
-        self._columns_types = {}
+        self.columns_by_name = {}
+        self.columns_by_num = {}
+        self.columns_types = {}
 
         for name, i in columns.items():
-            self._columns_by_name[name] = i[0]
-            self._columns_by_num[i[0]] = name
-            self._columns_types[i[0]] = i[1]
+            self.columns_by_name[name] = i[0]
+            self.columns_by_num[i[0]] = name
+            self.columns_types[i[0]] = i[1]
 
-        for name, i in calc_columns.items():
-            self._columns_types[i[0]] = i[1]
+        if calc_columns is not None:
+            for name, i in calc_columns.items():
+                self.columns_types[i[0]] = i[1]
 
-        self._n_columns = max(self._columns_types.keys()) + 1
+        self._n_columns = max(self.columns_types.keys()) + 1
 
         self._source = None
         self._closing = False
         self._view = None
+        self._last_count = 0
+        self._cache = {}
+        self._frame = (0, -1)
+        self._in_process = {}
+        self._postponed = []
 
         self.set_source(None, force=True)
         self.set_view(None, force=True)
@@ -85,12 +96,12 @@ class LazyModel(gtk.GenericTreeModel):
 
         if self._source is not None:
             self._source.disconnect_by_func(self.refresh)
-            self._source.disconnect_by_func(self._delayed_fetch_cb)
+            self._source.disconnect_by_func(self.__delayed_fetch_cb)
 
         self._source = source
         if self._source is not None:
             self._source.connect('objects-updated', self.refresh)
-            self._source.connect('row-delayed-fetch', self._delayed_fetch_cb)
+            self._source.connect('row-delayed-fetch', self.__delayed_fetch_cb)
 
         self.refresh()
 
@@ -129,17 +140,17 @@ class LazyModel(gtk.GenericTreeModel):
     view = property(get_view, set_view)
 
     def get_order(self):
-        if not self._source:
+        if self._source is None:
             return None
         order = self._source.get_order()
         if order is None:
             return None
-        return (self._columns_by_name[order[0]], order[1])
+        return (self.columns_by_name[order[0]], order[1])
 
     def set_order(self, column, order):
-        if not self._source:
+        if self._source is None:
             return
-        self._source.set_order(self._columns_by_num[column], order)
+        self._source.set_order(self.columns_by_num[column], order)
         self._update_columns()
 
     def refresh(self, sender=None):
@@ -157,17 +168,17 @@ class LazyModel(gtk.GenericTreeModel):
         #      commented for now since in TableView
         #      it works fine w/o these updates
         #for i in range(self._last_count, count):
-        #    self.emit('row-inserted', (i,), self.get_iter((i,)))
+        #    self.emit('row-inserted', (i, ), self.get_iter((i, )))
         #for i in reversed(range(count, self._last_count)):
-        #    self.emit('row-deleted', (i,))
+        #    self.emit('row-deleted', (i, ))
         if self._last_count != count:
-            self.emit('rows-reordered', (0,), self.get_iter((0,)), None)
+            self.emit('rows-reordered', (0, ), self.get_iter((0, )), None)
 
         if self._frame[0] >= count:
             self._frame = (0, -1)
         elif self._frame[1] >= count:
             for i in range(count, self._frame[1]):
-                if self._cache.has_key(i):
+                if i in self._cache:
                     del self._cache[i]
             self._frame = (self._frame[0], count-1)
 
@@ -175,40 +186,40 @@ class LazyModel(gtk.GenericTreeModel):
 
         if self._last_count == count:
             for i in range(self._frame[0], self._frame[1]+1):
-                self.emit('row-changed', (i,), self.get_iter((i,)))
+                self.emit('row-changed', (i, ), self.get_iter((i, )))
 
         self._last_count = count
 
     def recalc(self, fields):
         for i, row in self._cache.items():
             for field in fields:
-                if row.has_key(field):
+                if field in row:
                     del row[field]
-            self.emit('row-changed', (i,), self.get_iter((i,)))
+            self.emit('row-changed', (i, ), self.get_iter((i, )))
 
     def get_row(self, pos, frame=None):
-        if not self._source:
+        if self._source is None:
             return False
         if not isinstance(pos, tuple):
             pos = self.get_path(pos)
         return self._get_row(pos[0], frame or (pos, pos))
 
-    def _delayed_fetch_cb(self, source, offset, object):
-        if not self._in_process.has_key(offset):
-            logging.debug('_delayed_fetch_cb: no offset=%s' % offset)
+    def __delayed_fetch_cb(self, source, offset, metadata):
+        if not offset in self._in_process:
+            logging.debug('__delayed_fetch_cb: no offset=%s' % offset)
             return
 
-        logging.debug('_delayed_fetch_cb: get %s' % offset)
+        logging.debug('__delayed_fetch_cb: get %s' % offset)
 
-        path = (offset,)
-        iter = self.get_iter(path)
-        row = Row(self, path, iter, object)
+        path = (offset, )
+        iterator = self.get_iter(path)
+        row = Row(self, path, iterator, metadata)
 
         if self.in_frame(offset):
             self._cache[offset] = row
 
         del self._in_process[offset]
-        self.emit('row-changed', path, iter)
+        self.emit('row-changed', path, iterator)
         if self._in_process:
             return
 
@@ -216,13 +227,14 @@ class LazyModel(gtk.GenericTreeModel):
             offset, force = self._postponed.pop()
             if not force and not self.in_frame(offset):
                 continue
-            row = self.get_row((offset,))
-            if row:
-                self.emit('row-changed', row.path, row.iter)
+            row = self.get_row((offset, ))
+            if row is not None and row != False:
+                self.emit('row-changed', row.path, row.iterator)
             else:
                 break
 
     def _get_row(self, offset, frame):
+
         def fetch():
             row = self._source.get_row(offset)
 
@@ -234,12 +246,12 @@ class LazyModel(gtk.GenericTreeModel):
                 self._in_process[offset] = True
                 return None
 
-            row = Row(self, (offset,), self.get_iter(offset), row)
+            row = Row(self, (offset, ), self.get_iter(offset), row)
             self._cache[offset] = row
             return row
 
         out = self._cache.get(offset)
-        if out:
+        if out is not None:
             return out
 
         if frame[0] >= frame[1]:
@@ -259,10 +271,10 @@ class LazyModel(gtk.GenericTreeModel):
                 self._cache = {}
             else:
                 for i in range(self._frame[0], intersect_min):
-                    if self._cache.has_key(i):
+                    if i in self._cache:
                         del self._cache[i]
                 for i in range(intersect_max+1, self._frame[1]+1):
-                    if self._cache.has_key(i):
+                    if i in self._cache:
                         del self._cache[i]
             self._frame = frame
 
@@ -274,7 +286,7 @@ class LazyModel(gtk.GenericTreeModel):
 
     def _update_columns(self):
         order = self.get_order()
-        if not order or not hasattr(self._view, 'get_columns'):
+        if order is None or not hasattr(self._view, 'get_columns'):
             return
 
         for column in self._view.get_columns():
@@ -287,38 +299,36 @@ class LazyModel(gtk.GenericTreeModel):
     def in_frame(self, offset):
         return offset >= self._frame[0] and offset <= self._frame[1]
 
-    # interface implementation -------------------------------------------------
-
     def on_get_n_columns(self):
         return self._n_columns
 
     def on_get_column_type(self, index):
-        return self._columns_types.get(index, bool)
+        return self.columns_types.get(index, bool)
 
-    def on_iter_n_children(self, iter):
-        if iter is None and not self._closing:
+    def on_iter_n_children(self, iterator):
+        if iterator is None and not self._closing:
             return self._source.get_count()
         else:
             return 0
 
     def on_get_value(self, offset, column):
-        if not self._view or offset >= self._source.get_count():
+        if self._view is None or offset >= self._source.get_count():
             return None
 
-        # return value only if iter came from visible range
+        # return value only if iterator came from visible range
         # (on setting model, gtk.TreeView scans all items)
-        range = self._view.get_visible_range()
-        if range and offset >= range[0][0] and offset <= range[1][0]:
-            row = self._get_row(offset, (range[0][0], range[1][0]))
-            return row and row[column]
+        vrange = self._view.get_visible_range()
+        if vrange and offset >= vrange[0][0] and offset <= vrange[1][0]:
+            row = self._get_row(offset, (vrange[0][0], vrange[1][0]))
+            return row is not None and row != False and row[column]
 
         return None
 
-    def on_iter_nth_child(self, iter, n):
+    def on_iter_nth_child(self, iterator, n):
         return n
 
-    def on_get_path(self, iter):
-        return (iter)
+    def on_get_path(self, iterator):
+        return iterator
 
     def on_get_iter(self, path):
         if self._source.get_count() and not self._closing:
@@ -326,36 +336,38 @@ class LazyModel(gtk.GenericTreeModel):
         else:
             return False
 
-    def on_iter_next(self, iter):
-        if iter != None:
-            if iter >= self._source.get_count() - 1 or self._closing:
+    def on_iter_next(self, iterator):
+        if iterator is not None:
+            if iterator >= self._source.get_count() - 1 or self._closing:
                 return None
-            return iter + 1
+            return iterator + 1
         return None
 
     def on_get_flags(self):
         return gtk.TREE_MODEL_ITERS_PERSIST | gtk.TREE_MODEL_LIST_ONLY
 
-    def on_iter_children(self, iter):
+    def on_iter_children(self, iterator):
         return None
 
-    def on_iter_has_child(self, iter):
+    def on_iter_has_child(self, iterator):
         return False
 
-    def on_iter_parent(self, iter):
+    def on_iter_parent(self, iterator):
         return None
 
+
 class Row:
-    def __init__(self, model, path, iter, object):
+
+    def __init__(self, model, path, iterator, metadata):
         self.model = model
-        self.iter = iter
+        self.iterator = iterator
         self.path = path
-        self.metadata = object
-        self.row = [None] * len(model._columns_by_name)
+        self.metadata = metadata
+        self.row = [None] * len(model.columns_by_name)
         self._calced_row = {}
 
-        for name, value in object.items():
-            column = model._columns_by_name.get(str(name), -1)
+        for name, value in metadata.items():
+            column = model.columns_by_name.get(str(name), -1)
             if column != -1:
                 self.row[column] = value
 
@@ -364,7 +376,7 @@ class Row:
             if key < len(self.row):
                 return self.row[key]
             else:
-                if self._calced_row.has_key(key):
+                if key in self._calced_row:
                     return self._calced_row[key]
                 else:
                     value = self.model.on_calc_value(self, key)
@@ -394,7 +406,7 @@ class Row:
 
     def __contains__(self, key):
         if isinstance(key, int):
-            return key < len(self.row) or self._calced_row.has_key(key)
+            return key < len(self.row) or key in self._calced_row
         else:
             return self.metadata.__contains__(key)
 
@@ -402,7 +414,7 @@ class Row:
         return self.__contains__(key)
 
     def get(self, key, default=None):
-        if self.has_key(key):
+        if key in self:
             return self.__getitem__(key)
         else:
             return default
diff --git a/src/jarabe/journal/browse/smoothtable.py b/src/jarabe/journal/browse/smoothtable.py
index 437eb47..9f6af15 100644
--- a/src/jarabe/journal/browse/smoothtable.py
+++ b/src/jarabe/journal/browse/smoothtable.py
@@ -20,7 +20,9 @@ import math
 import bisect
 import logging
 
+
 class SmoothTable(gtk.Container):
+
     __gsignals__ = {
             'set-scroll-adjustments': (gobject.SIGNAL_RUN_FIRST, None,
                                       [gtk.Adjustment, gtk.Adjustment]),
@@ -42,9 +44,9 @@ class SmoothTable(gtk.Container):
 
         gtk.Container.__init__(self)
 
-        for y in range(rows + 2):
+        for i in range(rows + 2):
             row = []
-            for x in range(columns):
+            for j in range(columns):
                 cell = new_cell()
                 cell.show()
                 cell.set_parent(self)
@@ -266,7 +268,9 @@ class SmoothTable(gtk.Container):
             self._last_allocation = self.allocation
             spare_rows = [] + self._rows
         else:
+
             class IndexedRow:
+
                 def __init__(self, row):
                     self.row = row
 
@@ -319,7 +323,8 @@ class SmoothTable(gtk.Container):
             self._adj.value -= self._cell_height
 
         elif event.keyval == gtk.keysyms.Down:
-            self._adj.value += min(uplimit - self._adj.value, self._cell_height)
+            self._adj.value += min(uplimit - self._adj.value,
+                    self._cell_height)
 
         elif event.keyval in (gtk.keysyms.Page_Up, gtk.keysyms.KP_Page_Up):
             self._adj.value -= min(self._adj.value, page)
@@ -339,26 +344,3 @@ class SmoothTable(gtk.Container):
         return True
 
 SmoothTable.set_set_scroll_adjustments_signal('set-scroll-adjustments')
-
-if __name__ == '__main__':
-    import random
-
-    window = gtk.Window()
-
-    scrolled = gtk.ScrolledWindow()
-    scrolled.set_policy(gtk.POLICY_ALWAYS, gtk.POLICY_ALWAYS)
-    window.add(scrolled)
-
-    def fill_in(cell, row, column):
-        cell.props.label = '%s:%s' % (row, column)
-    table = SmoothTable(3, 3, gtk.Button, fill_in)
-    table.bin_rows = 100
-    scrolled.add(table)
-
-    for row in table._rows:
-        for cell in row:
-            cell.connect('clicked',
-                    lambda button: table.goto(random.randint(0, 100)))
-
-    window.show_all()
-    gtk.main()
diff --git a/src/jarabe/journal/browse/tableview.py b/src/jarabe/journal/browse/tableview.py
index b5d45cd..024d212 100644
--- a/src/jarabe/journal/browse/tableview.py
+++ b/src/jarabe/journal/browse/tableview.py
@@ -18,7 +18,6 @@ import gtk
 import math
 import hippo
 import gobject
-import logging
 
 from sugar.graphics import style
 from sugar.graphics.roundbox import CanvasRoundBox
@@ -27,7 +26,9 @@ from jarabe.journal.browse.smoothtable import SmoothTable
 COLOR_BACKGROUND = style.COLOR_WHITE
 COLOR_SELECTED = style.COLOR_TEXT_FIELD_GREY
 
+
 class TableCell:
+
     def __init__(self):
         self.row = None
         self.tree = None
@@ -35,17 +36,19 @@ class TableCell:
     def do_fill_in(self):
         pass
 
+
 class TableView(SmoothTable):
+
     def __init__(self, cell_class, rows, columns):
         SmoothTable.__init__(self, rows, columns,
-                lambda: self._create_cell(cell_class), self._fill_in)
+                lambda: self._create_cell(cell_class), self._do_fill_in)
 
         self._model = None
         self._hover_selection = False
         self._selected_cell = None
 
     def get_cursor(self):
-        return (self.frame[0],)
+        return (self.frame[0], )
 
     def set_cursor(self, cursor):
         self.goto(cursor)
@@ -57,13 +60,13 @@ class TableView(SmoothTable):
         if self._model == model:
             return
 
-        if self._model:
+        if self._model is not None:
             self._model.disconnect_by_func(self.__row_changed_cb)
             self._model.disconnect_by_func(self.__table_resized_cb)
 
         self._model = model
 
-        if model:
+        if model is not None:
             self._model.connect('row-changed', self.__row_changed_cb)
             self._model.connect('rows-reordered', self.__table_resized_cb)
 
@@ -82,7 +85,7 @@ class TableView(SmoothTable):
             getter=get_hover_selection, setter=set_hover_selection)
 
     def get_visible_range(self):
-        return ((self.frame[0],), (self.frame[1],))
+        return ((self.frame[0], ), (self.frame[1], ))
 
     def _create_cell(self, cell_class):
         canvas = hippo.Canvas()
@@ -97,7 +100,8 @@ class TableView(SmoothTable):
         cell.tree = self
         sel_box.append(cell, hippo.PACK_EXPAND)
 
-        canvas.connect('enter-notify-event', self.__enter_notify_event_cb, cell)
+        canvas.connect('enter-notify-event',
+                self.__enter_notify_event_cb, cell)
         canvas.connect('leave-notify-event', self.__leave_notify_event_cb)
 
         canvas.table_view_cell_sel_box = sel_box
@@ -110,7 +114,7 @@ class TableView(SmoothTable):
                 self.columns))
         self.bin_rows = rows
 
-    def _fill_in(self, canvas, y, x, prepared_row=None):
+    def _do_fill_in(self, canvas, y, x, prepared_row=None):
 
         cell = canvas.table_view_cell
         sel_box = canvas.table_view_cell_sel_box
@@ -127,8 +131,8 @@ class TableView(SmoothTable):
             cell_num = y * self.columns + x
 
             if cell_num < self._model.iter_n_children(None):
-                row = self._model.get_row((cell_num,), self.frame)
-                if row != False:
+                row = self._model.get_row((cell_num, ), self.frame)
+                if row is not None and row != False:
                     cell.row = row
 
         if cell.row is None:
@@ -156,7 +160,7 @@ class TableView(SmoothTable):
 
         self._selected_cell = None
 
-    def __row_changed_cb(self, model, path, iter):
+    def __row_changed_cb(self, model, path, iterator):
         y = path[0] / self.columns
         x = path[0] % self.columns
 
@@ -165,7 +169,7 @@ class TableView(SmoothTable):
             return
 
         row = self._model.get_row(path)
-        self._fill_in(canvas, y, x, row)
+        self._do_fill_in(canvas, y, x, row)
 
-    def __table_resized_cb(self, model=None, path=None, iter=None, arg3=None):
+    def __table_resized_cb(self, model=None, path=None, iterator=None, a=None):
         self._resize()
diff --git a/src/jarabe/journal/browse/treeview.py b/src/jarabe/journal/browse/treeview.py
index 0980405..b103e9a 100644
--- a/src/jarabe/journal/browse/treeview.py
+++ b/src/jarabe/journal/browse/treeview.py
@@ -22,7 +22,9 @@ from sugar.graphics.palette import Invoker
 
 _SHOW_PALETTE_TIMEOUT = 200
 
+
 class TreeView(gtk.TreeView):
+
     def __init__(self):
         gtk.TreeView.__init__(self)
         self._invoker = _TreeInvoker(self)
@@ -39,7 +41,9 @@ class TreeView(gtk.TreeView):
     def create_palette(self):
         return self._invoker.cell_palette
 
+
 class TreeViewColumn(gtk.TreeViewColumn):
+
     def __init__(self, title=None, cell=None, **kwargs):
         gtk.TreeViewColumn.__init__(self, title, cell, **kwargs)
         self.view = None
@@ -55,7 +59,7 @@ class TreeViewColumn(gtk.TreeViewColumn):
         return self._order_by
 
     def _clicked_cb(self, column):
-        if not self.view:
+        if self.view is None:
             return
 
         if self.props.sort_indicator:
@@ -68,7 +72,9 @@ class TreeViewColumn(gtk.TreeViewColumn):
 
         self.view.get_model().set_order(self._order_by, new_order)
 
+
 class _TreeInvoker(Invoker):
+
     def __init__(self, tree=None):
         Invoker.__init__(self)
         self._position_hint = self.AT_CURSOR
@@ -83,7 +89,7 @@ class _TreeInvoker(Invoker):
         self._leave_hid = None
         self._button_hid = None
 
-        if tree:
+        if tree is not None:
             self.attach(tree)
 
     def get_toplevel(self):
@@ -94,7 +100,8 @@ class _TreeInvoker(Invoker):
         self._enter_hid = tree.connect('enter-notify-event', self._enter_cb)
         self._motion_hid = tree.connect('motion-notify-event', self._enter_cb)
         self._leave_hid = tree.connect('leave-notify-event', self._leave_cb)
-        self._button_hid = tree.connect('button-release-event', self._button_cb)
+        self._button_hid = tree.connect('button-release-event',
+                self._button_cb)
         Invoker.attach(self, tree)
 
     def detach(self):
@@ -130,19 +137,19 @@ class _TreeInvoker(Invoker):
             return False
 
         row = self._tree.props.model.get_row(path)
-        if not row:
+        if row is None:
             logging.debug('_open_palette: wait for row %s' % path)
             self._enter_timeout = gobject.timeout_add(500, self._open_palette,
                     self.notify_mouse_enter, False)
             return False
 
         palette = column.palette_cb(self._tree.props.model, row, x, y)
-        if not palette:
+        if palette is None:
             self._close_palette()
             return False
 
         if self._palette_pos != (path, column) or self.cell_palette != palette:
-            if self.palette:
+            if self.palette is not None:
                 self.palette.popdown(True)
                 self.palette = None
 
diff --git a/src/jarabe/journal/objectmodel.py b/src/jarabe/journal/objectmodel.py
index 6e98967..d602128 100644
--- a/src/jarabe/journal/objectmodel.py
+++ b/src/jarabe/journal/objectmodel.py
@@ -14,10 +14,7 @@
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
-import gtk
-import cairo
 import gobject
-import logging
 
 from sugar import util
 
@@ -25,7 +22,9 @@ from jarabe.journal import misc
 from jarabe.journal.source import Source
 from jarabe.journal.browse.lazymodel import LazyModel
 
+
 class ObjectModel(LazyModel):
+
     FIELD_FETCHED_FLAG = 50
 
     def __init__(self):
@@ -46,7 +45,7 @@ class ObjectModel(LazyModel):
         return None
 
     def fetch_metadata(self, row, force=False):
-        if row.has_key(self.FIELD_FETCHED_FLAG):
+        if self.FIELD_FETCHED_FLAG in row:
             return True
 
         if row not in self._fetch_queue:
@@ -75,7 +74,7 @@ class ObjectModel(LazyModel):
         row[Source.FIELD_THUMB] = misc.load_preview(metadata)
         row[self.FIELD_FETCHED_FLAG] = True
 
-        self.emit('row-changed', row.path, row.iter)
+        self.emit('row-changed', row.path, row.iterator)
 
         if len(self._fetch_queue):
             self.__idle_cb(False)
diff --git a/src/jarabe/journal/objectview.py b/src/jarabe/journal/objectview.py
index 65571de..07b7d6c 100644
--- a/src/jarabe/journal/objectview.py
+++ b/src/jarabe/journal/objectview.py
@@ -44,7 +44,9 @@ VIEW_TYPES = [ListView, ThumbsView]
 
 PAGE_SIZE = 10
 
+
 class ObjectsView(gtk.Bin):
+
     __gsignals__ = {
         'clear-clicked': (gobject.SIGNAL_RUN_FIRST,
                           gobject.TYPE_NONE,
@@ -75,7 +77,8 @@ class ObjectsView(gtk.Bin):
             view.modify_base(gtk.STATE_NORMAL,
                     style.COLOR_WHITE.get_gdk_color())
             view.connect('detail-clicked', self.__detail_clicked_cb)
-            view.connect('button-release-event', self.__button_release_event_cb)
+            view.connect('button-release-event',
+                    self.__button_release_event_cb)
             view.show()
 
             widget = gtk.ScrolledWindow()
@@ -188,8 +191,8 @@ class ObjectsView(gtk.Bin):
     def _is_query_empty(self):
         # FIXME: This is a hack, we shouldn't have to update this every time
         # a new search term is added.
-        if self._query.get('query', '') or self._query.get('mime_type', '') or \
-                self._query.get('keep', '') or self._query.get('mtime', '') or \
+        if self._query.get('query', '') or self._query.get('mime_type', '') or\
+                self._query.get('keep', '') or self._query.get('mtime', '') or\
                 self._query.get('activity', ''):
             return False
         else:
diff --git a/src/jarabe/journal/source.py b/src/jarabe/journal/source.py
index a7c9084..13bf814 100644
--- a/src/jarabe/journal/source.py
+++ b/src/jarabe/journal/source.py
@@ -14,16 +14,14 @@
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
-import gtk
 import cairo
-from gobject import property, GObject, SIGNAL_RUN_FIRST, TYPE_PYOBJECT
+from gobject import GObject, SIGNAL_RUN_FIRST, TYPE_PYOBJECT
 
-from sugar import util
-
-from jarabe.journal.browse.lazymodel import LazyModel
 from jarabe.journal import model
 
+
 class Source(GObject):
+
     FIELD_UID = 0
     FIELD_TITLE = 1
     FIELD_MTIME = 2
@@ -60,10 +58,12 @@ class Source(GObject):
                    'modify_time': (FIELD_MODIFY_TIME, str),
                    'thumb': (FIELD_THUMB, cairo.ImageSurface)}
 
+
 class LocalSource(Source):
+
     __gsignals__ = {
             'objects-updated': (SIGNAL_RUN_FIRST, None, []),
-            'row-delayed-fetch': (SIGNAL_RUN_FIRST, None, 2*[TYPE_PYOBJECT])
+            'row-delayed-fetch': (SIGNAL_RUN_FIRST, None, 2 * [TYPE_PYOBJECT]),
             }
 
     def __init__(self, resultset):
diff --git a/src/jarabe/journal/thumbsview.py b/src/jarabe/journal/thumbsview.py
index add29c7..0379d75 100644
--- a/src/jarabe/journal/thumbsview.py
+++ b/src/jarabe/journal/thumbsview.py
@@ -14,9 +14,7 @@
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
-import gtk
 import gobject
-import logging
 import hippo
 
 from sugar.graphics import style
@@ -36,7 +34,9 @@ ROWS = 4
 COLUMNS = 5
 STAR_WIDTH = 30
 
+
 class ThumbsCell(TableCell, hippo.CanvasBox):
+
     def __init__(self):
         TableCell.__init__(self)
 
@@ -123,7 +123,7 @@ class ThumbsCell(TableCell, hippo.CanvasBox):
         thumb = self.row[Source.FIELD_THUMB]
 
         if self._last_uid == self.row[Source.FIELD_UID] and \
-                not self.row.has_key(ObjectModel.FIELD_FETCHED_FLAG):
+                not ObjectModel.FIELD_FETCHED_FLAG in self.row:
             # do not blink by preview while re-reading entries
             return
         else:
@@ -153,13 +153,17 @@ class ThumbsCell(TableCell, hippo.CanvasBox):
     def __detail_clicked_cb(self, sender, uid):
         self.tree.emit('detail-clicked', uid)
 
+
 class ActivityCanvas:
+
     def __init__(self):
         self._metadata = None
         self.connect_after('button-release-event',
                 self.__button_release_event_cb)
+        self.palette = None
 
     def set_metadata(self, metadata):
+        # pylint: disable-msg=W0201
         self.palette = None
         self._metadata = metadata
 
@@ -173,11 +177,13 @@ class ActivityCanvas:
     def __detail_clicked_cb(self, palette, uid):
         self.emit('detail-clicked', uid)
 
-    def __button_release_event_cb(self, button, foo):
+    def __button_release_event_cb(self, button, event):
         misc.resume(self._metadata)
         return True
 
+
 class ActivityIcon(ActivityCanvas, CanvasIcon):
+
     __gsignals__ = {
             'detail-clicked': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
                               ([str])),
@@ -196,10 +202,12 @@ class ActivityIcon(ActivityCanvas, CanvasIcon):
             self.props.fill_color = style.COLOR_TRANSPARENT.get_svg()
             self.props.stroke_color = style.COLOR_BUTTON_GREY.get_svg()
         else:
-            if metadata.has_key('icon-color') and metadata['icon-color']:
+            if 'icon-color' in metadata and metadata['icon-color']:
                 self.props.xo_color = XoColor(self._metadata['icon-color'])
 
+
 class ThumbCanvas(ActivityCanvas, hippo.CanvasImage):
+
     __gsignals__ = {
             'detail-clicked': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
                               ([str])),
@@ -217,7 +225,9 @@ class ThumbCanvas(ActivityCanvas, hippo.CanvasImage):
         if self._palette_invoker is not None:
             self._palette_invoker.detach()
 
+
 class DetailsIcon(CanvasIcon):
+
     def __init__(self, **kwargs):
         CanvasIcon.__init__(self, **kwargs)
         self.props.icon_name = 'go-right'
@@ -231,7 +241,9 @@ class DetailsIcon(CanvasIcon):
         elif event.detail == hippo.MOTION_DETAIL_LEAVE:
             icon.props.fill_color = style.COLOR_BUTTON_GREY.get_svg()
 
+
 class ThumbsView(TableView):
+
     __gsignals__ = {
             'detail-clicked': (gobject.SIGNAL_RUN_FIRST,
                               gobject.TYPE_NONE,