Pep8 fixes

11 files changed, 161 insertions, 158 deletions

diff --git a/bookmarkview.py b/bookmarkview.py
index a5adc5d..8ae6d4b 100644
--- a/bookmarkview.py
+++ b/bookmarkview.py
@@ -42,13 +42,13 @@ class BookmarkView(Gtk.EventBox):
 
     __gsignals__ = {
         'bookmark-changed': (GObject.SignalFlags.RUN_FIRST, GObject.TYPE_NONE,
-                              ([])),
+                             ([])),
     }
 
     def __init__(self):
         Gtk.EventBox.__init__(self)
         self.set_size_request(style.GRID_CELL_SIZE,
-                style.GRID_CELL_SIZE * 2)
+                              style.GRID_CELL_SIZE * 2)
         self._xo_color = profile.get_color()
         self._fill_color = style.Color(self._xo_color.get_fill_color())
         self._stroke_color = style.Color(self._xo_color.get_stroke_color())
@@ -85,11 +85,12 @@ class BookmarkView(Gtk.EventBox):
     def _add_bookmark_icon(self, bookmark):
         xocolor = XoColor(str(bookmark.color))
         self._bookmark_icon = Icon(icon_name='emblem-favorite',
-                xo_color=xocolor, icon_size=Gtk.IconSize.LARGE_TOOLBAR)
+                                   xo_color=xocolor,
+                                   icon_size=Gtk.IconSize.LARGE_TOOLBAR)
 
         self._box.props.has_tooltip = True
-        self.__box_query_tooltip_cb_id = self._box.connect('query_tooltip',
-            self.__bookmark_icon_query_tooltip_cb, bookmark)
+        self.__box_query_tooltip_cb_id = self._box.connect(
+            'query_tooltip', self.__bookmark_icon_query_tooltip_cb, bookmark)
 
         self.__event_cb_id = \
             self.connect('event', self.__event_cb, bookmark)
@@ -101,15 +102,16 @@ class BookmarkView(Gtk.EventBox):
             self._is_showing_local_bookmark = True
 
     def __bookmark_icon_query_tooltip_cb(self, widget, x, y, keyboard_mode,
-            tip, bookmark):
+                                         tip, bookmark):
         tooltip_header = bookmark.get_note_title()
         tooltip_body = bookmark.get_note_body()
         time = timestamp_to_elapsed_string(bookmark.timestamp)
         #TRANS: This goes like Bookmark added by User 5 days ago
         #TRANS: (the elapsed string gets translated automatically)
-        tooltip_footer = (_('Bookmark added by %(user)s %(time)s') \
-                % {'user': bookmark.nick.decode('utf-8'),
-                'time': time.decode('utf-8')})
+        tooltip_footer = (
+            _('Bookmark added by %(user)s %(time)s')
+            % {'user': bookmark.nick.decode('utf-8'),
+               'time': time.decode('utf-8')})
 
         vbox = Gtk.VBox()
 
@@ -143,7 +145,7 @@ class BookmarkView(Gtk.EventBox):
 
     def __event_cb(self, widget, event, bookmark):
         if event.type == Gdk.EventType.BUTTON_PRESS and \
-                    self._bookmark_icon is not None:
+                self._bookmark_icon is not None:
 
             bookmark_title = bookmark.get_note_title()
             bookmark_content = bookmark.get_note_body()
diff --git a/epubadapter.py b/epubadapter.py
index e412675..a4ff627 100644
--- a/epubadapter.py
+++ b/epubadapter.py
@@ -18,7 +18,7 @@ class EpubViewer(epubview.EpubView):
     def setup(self, activity):
         self.set_screen_dpi(activity.dpi)
         self.connect('selection-changed',
-                            activity._view_selection_changed_cb)
+                     activity._view_selection_changed_cb)
 
         activity._hbox.pack_start(self, True, True, 0)
         self.show_all()
@@ -82,8 +82,8 @@ class EpubViewer(epubview.EpubView):
         if end_range > len(self.word_tuples):
             end_range = len(self.word_tuples)
         for word_tuple in self.word_tuples[self.current_word:end_range]:
-            file_str.write('<mark name="' + str(i) + '"/>' + \
-                    word_tuple[2].encode('utf-8'))
+            file_str.write('<mark name="' + str(i) + '"/>' +
+                           word_tuple[2].encode('utf-8'))
             i = i + 1
         self.current_word = i
         file_str.write('</speak>')
@@ -114,7 +114,7 @@ class EpubViewer(epubview.EpubView):
     def connect_zoom_handler(self, handler):
         self._zoom_handler = handler
         self._view_notify_zoom_handler = \
-                self.connect('notify::scale', handler)
+            self.connect('notify::scale', handler)
         return self._view_notify_zoom_handler
 
     def connect_page_changed_handler(self, handler):
@@ -167,7 +167,7 @@ class EpubViewer(epubview.EpubView):
 
         while link_iter is not None and \
                 self._epub.get_links_model().get_value(link_iter, 1) \
-                        != current_link:
+                != current_link:
             link_iter = self._epub.get_links_model().iter_next(link_iter)
         return link_iter
 
@@ -179,10 +179,10 @@ class EpubViewer(epubview.EpubView):
 
     def setup_find_job(self, text, updated_cb):
         self._find_job = JobFind(document=self._epub,
-                start_page=0, n_pages=self.get_pagecount(),
-                text=text, case_sensitive=False)
+                                 start_page=0, n_pages=self.get_pagecount(),
+                                 text=text, case_sensitive=False)
         self._find_updated_handler = self._find_job.connect('updated',
-                updated_cb)
+                                                            updated_cb)
         return self._find_job, self._find_updated_handler
 
 
@@ -205,6 +205,6 @@ class EpubDocument(epubview.Epub):
 class JobFind(epubview.JobFind):
 
     def __init__(self, document, start_page, n_pages, text,
-            case_sensitive=False):
+                 case_sensitive=False):
         epubview.JobFind.__init__(self, document, start_page, n_pages, text,
-            case_sensitive=False)
+                                  case_sensitive=False)
diff --git a/evinceadapter.py b/evinceadapter.py
index 31859d9..94c9166 100644
--- a/evinceadapter.py
+++ b/evinceadapter.py
@@ -27,19 +27,19 @@ class EvinceViewer():
     def setup(self, activity):
         self._activity = activity
         self._view.connect('selection-changed',
-                            activity._view_selection_changed_cb)
+                           activity._view_selection_changed_cb)
         self._view.connect('external-link', self.__handle_link_cb)
 
         activity._scrolled = Gtk.ScrolledWindow()
         activity._scrolled.set_policy(Gtk.PolicyType.AUTOMATIC,
-                Gtk.PolicyType.AUTOMATIC)
+                                      Gtk.PolicyType.AUTOMATIC)
         activity._scrolled.props.shadow_type = Gtk.ShadowType.NONE
 
         activity._scrolled.add(self._view)
         self._view.show()
 
         self._view.set_events(self._view.get_events() |
-                Gdk.EventMask.TOUCH_MASK)
+                              Gdk.EventMask.TOUCH_MASK)
         self._view.connect('event', self.__view_touch_event_cb)
 
         activity._hbox.pack_start(activity._scrolled, True, True, 0)
@@ -50,7 +50,7 @@ class EvinceViewer():
     def load_document(self, file_path):
         try:
             self._document = \
-                    EvinceDocument.Document.factory_get_document(file_path)
+                EvinceDocument.Document.factory_get_document(file_path)
         except GObject.GError, e:
             _logger.error('Can not load document: %s', e)
             return
@@ -88,12 +88,12 @@ class EvinceViewer():
             'title': "%s: %s" % (_('URL from Read'), url),
             'title_set_by_user': '1',
             'icon-color': profile.get_color().to_string(),
-            'mime_type': 'text/uri-list',
-            }
+            'mime_type': 'text/uri-list', }
+
         for k, v in metadata.items():
             jobject.metadata[k] = v
         file_path = os.path.join(get_activity_root(),
-                'instance', '%i_' % time.time())
+                                 'instance', '%i_' % time.time())
         open(file_path, 'w').write(url + '\r\n')
         os.chmod(file_path, 0755)
         jobject.set_file_path(file_path)
@@ -253,19 +253,19 @@ class EvinceViewer():
     def connect_zoom_handler(self, handler):
         self._zoom_handler = handler
         self._view_notify_zoom_handler = \
-                self._model.connect('notify::scale', handler)
+            self._model.connect('notify::scale', handler)
         return self._view_notify_zoom_handler
 
     def setup_find_job(self, text, updated_cb):
-        self._find_job = EvinceView.JobFind.new(document=self._document,
-                start_page=0,
-                n_pages=self._document.get_n_pages(),
-                text=text, case_sensitive=False)
+        self._find_job = EvinceView.JobFind.new(
+            document=self._document, start_page=0,
+            n_pages=self._document.get_n_pages(),
+            text=text, case_sensitive=False)
         self._find_updated_handler = self._find_job.connect('updated',
-                updated_cb)
+                                                            updated_cb)
         self._view.find_started(self._find_job)
-        EvinceView.Job.scheduler_push_job(self._find_job,
-                EvinceView.JobPriority.PRIORITY_NONE)
+        EvinceView.Job.scheduler_push_job(
+            self._find_job, EvinceView.JobPriority.PRIORITY_NONE)
         return self._find_job, self._find_updated_handler
 
     def connect_page_changed_handler(self, handler):
@@ -281,9 +281,10 @@ class EvinceViewer():
             else:
                 self._job_links = EvinceView.JobLinks.new(document=doc)
                 self._job_links.connect('finished', self.__index_loaded_cb,
-                        activity)
-                EvinceView.Job.scheduler_push_job(self._job_links,
-                        EvinceView.JobPriority.PRIORITY_NONE)
+                                        activity)
+                EvinceView.Job.scheduler_push_job(
+                    self._job_links,
+                    EvinceView.JobPriority.PRIORITY_NONE)
                 return True
         else:
             return False
@@ -296,7 +297,8 @@ class EvinceViewer():
         Check if Evince version is at major or equal than the requested
         """
         evince_version = [EvinceDocument.MAJOR_VERSION,
-                EvinceDocument.MINOR_VERSION, EvinceDocument.MICRO_VERSION]
+                          EvinceDocument.MINOR_VERSION,
+                          EvinceDocument.MICRO_VERSION]
         return evince_version >= [major, minor, micro]
 
     def __index_loaded_cb(self, job, activity):
diff --git a/linkbutton.py b/linkbutton.py
index 075fdb3..037a58c 100644
--- a/linkbutton.py
+++ b/linkbutton.py
@@ -40,8 +40,7 @@ class LinkButton(TrayButton, GObject.GObject):
         'remove_link': (GObject.SignalFlags.RUN_FIRST,
                         None, ([int])),
         'go_to_bookmark': (GObject.SignalFlags.RUN_FIRST,
-                        None, ([int])),
-        }
+                           None, ([int])), }
 
     def __init__(self, buf, color, title, owner, page):
         TrayButton.__init__(self)
@@ -67,7 +66,7 @@ class LinkButton(TrayButton, GObject.GObject):
 
         bg_width, bg_height = style.zoom(120), style.zoom(110)
         bg_surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, bg_width,
-                bg_height)
+                                        bg_height)
         context = cairo.Context(bg_surface)
         # draw a rectangle in the background with the selected colors
         context.set_line_width(style.zoom(10))
diff --git a/readdb.py b/readdb.py
index 1df587f..f39a42f 100644
--- a/readdb.py
+++ b/readdb.py
@@ -56,7 +56,8 @@ def _init_db():
         shutil.copy(olddbpath, dbpath)
 
         conn = sqlite3.connect(dbpath)
-        conn.execute("CREATE TABLE  temp_bookmarks  AS SELECT md5, page, " + \
+        conn.execute(
+            "CREATE TABLE  temp_bookmarks  AS SELECT md5, page, " +
             "title 'content', timestamp, user, color, local  FROM bookmarks")
         conn.execute("ALTER TABLE bookmarks RENAME TO bookmarks_old")
         conn.execute("ALTER TABLE temp_bookmarks RENAME TO bookmarks")
@@ -72,15 +73,15 @@ def _init_db():
 
 def _init_db_highlights(conn):
     conn.execute('CREATE TABLE IF NOT EXISTS HIGHLIGHTS ' +
-                '(md5 TEXT, page INTEGER, ' +
-                'init_pos INTEGER, end_pos INTEGER)')
+                 '(md5 TEXT, page INTEGER, ' +
+                 'init_pos INTEGER, end_pos INTEGER)')
     conn.commit()
 
 
 def _init_db_previews(conn):
     conn.execute('CREATE TABLE IF NOT EXISTS PREVIEWS ' +
-                '(md5 TEXT, page INTEGER, ' +
-                'preview)')
+                 '(md5 TEXT, page INTEGER, ' +
+                 'preview)')
     conn.commit()
 
 
@@ -88,10 +89,9 @@ class BookmarkManager(GObject.GObject):
 
     __gsignals__ = {
         'added_bookmark': (GObject.SignalFlags.RUN_FIRST,
-                     None, ([int])),
+                           None, ([int])),
         'removed_bookmark': (GObject.SignalFlags.RUN_FIRST,
-                     None, ([int])),
-        }
+                             None, ([int])), }
 
     def __init__(self, filehash):
         GObject.GObject.__init__(self)
@@ -99,7 +99,7 @@ class BookmarkManager(GObject.GObject):
 
         dbpath = _init_db()
 
-        assert dbpath != None
+        assert dbpath is not None
 
         self._conn = sqlite3.connect(dbpath)
         _init_db_highlights(self._conn)
@@ -120,10 +120,10 @@ class BookmarkManager(GObject.GObject):
         # locale = 0 means that this is a bookmark originally
         # created by the person who originally shared the file
         timestamp = time.time()
-        t = (self._filehash, page, content, timestamp, self._user, \
-                self._color, local)
-        self._conn.execute('insert into bookmarks values ' + \
-                '(?, ?, ?, ?, ?, ?, ?)', t)
+        t = (self._filehash, page, content, timestamp, self._user,
+             self._color, local)
+        self._conn.execute('insert into bookmarks values ' +
+                           '(?, ?, ?, ?, ?, ?, ?)', t)
         self._conn.commit()
 
         self._resync_bookmark_cache()
@@ -133,8 +133,8 @@ class BookmarkManager(GObject.GObject):
         # We delete only the locally made bookmark
         logging.debug('del_bookmark page %d', page)
         t = (self._filehash, page, self._user)
-        self._conn.execute('delete from bookmarks ' + \
-                'where md5=? and page=? and user=?', t)
+        self._conn.execute('delete from bookmarks ' +
+                           'where md5=? and page=? and user=?', t)
         self._conn.commit()
         self._del_bookmark_preview(page)
         self._resync_bookmark_cache()
@@ -143,21 +143,22 @@ class BookmarkManager(GObject.GObject):
     def add_bookmark_preview(self, page, preview):
         logging.debug('add_bookmark_preview page %d', page)
         t = (self._filehash, page, base64.b64encode(preview))
-        self._conn.execute('insert into previews values ' + \
-                '(?, ?, ?)', t)
+        self._conn.execute('insert into previews values ' +
+                           '(?, ?, ?)', t)
         self._conn.commit()
 
     def _del_bookmark_preview(self, page):
         logging.debug('del_bookmark_preview page %d', page)
         t = (self._filehash, page)
-        self._conn.execute('delete from previews ' + \
-                'where md5=? and page=?', t)
+        self._conn.execute('delete from previews ' +
+                           'where md5=? and page=?', t)
         self._conn.commit()
 
     def get_bookmark_preview(self, page):
         logging.debug('get_bookmark page %d', page)
-        rows = self._conn.execute('select preview from previews ' + \
-            'where md5=? and page=?', (self._filehash, page))
+        rows = self._conn.execute('select preview from previews ' +
+                                  'where md5=? and page=?',
+                                  (self._filehash, page))
         for row in rows:
             return base64.b64decode(row[0])
         return None
@@ -165,8 +166,9 @@ class BookmarkManager(GObject.GObject):
     def _populate_bookmarks(self):
         # TODO: Figure out if caching the entire set of bookmarks
         # is a good idea or not
-        rows = self._conn.execute('select * from bookmarks ' + \
-            'where md5=? order by page', (self._filehash, ))
+        rows = self._conn.execute('select * from bookmarks ' +
+                                  'where md5=? order by page',
+                                  (self._filehash, ))
 
         for row in rows:
             self._bookmarks.append(Bookmark(row))
@@ -227,24 +229,24 @@ class BookmarkManager(GObject.GObject):
         logging.error('Adding hg page %d %s' % (page, highlight_tuple))
         self.get_highlights(page).append(highlight_tuple)
 
-        t = (self._filehash, page, highlight_tuple[0],
-                highlight_tuple[1])
-        self._conn.execute('insert into highlights values ' + \
-                '(?, ?, ?, ?)', t)
+        t = (self._filehash, page, highlight_tuple[0], highlight_tuple[1])
+        self._conn.execute('insert into highlights values ' +
+                           '(?, ?, ?, ?)', t)
         self._conn.commit()
 
     def del_highlight(self, page, highlight_tuple):
         self._highlights[page].remove(highlight_tuple)
-        t = (self._filehash, page, highlight_tuple[0], \
-                highlight_tuple[1])
-        self._conn.execute('delete from highlights ' + \
-            'where md5=? and page=? and init_pos=? and end_pos=?', \
-            t)
+        t = (self._filehash, page, highlight_tuple[0],
+             highlight_tuple[1])
+        self._conn.execute(
+            'delete from highlights ' +
+            'where md5=? and page=? and init_pos=? and end_pos=?', t)
         self._conn.commit()
 
     def _populate_highlights(self):
-        rows = self._conn.execute('select * from highlights ' + \
-            'where md5=? order by page', (self._filehash, ))
+        rows = self._conn.execute('select * from highlights ' +
+                                  'where md5=? order by page',
+                                  (self._filehash, ))
         for row in rows:
             # md5 = row[0]
             page = row[1]
diff --git a/readdialog.py b/readdialog.py
index c479e7d..e1680e5 100644
--- a/readdialog.py
+++ b/readdialog.py
@@ -80,15 +80,15 @@ class BaseReadDialog(Gtk.Window):
         self.get_window().set_transient_for(self._parent_window_xid)
 
         self.modify_bg(Gtk.StateType.NORMAL,
-                            style.COLOR_WHITE.get_gdk_color())
+                       style.COLOR_WHITE.get_gdk_color())
 
         if self._canvas is not None:
             self._canvas.modify_bg(Gtk.StateType.NORMAL,
-                style.COLOR_WHITE.get_gdk_color())
+                                   style.COLOR_WHITE.get_gdk_color())
             self._canvas.grab_focus()
 
         self._event_box.modify_bg(Gtk.StateType.NORMAL,
-                style.COLOR_WHITE.get_gdk_color())
+                                  style.COLOR_WHITE.get_gdk_color())
 
     def accept_clicked_cb(self, widget):
         raise NotImplementedError
@@ -100,7 +100,7 @@ class BaseReadDialog(Gtk.Window):
 class BookmarkDialog(BaseReadDialog):
 
     def __init__(self, parent_xid, dialog_title, bookmark_title,
-            bookmark_content, page, sidebarinstance):
+                 bookmark_content, page, sidebarinstance):
         BaseReadDialog.__init__(self, parent_xid, dialog_title)
 
         self._sidebarinstance = sidebarinstance
@@ -117,15 +117,15 @@ class BookmarkDialog(BaseReadDialog):
         label_title.set_use_markup(True)
         label_title.set_alignment(1, 0.5)
         label_title.modify_fg(Gtk.StateType.NORMAL,
-                            style.COLOR_SELECTION_GREY.get_gdk_color())
+                              style.COLOR_SELECTION_GREY.get_gdk_color())
         thbox.pack_start(label_title, False, False, 0)
         label_title.show()
 
         self._title_entry = Gtk.Entry()
         self._title_entry.modify_bg(Gtk.StateType.INSENSITIVE,
-                            style.COLOR_WHITE.get_gdk_color())
+                                    style.COLOR_WHITE.get_gdk_color())
         self._title_entry.modify_base(Gtk.StateType.INSENSITIVE,
-                            style.COLOR_WHITE.get_gdk_color())
+                                      style.COLOR_WHITE.get_gdk_color())
         self._title_entry.set_size_request(int(Gdk.Screen.width() / 3), -1)
 
         thbox.pack_start(self._title_entry, False, False, 0)
@@ -143,7 +143,7 @@ class BookmarkDialog(BaseReadDialog):
         label_content.set_use_markup(True)
         label_content.set_alignment(0, 0)
         label_content.modify_fg(Gtk.StateType.NORMAL,
-                            style.COLOR_SELECTION_GREY.get_gdk_color())
+                                style.COLOR_SELECTION_GREY.get_gdk_color())
         cvbox.pack_start(label_content, False, False, 0)
         label_content.show()
 
@@ -172,17 +172,17 @@ class BookmarkDialog(BaseReadDialog):
 class BookmarkAddDialog(BookmarkDialog):
 
     def __init__(self, parent_xid, dialog_title, bookmark_title,
-            bookmark_content, page, sidebarinstance):
+                 bookmark_content, page, sidebarinstance):
         BookmarkDialog.__init__(self, parent_xid, dialog_title, bookmark_title,
-            bookmark_content, page, sidebarinstance)
+                                bookmark_content, page, sidebarinstance)
 
     def accept_clicked_cb(self, widget):
         title = self._title_entry.get_text()
         details = self._content_entry.get_buffer().props.text
         content = {'title': title.decode('utf-8'),
-                'body': details.decode('utf-8')}
+                   'body': details.decode('utf-8')}
         self._sidebarinstance._real_add_bookmark(self._page,
-                json.dumps(content))
+                                                 json.dumps(content))
         self.destroy()
 
     def cancel_clicked_cb(self, widget):
@@ -193,16 +193,16 @@ class BookmarkAddDialog(BookmarkDialog):
 class BookmarkEditDialog(BookmarkDialog):
 
     def __init__(self, parent_xid, dialog_title, bookmark_title,
-            bookmark_content, page, sidebarinstance):
+                 bookmark_content, page, sidebarinstance):
         BookmarkDialog.__init__(self, parent_xid, dialog_title, bookmark_title,
-            bookmark_content, page, sidebarinstance)
+                                bookmark_content, page, sidebarinstance)
 
     def accept_clicked_cb(self, widget):
         title = self._title_entry.get_text()
         details = self._content_entry.get_buffer().props.text
         content = {'title': title.decode('utf-8'),
-                'body': details.decode('utf-8')}
+                   'body': details.decode('utf-8')}
         self._sidebarinstance.del_bookmark(self._page)
         self._sidebarinstance._real_add_bookmark(self._page,
-                json.dumps(content))
+                                                 json.dumps(content))
         self.destroy()
diff --git a/readtoolbar.py b/readtoolbar.py
index 02170af..c2e6aee 100644
--- a/readtoolbar.py
+++ b/readtoolbar.py
@@ -42,7 +42,7 @@ class EditToolbar(BaseEditToolbar):
 
         self._search_entry = iconentry.IconEntry()
         self._search_entry.set_icon_from_name(iconentry.ICON_ENTRY_PRIMARY,
-                                                'entry-search')
+                                              'entry-search')
         self._search_entry.add_clear_button()
         self._search_entry.connect('activate', self._search_entry_activate_cb)
         self._search_entry.connect('changed', self._search_entry_changed_cb)
@@ -97,7 +97,7 @@ class EditToolbar(BaseEditToolbar):
         text = self._search_entry.props.text
         if text != "":
             self._find_job, self._find_updated_handler = \
-                        self._view.setup_find_job(text, self._find_updated_cb)
+                self._view.setup_find_job(text, self._find_updated_cb)
         else:
             # FIXME: highlight nothing
             pass
@@ -173,12 +173,11 @@ class ViewToolbar(Gtk.Toolbar):
 
     __gsignals__ = {
         'go-fullscreen': (GObject.SignalFlags.RUN_FIRST, GObject.TYPE_NONE,
-                ([])),
+                          ([])),
         'toggle-index-show': (GObject.SignalFlags.RUN_FIRST, GObject.TYPE_NONE,
-                ([bool])),
+                              ([bool])),
         'toggle-tray-show': (GObject.SignalFlags.RUN_FIRST, GObject.TYPE_NONE,
-                ([bool])),
-    }
+                             ([bool])), }
 
     def __init__(self):
         Gtk.Toolbar.__init__(self)
diff --git a/speech_dispatcher.py b/speech_dispatcher.py
index 77dafb3..00e12c8 100644
--- a/speech_dispatcher.py
+++ b/speech_dispatcher.py
@@ -82,14 +82,14 @@ class EspeakThread(threading.Thread):
         try:
             self.client = speechd.SSIPClient('readetexts')
             self.client._conn.send_command('SET', speechd.Scope.SELF,
-                    'SSML_MODE', "ON")
+                                           'SSML_MODE', "ON")
             if speech.voice:
                 self.client.set_language(speech.voice[1])
                 self.client.set_rate(speech.rate)
                 self.client.set_pitch(speech.pitch)
             self.client.speak(self.words, self.next_word_cb,
-                    (speechd.CallbackType.INDEX_MARK,
-                    speechd.CallbackType.END))
+                              (speechd.CallbackType.INDEX_MARK,
+                               speechd.CallbackType.END))
             global done
             done = False
             while not done:
diff --git a/speech_gst.py b/speech_gst.py
index 69fa9a8..df3bde9 100644
--- a/speech_gst.py
+++ b/speech_gst.py
@@ -36,7 +36,7 @@ def get_all_voices():
 def _message_cb(bus, message, pipe):
     if message.type == Gst.MessageType.EOS:
         pipe.set_state(Gst.State.NULL)
-        if speech.end_text_cb != None:
+        if speech.end_text_cb is not None:
             speech.end_text_cb()
     if message.type == Gst.MessageType.ERROR:
         pipe.set_state(Gst.State.NULL)
diff --git a/speechtoolbar.py b/speechtoolbar.py
index d6444d3..63acfda 100644
--- a/speechtoolbar.py
+++ b/speechtoolbar.py
@@ -101,13 +101,13 @@ class SpeechToolbar(Gtk.Toolbar):
                 f.close()
 
         self._cnf_client.add_dir('/desktop/sugar/speech',
-                GConf.ClientPreloadType.PRELOAD_NONE)
+                                 GConf.ClientPreloadType.PRELOAD_NONE)
         speech.pitch = self._cnf_client.get_int('/desktop/sugar/speech/pitch')
         speech.rate = self._cnf_client.get_int('/desktop/sugar/speech/rate')
-        self._cnf_client.notify_add('/desktop/sugar/speech/pitch', \
-                self.__conf_changed_cb, None)
-        self._cnf_client.notify_add('/desktop/sugar/speech/rate', \
-                self.__conf_changed_cb, None)
+        self._cnf_client.notify_add('/desktop/sugar/speech/pitch',
+                                    self.__conf_changed_cb, None)
+        self._cnf_client.notify_add('/desktop/sugar/speech/rate',
+                                    self.__conf_changed_cb, None)
 
     def __conf_changed_cb(self, client, connection_id, entry, args):
         key = entry.get_key()
diff --git a/textadapter.py b/textadapter.py
index c6ded43..f1a504f 100644
--- a/textadapter.py
+++ b/textadapter.py
@@ -28,12 +28,11 @@ class TextViewer(GObject.GObject):
 
     __gsignals__ = {
         'zoom-changed': (GObject.SignalFlags.RUN_FIRST, GObject.TYPE_NONE,
-                ([int])),
+                         ([int])),
         'page-changed': (GObject.SignalFlags.RUN_FIRST, GObject.TYPE_NONE,
-                ([int, int])),
+                         ([int, int])),
         'selection-changed': (GObject.SignalFlags.RUN_FIRST, GObject.TYPE_NONE,
-                              ([])),
-    }
+                              ([])), }
 
     def setup(self, activity):
         self._activity = activity
@@ -48,25 +47,25 @@ class TextViewer(GObject.GObject):
         self.textview.set_right_margin(50)
         self.textview.set_justification(Gtk.Justification.FILL)
         self.textview.set_wrap_mode(Gtk.WrapMode.WORD)
-        self.textview.connect('button-release-event', \
-                self._view_buttonrelease_event_cb)
+        self.textview.connect('button-release-event',
+                              self._view_buttonrelease_event_cb)
         self.connect('selection-changed',
-                            activity._view_selection_changed_cb)
+                     activity._view_selection_changed_cb)
 
-        self.textview.set_events(self.textview.get_events() | \
-                Gdk.EventMask.TOUCH_MASK)
+        self.textview.set_events(self.textview.get_events() |
+                                 Gdk.EventMask.TOUCH_MASK)
         self.textview.connect('event', self.__touch_event_cb)
 
         self._sw = Gtk.ScrolledWindow()
         self._sw.add(self.textview)
         self._v_vscrollbar = self._sw.get_vscrollbar()
         self._v_scrollbar_value_changed_cb_id = \
-                self._v_vscrollbar.connect('value-changed', \
-                self._v_scrollbar_value_changed_cb)
+            self._v_vscrollbar.connect('value-changed',
+                                       self._v_scrollbar_value_changed_cb)
         self._scrollbar = Gtk.VScrollbar()
         self._scrollbar_change_value_cb_id = \
-                self._scrollbar.connect('change-value', \
-                self._scrollbar_change_value_cb)
+            self._scrollbar.connect('change-value',
+                                    self._scrollbar_change_value_cb)
 
         overlay = Gtk.Overlay()
         hbox = Gtk.HBox()
@@ -109,7 +108,7 @@ class TextViewer(GObject.GObject):
             self.zf = zipfile.ZipFile(file_path.replace('file://', ''), 'r')
             self.book_files = self.zf.namelist()
             extract_path = os.path.join(self._activity.get_activity_root(),
-                    'instance')
+                                        'instance')
             for book_file in self.book_files:
                 if (book_file != 'annotations.pkl'):
                     self.zf.extract(book_file, extract_path)
@@ -169,12 +168,12 @@ class TextViewer(GObject.GObject):
         scroll_upper = self._v_vscrollbar.props.adjustment.props.upper
         scroll_page_size = self._v_vscrollbar.props.adjustment.props.page_size
 
-        if self.__going_fwd == True and \
-            not self._current_page == self._pagecount:
+        if self.__going_fwd and \
+                not self._current_page == self._pagecount:
 
             if scrollval == scroll_upper:
                 self.set_current_page(self._current_page + 1)
-        elif self.__going_back == True and self._current_page > 1:
+        elif self.__going_back and self._current_page > 1:
             if scrollval == 0.0:
                 self.set_current_page(self._current_page - 1)
 
@@ -190,7 +189,7 @@ class TextViewer(GObject.GObject):
             self.__going_fwd = False
             self.__going_back = True
         elif scrolltype == Gtk.ScrollType.JUMP or \
-            scrolltype == Gtk.ScrollType.PAGE_FORWARD or \
+                scrolltype == Gtk.ScrollType.PAGE_FORWARD or \
                 scrolltype == Gtk.ScrollType.PAGE_BACKWARD:
             if value > self._scrollbar.props.adjustment.props.upper:
                 value = self._pagecount
@@ -199,7 +198,7 @@ class TextViewer(GObject.GObject):
             self.emit('page-changed', old_page, self._current_page)
         else:
             print 'Warning: unknown scrolltype %s with value %f' \
-                    % (str(scrolltype), value)
+                % (str(scrolltype), value)
 
         #FIXME: This should not be needed here
         self._scrollbar.set_value(self._current_page)
@@ -225,8 +224,8 @@ class TextViewer(GObject.GObject):
 
     def get_cursor_position(self):
         insert_mark = self.textview.get_buffer().get_insert()
-        return self.textview.get_buffer().get_iter_at_mark( \
-                insert_mark).get_offset()
+        return self.textview.get_buffer().get_iter_at_mark(
+            insert_mark).get_offset()
 
     def show_highlights(self, tuples_list):
         textbuffer = self.textview.get_buffer()
@@ -250,7 +249,7 @@ class TextViewer(GObject.GObject):
         while i < len(self.word_tuples):
             word_tuple = self.word_tuples[i]
             marked_up_text = marked_up_text + '<mark name="' + str(i) + '"/>' \
-                    + word_tuple[2]
+                + word_tuple[2]
             i = i + 1
         print marked_up_text
         return marked_up_text + '</speak>'
@@ -264,7 +263,7 @@ class TextViewer(GObject.GObject):
         word_begin = 0
         word_end = 0
         ignore_chars = [' ',  '\n',  u'\r',  '_',  '[', '{', ']', '}', '|',
-                '<',  '>',  '*',  '+',  '/',  '\\']
+                        '<',  '>',  '*',  '+',  '/',  '\\']
         ignore_set = set(ignore_chars)
         self.word_tuples = []
         len_page_text = len(page_text)
@@ -272,12 +271,12 @@ class TextViewer(GObject.GObject):
             if page_text[i] not in ignore_set:
                 word_begin = i
                 j = i
-                while  j < len_page_text and page_text[j] not in ignore_set:
+                while j < len_page_text and page_text[j] not in ignore_set:
                     j = j + 1
                     word_end = j
                     i = j
                 word_tuple = (word_begin, word_end,
-                        page_text[word_begin: word_end])
+                              page_text[word_begin: word_end])
                 if word_tuple[2] != u'\r':
                     self.word_tuples.append(word_tuple)
             i = i + 1
@@ -326,19 +325,19 @@ class TextViewer(GObject.GObject):
         v_adjustment = self._sw.get_vadjustment()
         v_value = v_adjustment.get_value()
         if scrolltype in (Gtk.ScrollType.PAGE_BACKWARD,
-                Gtk.ScrollType.PAGE_FORWARD):
+                          Gtk.ScrollType.PAGE_FORWARD):
             step = v_adjustment.get_page_increment()
         else:
             step = v_adjustment.get_step_increment()
 
         if scrolltype in (Gtk.ScrollType.PAGE_BACKWARD,
-                Gtk.ScrollType.STEP_BACKWARD):
+                          Gtk.ScrollType.STEP_BACKWARD):
             self.__going_fwd = False
             self.__going_back = True
             if v_value <= v_adjustment.get_lower():
                 self.previous_page()
-                v_adjustment.set_value(v_adjustment.get_upper() - \
-                        v_adjustment.get_page_size())
+                v_adjustment.set_value(v_adjustment.get_upper() -
+                                       v_adjustment.get_page_size())
                 return
             if v_value > v_adjustment.get_lower():
                 new_value = v_value - step
@@ -346,21 +345,21 @@ class TextViewer(GObject.GObject):
                     new_value = v_adjustment.get_lower()
                 v_adjustment.set_value(new_value)
         elif scrolltype in (Gtk.ScrollType.PAGE_FORWARD,
-                Gtk.ScrollType.STEP_FORWARD):
+                            Gtk.ScrollType.STEP_FORWARD):
             self.__going_fwd = True
             self.__going_back = False
 
             if v_value >= v_adjustment.get_upper() - \
-                                                v_adjustment.get_page_size():
+                    v_adjustment.get_page_size():
                 self.next_page()
                 return
             if v_value < v_adjustment.get_upper() - \
-                                                v_adjustment.get_page_size():
+                    v_adjustment.get_page_size():
                 new_value = v_value + step
                 if new_value > v_adjustment.get_upper() - \
-                                                v_adjustment.get_page_size():
+                        v_adjustment.get_page_size():
                     new_value = v_adjustment.get_upper() - \
-                            v_adjustment.get_page_size()
+                        v_adjustment.get_page_size()
                 v_adjustment.set_value(new_value)
         elif scrolltype == Gtk.ScrollType.START:
             self.set_current_page(0)
@@ -370,7 +369,7 @@ class TextViewer(GObject.GObject):
     def previous_page(self):
         v_adjustment = self._sw.get_vadjustment()
         v_adjustment.set_value(v_adjustment.get_upper() -
-                v_adjustment.get_page_size())
+                               v_adjustment.get_page_size())
         self.set_current_page(self.get_current_page() - 1)
 
     def next_page(self):
@@ -398,7 +397,7 @@ class TextViewer(GObject.GObject):
 
     def _view_buttonrelease_event_cb(self, view, event):
         self._has_selection = \
-                self.textview.get_buffer().get_selection_bounds() != ()
+            self.textview.get_buffer().get_selection_bounds() != ()
         self.emit('selection-changed')
 
     def get_has_selection(self):
@@ -409,10 +408,10 @@ class TextViewer(GObject.GObject):
 
     def setup_find_job(self, text, _find_updated_cb):
         self._find_job = _JobFind(self._etext_file, start_page=0,
-                n_pages=self._pagecount,
-                text=text, case_sensitive=False)
-        self._find_updated_handler = self._find_job.connect('updated',
-                _find_updated_cb)
+                                  n_pages=self._pagecount,
+                                  text=text, case_sensitive=False)
+        self._find_updated_handler = self._find_job.connect(
+            'updated', _find_updated_cb)
         return self._find_job, self._find_updated_handler
 
     def find_next(self):
@@ -439,8 +438,8 @@ class TextViewer(GObject.GObject):
         return self.font_zoom_relation * self._font_size
 
     def connect_zoom_handler(self, handler):
-        self._view_notify_zoom_handler = \
-                self.connect('zoom-changed', handler)
+        self._view_notify_zoom_handler = self.connect('zoom-changed',
+                                                      handler)
         return self._view_notify_zoom_handler
 
     def set_zoom(self, value):
@@ -483,14 +482,14 @@ class TextViewer(GObject.GObject):
     def can_rotate(self):
         return False
 
+
 class _JobFind(GObject.GObject):
 
     __gsignals__ = {
-        'updated': (GObject.SignalFlags.RUN_FIRST, GObject.TYPE_NONE, ([])),
-    }
+        'updated': (GObject.SignalFlags.RUN_FIRST, GObject.TYPE_NONE, ([])), }
 
-    def __init__(self, text_file, start_page, n_pages, text, \
-                case_sensitive=False):
+    def __init__(self, text_file, start_page, n_pages, text,
+                 case_sensitive=False):
         GObject.GObject.__init__(self)
         Gdk.threads_init()
 
@@ -569,8 +568,8 @@ class _SearchThread(threading.Thread):
             positions = self._allindices(line.lower(), self.obj._text.lower())
             for position in positions:
                 found_pos = charcount + position + 3
-                found_tuple = (pagecount, found_pos, \
-                        len(self.obj._text) + found_pos)
+                found_tuple = (pagecount, found_pos,
+                               len(self.obj._text) + found_pos)
                 self._found_records.append(found_tuple)
                 self._current_found_item = 0
             charcount = charcount + line_length
@@ -580,7 +579,7 @@ class _SearchThread(threading.Thread):
                 pagecount = pagecount + 1
         if self._current_found_item == 0:
             self.current_found_tuple = \
-                    self._found_records[self._current_found_item]
+                self._found_records[self._current_found_item]
             self._page = self.current_found_tuple[0]
 
         Gdk.threads_enter()
@@ -612,7 +611,7 @@ class _SearchThread(threading.Thread):
         if self._current_found_item >= len(self._found_records):
             self._current_found_item = 0
         self.current_found_tuple =  \
-                self._found_records[self._current_found_item]
+            self._found_records[self._current_found_item]
         self._page = self.current_found_tuple[0]
         self.obj.emit('updated')
 
@@ -621,7 +620,7 @@ class _SearchThread(threading.Thread):
         if self._current_found_item <= 0:
             self._current_found_item = len(self._found_records) - 1
         self.current_found_tuple = \
-                self._found_records[self._current_found_item]
+            self._found_records[self._current_found_item]
         self._page = self.current_found_tuple[0]
         self.obj.emit('updated')