renamed serviceItem

openlp/core/lib/mediamanageritem.py

@@ -447,7 +447,7 @@ class MediaManagerItem(QtGui.QWidget):
         """
         pass
 
-    def generateSlideData(self, serviceItem, item=None, xmlVersion=False, remote=False,
+    def generateSlideData(self, service_item, item=None, xmlVersion=False, remote=False,
             context=ServiceItemContext.Live):
         """
         Generate the slide data. Needs to be implemented by the plugin.
@@ -481,10 +481,10 @@ class MediaManagerItem(QtGui.QWidget):
                 translate('OpenLP.MediaManagerItem', 'You must select one or more items to preview.'))
         else:
             log.debug(u'%s Preview requested', self.plugin.name)
-            serviceItem = self.buildServiceItem()
+            service_item = self.buildServiceItem()
-            if serviceItem:
+            if service_item:
-                serviceItem.from_plugin = True
+                service_item.from_plugin = True
-                self.preview_controller.add_service_item(serviceItem)
+                self.preview_controller.add_service_item(service_item)
                 if keepFocus:
                     self.listView.setFocus()
 
@@ -507,13 +507,13 @@ class MediaManagerItem(QtGui.QWidget):
         item = None
         if item_id:
             item = self.createItemFromId(item_id)
-        serviceItem = self.buildServiceItem(item, remote=remote)
+        service_item = self.buildServiceItem(item, remote=remote)
-        if serviceItem:
+        if service_item:
             if not item_id:
-                serviceItem.from_plugin = True
+                service_item.from_plugin = True
             if remote:
-                serviceItem.will_auto_start = True
+                service_item.will_auto_start = True
-            self.live_controller.add_service_item(serviceItem)
+            self.live_controller.add_service_item(service_item)
 
     def createItemFromId(self, item_id):
         """
@@ -545,10 +545,10 @@ class MediaManagerItem(QtGui.QWidget):
         """
         Add this item to the current service.
         """
-        serviceItem = self.buildServiceItem(item, True, remote=remote, context=ServiceItemContext.Service)
+        service_item = self.buildServiceItem(item, True, remote=remote, context=ServiceItemContext.Service)
-        if serviceItem:
+        if service_item:
-            serviceItem.from_plugin = False
+            service_item.from_plugin = False
-            self.service_manager.add_service_item(serviceItem, replace=replace)
+            self.service_manager.add_service_item(service_item, replace=replace)
 
     def onAddEditClick(self):
         """
@@ -559,13 +559,13 @@ class MediaManagerItem(QtGui.QWidget):
                 translate('OpenLP.MediaManagerItem', 'You must select one or more items.'))
         else:
             log.debug(u'%s Add requested', self.plugin.name)
-            serviceItem = self.service_manager.get_service_item()
+            service_item = self.service_manager.get_service_item()
-            if not serviceItem:
+            if not service_item:
                 QtGui.QMessageBox.information(self, UiStrings().NISs,
                     translate('OpenLP.MediaManagerItem', 'You must select an existing service item to add to.'))
-            elif self.plugin.name == serviceItem.name:
+            elif self.plugin.name == service_item.name:
-                self.generateSlideData(serviceItem)
+                self.generateSlideData(service_item)
-                self.service_manager.add_service_item(serviceItem, replace=True)
+                self.service_manager.add_service_item(service_item, replace=True)
             else:
                 # Turn off the remote edit update message indicator
                 QtGui.QMessageBox.information(self, translate('OpenLP.MediaManagerItem', 'Invalid Service Item'),
@@ -575,10 +575,10 @@ class MediaManagerItem(QtGui.QWidget):
         """
         Common method for generating a service item
         """
-        serviceItem = ServiceItem(self.plugin)
+        service_item = ServiceItem(self.plugin)
-        serviceItem.add_icon(self.plugin.iconPath)
+        service_item.add_icon(self.plugin.iconPath)
-        if self.generateSlideData(serviceItem, item, xmlVersion, remote, context):
+        if self.generateSlideData(service_item, item, xmlVersion, remote, context):
-            return serviceItem
+            return service_item
         else:
             return None
 

openlp/core/lib/renderer.py

@@ -215,25 +215,25 @@ class Renderer(object):
         # save value for use in format_slide
         self.force_page = force_page
         # build a service item to generate preview
-        serviceItem = ServiceItem()
+        service_item = ServiceItem()
         if self.force_page:
             # make big page for theme edit dialog to get line count
-            serviceItem.add_from_text(VERSE_FOR_LINE_COUNT)
+            service_item.add_from_text(VERSE_FOR_LINE_COUNT)
         else:
-            serviceItem.add_from_text(VERSE)
+            service_item.add_from_text(VERSE)
-        serviceItem.raw_footer = FOOTER
+        service_item.raw_footer = FOOTER
         # if No file do not update cache
         if theme_data.background_filename:
             self.image_manager.add_image(
                 theme_data.background_filename, ImageSource.Theme, QtGui.QColor(theme_data.background_border_color))
         theme_data, main, footer = self.pre_render(theme_data)
-        serviceItem.themedata = theme_data
+        service_item.themedata = theme_data
-        serviceItem.main = main
+        service_item.main = main
-        serviceItem.footer = footer
+        service_item.footer = footer
-        serviceItem.render(True)
+        service_item.render(True)
         if not self.force_page:
-            self.display.build_html(serviceItem)
+            self.display.build_html(service_item)
-            raw_html = serviceItem.get_rendered_frame(0)
+            raw_html = service_item.get_rendered_frame(0)
             self.display.text(raw_html, False)
             preview = self.display.preview()
             return preview

openlp/core/lib/serviceitem.py

@@ -70,7 +70,7 @@ class ItemCapabilities(object):
              reordered.
 
     ``RequiresMedia``
-            Determines is the serviceItem needs a Media Player
+            Determines is the service_item needs a Media Player
 
     ``CanLoop``
             The capability to allow the SlideController to allow the loop

openlp/core/ui/maindisplay.py

@@ -220,9 +220,9 @@ class MainDisplay(Display):
                 (self.screen[u'size'].width() - splash_image.width()) / 2,
                 (self.screen[u'size'].height() - splash_image.height()) / 2,
                 splash_image)
-            serviceItem = ServiceItem()
+            service_item = ServiceItem()
-            serviceItem.bg_image_bytes = image_to_byte(self.initialFrame)
+            service_item.bg_image_bytes = image_to_byte(self.initialFrame)
-            self.web_view.setHtml(build_html(serviceItem, self.screen, self.is_live, None,
+            self.web_view.setHtml(build_html(service_item, self.screen, self.is_live, None,
                 plugins=self.plugin_manager.plugins))
             self.__hideMouse()
         log.debug(u'Finished MainDisplay setup')
@@ -290,10 +290,10 @@ class MainDisplay(Display):
         API for replacement backgrounds so Images are added directly to cache.
         """
         self.image_manager.add_image(path, ImageSource.ImagePlugin, background)
-        if not hasattr(self, u'serviceItem'):
+        if not hasattr(self, u'service_item'):
             return False
         self.override[u'image'] = path
-        self.override[u'theme'] = self.serviceItem.themedata.background_filename
+        self.override[u'theme'] = self.service_item.themedata.background_filename
         self.image(path)
         # Update the preview frame.
         if self.is_live:
@@ -332,8 +332,8 @@ class MainDisplay(Display):
         image plugin has changed the background.
         """
         log.debug(u'reset_image')
-        if hasattr(self, u'serviceItem'):
+        if hasattr(self, u'service_item'):
-            self.display_image(self.serviceItem.bg_image_bytes)
+            self.display_image(self.service_item.bg_image_bytes)
         else:
             self.display_image(None)
         # clear the cache
@@ -347,10 +347,10 @@ class MainDisplay(Display):
         was_visible = self.isVisible()
         self.application.process_events()
         # We must have a service item to preview.
-        if self.is_live and hasattr(self, u'serviceItem'):
+        if self.is_live and hasattr(self, u'service_item'):
             # Wait for the fade to finish before geting the preview.
             # Important otherwise preview will have incorrect text if at all!
-            if self.serviceItem.themedata and self.serviceItem.themedata.display_slide_transition:
+            if self.service_item.themedata and self.service_item.themedata.display_slide_transition:
                 while not self.frame.evaluateJavaScript(u'show_text_completed()'):
                     self.application.process_events()
         # Wait for the webview to update before getting the preview.
@@ -373,15 +373,15 @@ class MainDisplay(Display):
                     self.setVisible(True)
         return QtGui.QPixmap.grabWidget(self)
 
-    def build_html(self, serviceItem, image_path=u''):
+    def build_html(self, service_item, image_path=u''):
         """
-        Store the serviceItem and build the new HTML from it. Add the
+        Store the service_item and build the new HTML from it. Add the
         HTML to the display
         """
         log.debug(u'build_html')
         self.webLoaded = False
         self.initialFrame = None
-        self.serviceItem = serviceItem
+        self.service_item = service_item
         background = None
         # We have an image override so keep the image till the theme changes.
         if self.override:
@@ -390,31 +390,31 @@ class MainDisplay(Display):
                 Registry().execute(u'video_background_replaced')
                 self.override = {}
             # We have a different theme.
-            elif self.override[u'theme'] != serviceItem.themedata.background_filename:
+            elif self.override[u'theme'] != service_item.themedata.background_filename:
                 Registry().execute(u'live_theme_changed')
                 self.override = {}
             else:
                 # replace the background
                 background = self.image_manager.get_image_bytes(self.override[u'image'], ImageSource.ImagePlugin)
-        self.set_transparency(self.serviceItem.themedata.background_type ==
+        self.set_transparency(self.service_item.themedata.background_type ==
             BackgroundType.to_string(BackgroundType.Transparent))
-        if self.serviceItem.themedata.background_filename:
+        if self.service_item.themedata.background_filename:
-            self.serviceItem.bg_image_bytes = self.image_manager.get_image_bytes(
+            self.service_item.bg_image_bytes = self.image_manager.get_image_bytes(
-                self.serviceItem.themedata.background_filename, ImageSource.Theme
+                self.service_item.themedata.background_filename, ImageSource.Theme
             )
         if image_path:
             image_bytes = self.image_manager.get_image_bytes(image_path, ImageSource.ImagePlugin)
         else:
             image_bytes = None
-        html = build_html(self.serviceItem, self.screen, self.is_live, background, image_bytes,
+        html = build_html(self.service_item, self.screen, self.is_live, background, image_bytes,
             plugins=self.plugin_manager.plugins)
         log.debug(u'buildHtml - pre setHtml')
         self.web_view.setHtml(html)
         log.debug(u'buildHtml - post setHtml')
-        if serviceItem.foot_text:
+        if service_item.foot_text:
-            self.footer(serviceItem.foot_text)
+            self.footer(service_item.foot_text)
         # if was hidden keep it hidden
-        if self.hide_mode and self.is_live and not serviceItem.is_media():
+        if self.hide_mode and self.is_live and not service_item.is_media():
             if Settings().value(u'general/auto unblank'):
                 Registry().execute(u'slidecontroller_live_unblank')
             else:

openlp/core/ui/media/mediacontroller.py

@@ -84,7 +84,7 @@ class MediaController(object):
     The implementation of the Media Controller. The Media Controller adds an own
     class for every Player. Currently these are QtWebkit, Phonon and Vlc.
 
-    displayControllers are an array of controllers keyed on the
+    display_controllers are an array of controllers keyed on the
     slidecontroller or plugin which built them.  ControllerType is the class
     containing the key values.
 
@@ -100,7 +100,7 @@ class MediaController(object):
         Registry().register(u'media_controller', self)
         Registry().register_function(u'bootstrap_initialise', self.check_available_media_players)
         self.media_players = {}
-        self.displayControllers = {}
+        self.display_controllers = {}
         self.current_media_players = {}
         # Timer for video state
         self.timer = QtCore.QTimer()
@@ -125,9 +125,9 @@ class MediaController(object):
         """
         Set the active players and available media files
         """
-        savedPlayers = get_media_players()[0]
+        saved_players = get_media_players()[0]
         for player in self.media_players.keys():
-            self.media_players[player].isActive = player in savedPlayers
+            self.media_players[player].isActive = player in saved_players
 
     def _generate_extensions_lists(self):
         """
@@ -203,7 +203,7 @@ class MediaController(object):
         else:
             any_active = False
             for source in self.current_media_players.keys():
-                display = self._define_display(self.displayControllers[source])
+                display = self._define_display(self.display_controllers[source])
                 self.current_media_players[source].resize(display)
                 self.current_media_players[source].update_ui(display)
                 if self.current_media_players[source].state == MediaState.Playing:
@@ -214,7 +214,7 @@ class MediaController(object):
         # no players are active anymore
         for source in self.current_media_players.keys():
             if self.current_media_players[source].state != MediaState.Paused:
-                display = self._define_display(self.displayControllers[source])
+                display = self._define_display(self.display_controllers[source])
                 display.controller.seekSlider.setSliderPosition(0)
         self.timer.stop()
 
@@ -255,7 +255,7 @@ class MediaController(object):
         ``controller``
             The controller where a player will be placed
         """
-        self.displayControllers[controller.controller_type] = controller
+        self.display_controllers[controller.controller_type] = controller
         self.setup_generic_controls(controller)
 
     def setup_generic_controls(self, controller):
@@ -359,14 +359,14 @@ class MediaController(object):
         """
         player.resize(display)
 
-    def video(self, source, serviceItem, hidden=False, videoBehindText=False):
+    def video(self, source, service_item, hidden=False, videoBehindText=False):
         """
         Loads and starts a video to run with the option of sound
 
         ``source``
             Where the call originated form
 
-        ``serviceItem``
+        ``service_item``
             The player which is doing the playing
 
         ``hidden``
@@ -377,16 +377,16 @@ class MediaController(object):
         """
         log.debug(u'video')
         isValid = False
-        controller = self.displayControllers[source]
+        controller = self.display_controllers[source]
         # stop running videos
         self.media_reset(controller)
         controller.media_info = MediaInfo()
         controller.media_info.volume = controller.volumeSlider.value()
         controller.media_info.is_background = videoBehindText
-        controller.media_info.file_info = QtCore.QFileInfo(serviceItem.get_frame_path())
+        controller.media_info.file_info = QtCore.QFileInfo(service_item.get_frame_path())
         display = self._define_display(controller)
         if controller.is_live:
-            isValid = self._check_file_type(controller, display, serviceItem)
+            isValid = self._check_file_type(controller, display, service_item)
             display.override[u'theme'] = u''
             display.override[u'video'] = True
             if controller.media_info.is_background:
@@ -394,10 +394,10 @@ class MediaController(object):
                 controller.media_info.start_time = 0
                 controller.media_info.end_time = 0
             else:
-                controller.media_info.start_time = serviceItem.start_time
+                controller.media_info.start_time = service_item.start_time
-                controller.media_info.end_time = serviceItem.end_time
+                controller.media_info.end_time = service_item.end_time
         elif controller.preview_display:
-            isValid = self._check_file_type(controller, display, serviceItem)
+            isValid = self._check_file_type(controller, display, service_item)
         if not isValid:
             # Media could not be loaded correctly
             critical_error_message_box(translate('MediaPlugin.MediaItem', 'Unsupported File'),
@@ -412,7 +412,7 @@ class MediaController(object):
         if not controller.is_live:
             autoplay = True
         # Visible or background requested or Service Item wants to autostart
-        elif not hidden or controller.media_info.is_background or serviceItem.will_auto_start:
+        elif not hidden or controller.media_info.is_background or service_item.will_auto_start:
             autoplay = True
         # Unblank on load set
         elif Settings().value(u'general/auto unblank'):
@@ -426,22 +426,22 @@ class MediaController(object):
         log.debug(u'use %s controller' % self.current_media_players[controller.controller_type])
         return True
 
-    def media_length(self, serviceItem):
+    def media_length(self, service_item):
         """
         Loads and starts a media item to obtain the media length
 
-        ``serviceItem``
+        ``service_item``
             The ServiceItem containing the details to be played.
         """
-        controller = self.displayControllers[DisplayControllerType.Plugin]
+        controller = self.display_controllers[DisplayControllerType.Plugin]
         log.debug(u'media_length')
         # stop running videos
         self.media_reset(controller)
         controller.media_info = MediaInfo()
         controller.media_info.volume = 0
-        controller.media_info.file_info = QtCore.QFileInfo(serviceItem.get_frame_path())
+        controller.media_info.file_info = QtCore.QFileInfo(service_item.get_frame_path())
         display = controller._display
-        if not self._check_file_type(controller, display, serviceItem):
+        if not self._check_file_type(controller, display, service_item):
             # Media could not be loaded correctly
             critical_error_message_box(translate('MediaPlugin.MediaItem', 'Unsupported File'),
                 translate('MediaPlugin.MediaItem', 'Unsupported File'))
@@ -450,24 +450,24 @@ class MediaController(object):
             critical_error_message_box(translate('MediaPlugin.MediaItem', 'Unsupported File'),
                 translate('MediaPlugin.MediaItem', 'Unsupported File'))
             return False
-        serviceItem.set_media_length(controller.media_info.length)
+        service_item.set_media_length(controller.media_info.length)
         self.media_stop(controller)
         log.debug(u'use %s controller' % self.current_media_players[controller.controller_type])
         return True
 
-    def _check_file_type(self, controller, display, serviceItem):
+    def _check_file_type(self, controller, display, service_item):
         """
         Select the correct media Player type from the prioritized Player list
 
         ``controller``
             First element is the controller which should be used
 
-        ``serviceItem``
+        ``service_item``
             The ServiceItem containing the details to be played.
         """
         usedPlayers = get_media_players()[0]
-        if serviceItem.title != UiStrings().Automatic:
+        if service_item.title != UiStrings().Automatic:
-            usedPlayers = [serviceItem.title.lower()]
+            usedPlayers = [service_item.title.lower()]
         if controller.media_info.file_info.isFile():
             suffix = u'*.%s' % controller.media_info.file_info.suffix().lower()
             for title in usedPlayers:
@@ -721,8 +721,8 @@ class MediaController(object):
         Reset all the media controllers when OpenLP shuts down
         """
         self.timer.stop()
-        for controller in self.displayControllers:
+        for controller in self.display_controllers:
-            self.media_reset(self.displayControllers[controller])
+            self.media_reset(self.display_controllers[controller])
 
     def _define_display(self, controller):
         """

openlp/core/ui/servicemanager.py

@@ -303,9 +303,9 @@ class ServiceManager(QtGui.QWidget, ServiceManagerDialog):
         self._modified = False
         self._file_name = u''
         self.service_has_all_original_files = True
-        self.serviceNoteForm = ServiceNoteForm()
+        self.service_note_form = ServiceNoteForm()
-        self.serviceItemEditForm = ServiceItemEditForm()
+        self.service_item_edit_form = ServiceItemEditForm()
-        self.startTimeForm = StartTimeForm()
+        self.start_time_form = StartTimeForm()
         # start with the layout
         self.layout = QtGui.QVBoxLayout(self)
         self.layout.setSpacing(0)
@@ -337,7 +337,7 @@ class ServiceManager(QtGui.QWidget, ServiceManagerDialog):
         self._file_name = unicode(file_name)
         self.main_window.setServiceModified(self.is_modified(), self.short_file_name())
         Settings().setValue(u'servicemanager/last file', file_name)
-        self._saveLite = self._file_name.endswith(u'.oszl')
+        self._save_lite = self._file_name.endswith(u'.oszl')
 
     def file_name(self):
         """
@@ -505,7 +505,7 @@ class ServiceManager(QtGui.QWidget, ServiceManagerDialog):
             if item[u'service_item'].missing_frames():
                 self.service_items.remove(item)
             else:
-                service_item = item[u'service_item'].get_service_repr(self._saveLite)
+                service_item = item[u'service_item'].get_service_repr(self._save_lite)
                 if service_item[u'header'][u'background_audio']:
                     for i, file_name in enumerate(service_item[u'header'][u'background_audio']):
                         new_file = os.path.join(u'audio', item[u'service_item'].unique_identifier, file_name)
@@ -591,7 +591,7 @@ class ServiceManager(QtGui.QWidget, ServiceManagerDialog):
         self.main_window.displayProgressBar(len(self.service_items) + 1)
         for item in self.service_items:
             self.main_window.incrementProgressBar()
-            service_item = item[u'service_item'].get_service_repr(self._saveLite)
+            service_item = item[u'service_item'].get_service_repr(self._save_lite)
             #@todo check for file item on save.
             service.append({u'serviceitem': service_item})
             self.main_window.incrementProgressBar()
@@ -675,7 +675,7 @@ class ServiceManager(QtGui.QWidget, ServiceManagerDialog):
         """
         if not self.file_name():
             return self.save_file_as()
-        if self._saveLite:
+        if self._save_lite:
             return self.save_local_file()
         else:
             return self.save_file()
@@ -721,7 +721,7 @@ class ServiceManager(QtGui.QWidget, ServiceManagerDialog):
                 for item in items:
                     self.main_window.incrementProgressBar()
                     service_item = ServiceItem()
-                    if self._saveLite:
+                    if self._save_lite:
                         service_item.set_from_service(item)
                     else:
                         service_item.set_from_service(item, self.servicePath)
@@ -848,9 +848,9 @@ class ServiceManager(QtGui.QWidget, ServiceManagerDialog):
         Allow the service note to be edited
         """
         item = self.find_service_item()[0]
-        self.serviceNoteForm.text_edit.setPlainText(self.service_items[item][u'service_item'].notes)
+        self.service_note_form.text_edit.setPlainText(self.service_items[item][u'service_item'].notes)
-        if self.serviceNoteForm.exec_():
+        if self.service_note_form.exec_():
-            self.service_items[item][u'service_item'].notes = self.serviceNoteForm.text_edit.toPlainText()
+            self.service_items[item][u'service_item'].notes = self.service_note_form.text_edit.toPlainText()
             self.repaint_service_list(item, -1)
             self.set_modified()
 
@@ -859,8 +859,8 @@ class ServiceManager(QtGui.QWidget, ServiceManagerDialog):
         Opens a dialog to type in service item notes.
         """
         item = self.find_service_item()[0]
-        self.startTimeForm.item = self.service_items[item]
+        self.start_time_form.item = self.service_items[item]
-        if self.startTimeForm.exec_():
+        if self.start_time_form.exec_():
             self.repaint_service_list(item, -1)
 
     def toggle_auto_play_slides_once(self):
@@ -931,9 +931,9 @@ class ServiceManager(QtGui.QWidget, ServiceManagerDialog):
         display if changes are saved.
         """
         item = self.find_service_item()[0]
-        self.serviceItemEditForm.set_service_item(self.service_items[item][u'service_item'])
+        self.service_item_edit_form.set_service_item(self.service_items[item][u'service_item'])
-        if self.serviceItemEditForm.exec_():
+        if self.service_item_edit_form.exec_():
-            self.add_service_item(self.serviceItemEditForm.get_service_item(),
+            self.add_service_item(self.service_item_edit_form.get_service_item(),
                 replace=True, expand=self.service_items[item][u'expanded'])
 
     def preview_live(self, unique_identifier, row):
@@ -1136,17 +1136,17 @@ class ServiceManager(QtGui.QWidget, ServiceManagerDialog):
             self.repaint_service_list(item - 1, -1)
             self.set_modified()
 
-    def repaint_service_list(self, serviceItem, serviceItemChild):
+    def repaint_service_list(self, service_item, service_item_child):
         """
         Clear the existing service list and prepaint all the items. This is
         used when moving items as the move takes place in a supporting list,
         and when regenerating all the items due to theme changes.
 
-        ``serviceItem``
+        ``service_item``
             The item which changed. (int)
 
-        ``serviceItemChild``
+        ``service_item_child``
-            The child of the ``serviceItem``, which will be selected. (int)
+            The child of the ``service_item``, which will be selected. (int)
         """
         # Correct order of items in array
         count = 1
@@ -1207,10 +1207,10 @@ class ServiceManager(QtGui.QWidget, ServiceManagerDialog):
                 text = frame[u'title'].replace(u'\n', u' ')
                 child.setText(0, text[:40])
                 child.setData(0, QtCore.Qt.UserRole, count)
-                if serviceItem == item_count:
+                if service_item == item_count:
-                    if item[u'expanded'] and serviceItemChild == count:
+                    if item[u'expanded'] and service_item_child == count:
                         self.service_manager_list.setCurrentItem(child)
-                    elif serviceItemChild == -1:
+                    elif service_item_child == -1:
                         self.service_manager_list.setCurrentItem(treewidgetitem)
             treewidgetitem.setExpanded(item[u'expanded'])
 
@@ -1443,20 +1443,20 @@ class ServiceManager(QtGui.QWidget, ServiceManagerDialog):
             (1, 2)
         """
         items = self.service_manager_list.selectedItems()
-        serviceItem = -1
+        service_item = -1
-        serviceItemChild = -1
+        service_item_child = -1
         for item in items:
             parent_item = item.parent()
             if parent_item is None:
-                serviceItem = item.data(0, QtCore.Qt.UserRole)
+                service_item = item.data(0, QtCore.Qt.UserRole)
             else:
-                serviceItem = parent_item.data(0, QtCore.Qt.UserRole)
+                service_item = parent_item.data(0, QtCore.Qt.UserRole)
-                serviceItemChild = item.data(0, QtCore.Qt.UserRole)
+                service_item_child = item.data(0, QtCore.Qt.UserRole)
             # Adjust for zero based arrays.
-            serviceItem -= 1
+            service_item -= 1
             # Only process the first item on the list for this method.
             break
-        return serviceItem, serviceItemChild
+        return service_item, service_item_child
 
     def drop_event(self, event):
         """