def get_book_ref_id_by_name(self, book, maxbooks=66, language_id=None):
"""
Find the book id from the name or abbreviation of the book. If it doesn't currently exist, ask the user.
:param book: The name or abbreviation of the book
:param maxbooks: The number of books in the bible
:param language_id: The language_id of the bible
:return: The id of the bible, or None
"""
self.log_debug(
'BibleDB.get_book_ref_id_by_name:("{book}", "{lang}")'.format(
book=book, lang=language_id))
book_temp = BiblesResourcesDB.get_book(book, True)
if book_temp:
return book_temp['id']
book_id = BiblesResourcesDB.get_alternative_book_name(book)
if book_id:
return book_id
book_id = AlternativeBookNamesDB.get_book_reference_id(book)
if book_id:
return book_id
from openlp.plugins.bibles.forms import BookNameForm
book_name = BookNameForm(self.wizard)
if book_name.exec(book, self.get_books(),
maxbooks) and book_name.book_id:
AlternativeBookNamesDB.create_alternative_book_name(
book, book_name.book_id, language_id)
return book_name.book_id
def buildDisplayResults(self, bible, second_bible, search_results):
"""
Displays the search results in the media manager. All data needed for
further action is saved for/in each row.
"""
verse_separator = get_reference_separator('sep_v_display')
version = self.plugin.manager.get_meta_data(bible, 'name').value
copyright = self.plugin.manager.get_meta_data(bible, 'copyright').value
permissions = self.plugin.manager.get_meta_data(bible, 'permissions').value
second_version = ''
second_copyright = ''
second_permissions = ''
if second_bible:
second_version = self.plugin.manager.get_meta_data(second_bible, 'name').value
second_copyright = self.plugin.manager.get_meta_data(second_bible, 'copyright').value
second_permissions = self.plugin.manager.get_meta_data(second_bible, 'permissions').value
items = []
language_selection = self.plugin.manager.get_language_selection(bible)
for count, verse in enumerate(search_results):
book = None
if language_selection == LanguageSelection.Bible:
book = verse.book.name
elif language_selection == LanguageSelection.Application:
book_names = BibleStrings().BookNames
data = BiblesResourcesDB.get_book_by_id(verse.book.book_reference_id)
book = str(book_names[data['abbreviation']])
elif language_selection == LanguageSelection.English:
data = BiblesResourcesDB.get_book_by_id(verse.book.book_reference_id)
book = data['name']
data = {
'book': book,
'chapter': verse.chapter,
'verse': verse.verse,
'bible': bible,
'version': version,
'copyright': copyright,
'permissions': permissions,
'text': verse.text,
'second_bible': second_bible,
'second_version': second_version,
'second_copyright': second_copyright,
'second_permissions': second_permissions,
'second_text': ''
}
if second_bible:
try:
data['second_text'] = self.second_search_results[count].text
except IndexError:
log.exception('The second_search_results does not have as many verses as the search_results.')
break
bible_text = '%s %d%s%d (%s, %s)' % (book, verse.chapter, verse_separator, verse.verse, version,
second_version)
else:
bible_text = '%s %d%s%d (%s)' % (book, verse.chapter, verse_separator, verse.verse, version)
bible_verse = QtGui.QListWidgetItem(bible_text)
bible_verse.setData(QtCore.Qt.UserRole, data)
items.append(bible_verse)
return items
def do_import(self, bible_name=None):
"""
Run the import. This method overrides the parent class method. Returns ``True`` on success, ``False`` on
failure.
"""
self.wizard.progress_bar.setMaximum(68)
self.wizard.increment_progress_bar(translate('BiblesPlugin.HTTPBible', 'Registering Bible and loading books...'))
self.save_meta('download_source', self.download_source)
self.save_meta('download_name', self.download_name)
if self.proxy_server:
self.save_meta('proxy_server', self.proxy_server)
if self.proxy_username:
# Store the proxy userid.
self.save_meta('proxy_username', self.proxy_username)
if self.proxy_password:
# Store the proxy password.
self.save_meta('proxy_password', self.proxy_password)
if self.download_source.lower() == 'crosswalk':
handler = CWExtract(self.proxy_server)
elif self.download_source.lower() == 'biblegateway':
handler = BGExtract(self.proxy_server)
elif self.download_source.lower() == 'bibleserver':
handler = BSExtract(self.proxy_server)
books = handler.get_books_from_http(self.download_name)
if not books:
log.exception('Importing books from %s - download name: "%s" '\
'failed' % (self.download_source, self.download_name))
return False
self.wizard.progress_bar.setMaximum(len(books) + 2)
self.wizard.increment_progress_bar(translate( 'BiblesPlugin.HTTPBible', 'Registering Language...'))
bible = BiblesResourcesDB.get_webbible(self.download_name, self.download_source.lower())
if bible['language_id']:
language_id = bible['language_id']
self.save_meta('language_id', language_id)
else:
language_id = self.get_language(bible_name)
if not language_id:
log.exception('Importing books from %s failed' % self.filename)
return False
for book in books:
if self.stop_import_flag:
break
self.wizard.increment_progress_bar(translate(
'BiblesPlugin.HTTPBible', 'Importing %s...', 'Importing <book name>...') % book)
book_ref_id = self.get_book_ref_id_by_name(book, len(books), language_id)
if not book_ref_id:
log.exception('Importing books from %s - download name: "%s" '\
'failed' % (self.download_source, self.download_name))
return False
book_details = BiblesResourcesDB.get_book_by_id(book_ref_id)
log.debug('Book details: Name:%s; id:%s; testament_id:%s',
book, book_ref_id, book_details['testament_id'])
self.create_book(book, book_ref_id, book_details['testament_id'])
if self.stop_import_flag:
return False
else:
return True
def initialiseAdvancedBible(self, bible, last_book_id=None):
"""
This initialises the given bible, which means that its book names and
their chapter numbers is added to the combo boxes on the
'Advanced Search' Tab. This is not of any importance of the
'Quick Search' Tab.
``bible``
The bible to initialise (unicode).
``last_book_id``
The "book reference id" of the book which is choosen at the moment.
(int)
"""
log.debug('initialiseAdvancedBible %s, %s', bible, last_book_id)
book_data = self.plugin.manager.get_books(bible)
secondbible = self.advancedSecondComboBox.currentText()
if secondbible != '':
secondbook_data = self.plugin.manager.get_books(secondbible)
book_data_temp = []
for book in book_data:
for secondbook in secondbook_data:
if book['book_reference_id'] == \
secondbook['book_reference_id']:
book_data_temp.append(book)
book_data = book_data_temp
self.advancedBookComboBox.clear()
first = True
initialise_chapter_verse = False
language_selection = self.plugin.manager.get_language_selection(bible)
book_names = BibleStrings().BookNames
for book in book_data:
row = self.advancedBookComboBox.count()
if language_selection == LanguageSelection.Bible:
self.advancedBookComboBox.addItem(book['name'])
elif language_selection == LanguageSelection.Application:
data = BiblesResourcesDB.get_book_by_id(book['book_reference_id'])
self.advancedBookComboBox.addItem(book_names[data['abbreviation']])
elif language_selection == LanguageSelection.English:
data = BiblesResourcesDB.get_book_by_id(book['book_reference_id'])
self.advancedBookComboBox.addItem(data['name'])
self.advancedBookComboBox.setItemData(row, book['book_reference_id'])
if first:
first = False
first_book = book
initialise_chapter_verse = True
if last_book_id and last_book_id == int(book['book_reference_id']):
index = self.advancedBookComboBox.findData(book['book_reference_id'])
if index == -1:
# Not Found.
index = 0
self.advancedBookComboBox.setCurrentIndex(index)
initialise_chapter_verse = False
if initialise_chapter_verse:
self.initialiseChapterVerse(bible, first_book['name'],
first_book['book_reference_id'])
def retranslateUi(self, edit_bible_dialog):
self.book_names = BibleStrings().BookNames
edit_bible_dialog.setWindowTitle(translate('BiblesPlugin.EditBibleForm', 'Bible Editor'))
# Meta tab
self.bible_tab_widget.setTabText(
self.bible_tab_widget.indexOf(self.meta_tab), translate('SongsPlugin.EditBibleForm', 'Meta Data'))
self.license_details_group_box.setTitle(translate('BiblesPlugin.EditBibleForm', 'License Details'))
self.version_name_label.setText(translate('BiblesPlugin.EditBibleForm', 'Version name:'))
self.copyright_label.setText(translate('BiblesPlugin.EditBibleForm', 'Copyright:'))
self.permissions_label.setText(translate('BiblesPlugin.EditBibleForm', 'Permissions:'))
self.language_selection_group_box.setTitle(translate('BiblesPlugin.EditBibleForm', 'Default Bible Language'))
self.language_selection_label.setText(
translate('BiblesPlugin.EditBibleForm', 'Book name language in search field, search results and '
'on display:'))
self.language_selection_combo_box.setItemText(0, translate('BiblesPlugin.EditBibleForm', 'Global Settings'))
self.language_selection_combo_box.setItemText(
LanguageSelection.Bible + 1,
translate('BiblesPlugin.EditBibleForm', 'Bible Language'))
self.language_selection_combo_box.setItemText(
LanguageSelection.Application + 1, translate('BiblesPlugin.EditBibleForm', 'Application Language'))
self.language_selection_combo_box.setItemText(
LanguageSelection.English + 1,
translate('BiblesPlugin.EditBibleForm', 'English'))
# Book name tab
self.bible_tab_widget.setTabText(
self.bible_tab_widget.indexOf(self.book_name_tab),
translate('SongsPlugin.EditBibleForm', 'Custom Book Names'))
for book in BiblesResourcesDB.get_books():
self.book_name_label[book['abbreviation']].setText('%s:' % str(self.book_names[book['abbreviation']]))
def find_and_create_book(self,
name,
no_of_books,
language_id,
guess_id=None):
"""
Find the OpenLP book id and then create the book in this bible db
:param name: Name of the book. If None, then fall back to the guess_id Str
:param no_of_books: The total number of books contained in this bible Int
:param language_id: The OpenLP id of the language of this bible Int
:param guess_id: The guessed id of the book, used if name is None Int
:return:
"""
if name:
book_ref_id = self.get_book_ref_id_by_name(name, no_of_books,
language_id)
else:
self.log_debug('No book name supplied. Falling back to guess_id')
book_ref_id = guess_id
if not book_ref_id:
raise ValidationError(msg='Could not resolve book_ref_id in "{}"'.
format(self.filename))
book_details = BiblesResourcesDB.get_book_by_id(book_ref_id)
if book_details is None:
raise ValidationError(
msg=
'book_ref_id: {book_ref} Could not be found in the BibleResourcesDB while '
'importing {file}'.format(book_ref=book_ref_id,
file=self.filename))
return self.create_book(name, book_ref_id,
book_details['testament_id'])
def exec_(self, bible_name):
self.languageComboBox.addItem(u'')
if bible_name:
self.bibleLabel.setText(unicode(bible_name))
items = BiblesResourcesDB.get_languages()
self.languageComboBox.addItems([item[u'name'] for item in items])
return QDialog.exec_(self)
def exec(self, bible_name):
self.language_combo_box.addItem('')
if bible_name:
self.bible_label.setText(str(bible_name))
items = BiblesResourcesDB.get_languages()
self.language_combo_box.addItems([item['name'] for item in items])
return QDialog.exec(self)
def exec_(self, bible_name):
self.language_combo_box.addItem('')
if bible_name:
self.bible_label.setText(str(bible_name))
items = BiblesResourcesDB.get_languages()
self.language_combo_box.addItems([item['name'] for item in items])
return QDialog.exec_(self)
def retranslateUi(self, edit_bible_dialog):
self.book_names = BibleStrings().BookNames
edit_bible_dialog.setWindowTitle(translate('BiblesPlugin.EditBibleForm', 'Bible Editor'))
# Meta tab
self.bible_tab_widget.setTabText( self.bible_tab_widget.indexOf(self.meta_tab),
translate('SongsPlugin.EditBibleForm', 'Meta Data'))
self.license_details_group_box.setTitle(translate('BiblesPlugin.EditBibleForm', 'License Details'))
self.version_name_label.setText(translate('BiblesPlugin.EditBibleForm', 'Version name:'))
self.copyright_label.setText(translate('BiblesPlugin.EditBibleForm', 'Copyright:'))
self.permissions_label.setText(translate('BiblesPlugin.EditBibleForm', 'Permissions:'))
self.language_selection_group_box.setTitle(translate('BiblesPlugin.EditBibleForm', 'Default Bible Language'))
self.language_selection_label.setText(translate('BiblesPlugin.EditBibleForm',
'Book name language in search field, search results and on display:'))
self.language_selection_combo_box.setItemText(0, translate('BiblesPlugin.EditBibleForm', 'Global Settings'))
self.language_selection_combo_box.setItemText(LanguageSelection.Bible + 1,
translate('BiblesPlugin.EditBibleForm', 'Bible Language'))
self.language_selection_combo_box.setItemText(LanguageSelection.Application + 1,
translate('BiblesPlugin.EditBibleForm', 'Application Language'))
self.language_selection_combo_box.setItemText(LanguageSelection.English + 1,
translate('BiblesPlugin.EditBibleForm', 'English'))
# Book name tab
self.bible_tab_widget.setTabText(self.bible_tab_widget.indexOf(self.book_name_tab),
translate('SongsPlugin.EditBibleForm', 'Custom Book Names'))
for book in BiblesResourcesDB.get_books():
self.book_name_label[book['abbreviation']].setText('%s:' % str(self.book_names[book['abbreviation']]))
def do_import(self, bible_name=None):
"""
Run the import. This method overrides the parent class method. Returns ``True`` on success, ``False`` on
failure.
"""
self.wizard.progress_bar.setMaximum(68)
self.wizard.increment_progress_bar(
translate("BiblesPlugin.HTTPBible", "Registering Bible and loading books...")
)
self.save_meta("download_source", self.download_source)
self.save_meta("download_name", self.download_name)
if self.proxy_server:
self.save_meta("proxy_server", self.proxy_server)
if self.proxy_username:
# Store the proxy userid.
self.save_meta("proxy_username", self.proxy_username)
if self.proxy_password:
# Store the proxy password.
self.save_meta("proxy_password", self.proxy_password)
if self.download_source.lower() == "crosswalk":
handler = CWExtract(self.proxy_server)
elif self.download_source.lower() == "biblegateway":
handler = BGExtract(self.proxy_server)
elif self.download_source.lower() == "bibleserver":
handler = BSExtract(self.proxy_server)
books = handler.get_books_from_http(self.download_name)
if not books:
log.error(
'Importing books from %s - download name: "%s" failed' % (self.download_source, self.download_name)
)
return False
self.wizard.progress_bar.setMaximum(len(books) + 2)
self.wizard.increment_progress_bar(translate("BiblesPlugin.HTTPBible", "Registering Language..."))
if self.language_id:
self.save_meta("language_id", self.language_id)
else:
self.language_id = self.get_language(bible_name)
if not self.language_id:
log.error("Importing books from %s failed" % self.filename)
return False
for book in books:
if self.stop_import_flag:
break
self.wizard.increment_progress_bar(
translate("BiblesPlugin.HTTPBible", "Importing %s...", "Importing <book name>...") % book
)
book_ref_id = self.get_book_ref_id_by_name(book, len(books), self.language_id)
if not book_ref_id:
log.error(
'Importing books from %s - download name: "%s" failed' % (self.download_source, self.download_name)
)
return False
book_details = BiblesResourcesDB.get_book_by_id(book_ref_id)
log.debug("Book details: Name:%s; id:%s; testament_id:%s", book, book_ref_id, book_details["testament_id"])
self.create_book(book, book_ref_id, book_details["testament_id"])
if self.stop_import_flag:
return False
else:
return True
def get_chapter_count(self, book):
"""
Return the number of chapters in a particular book.
:param book: The book object to get the chapter count for.
"""
log.debug('HTTPBible.get_chapter_count("%s")', book.name)
return BiblesResourcesDB.get_chapter_count(book.book_reference_id)
def get_chapter_count(self, book):
"""
Return the number of chapters in a particular book.
:param book: The book object to get the chapter count for.
"""
log.debug('HTTPBible.get_chapter_count("{name}")'.format(name=book.name))
return BiblesResourcesDB.get_chapter_count(book.book_reference_id)
def do_import(self, bible_name=None):
"""
Loads a Bible from file.
"""
log.debug('Starting Zefania import from "{name}"'.format(name=self.file_path))
success = True
try:
xmlbible = self.parse_xml(self.file_path, elements=REMOVABLE_ELEMENTS, tags=REMOVABLE_TAGS)
# Find bible language
language = xmlbible.xpath("/XMLBIBLE/INFORMATION/language/text()")
language_id = self.get_language_id(language[0] if language else None, bible_name=str(self.file_path))
if not language_id:
return False
no_of_books = int(xmlbible.xpath('count(//BIBLEBOOK)'))
self.wizard.progress_bar.setMaximum(int(xmlbible.xpath('count(//CHAPTER)')))
for BIBLEBOOK in xmlbible:
if self.stop_import_flag:
break
bname = BIBLEBOOK.get('bname')
bnumber = BIBLEBOOK.get('bnumber')
if not bname and not bnumber:
continue
if bname:
book_ref_id = self.get_book_ref_id_by_name(bname, no_of_books, language_id)
else:
log.debug('Could not find a name, will use number, basically a guess.')
book_ref_id = int(bnumber)
if not book_ref_id:
log.error('Importing books from "{name}" failed'.format(name=self.file_path))
return False
book_details = BiblesResourcesDB.get_book_by_id(book_ref_id)
db_book = self.create_book(book_details['name'], book_ref_id, book_details['testament_id'])
for CHAPTER in BIBLEBOOK:
if self.stop_import_flag:
break
chapter_number = CHAPTER.get("cnumber")
for VERS in CHAPTER:
verse_number = VERS.get("vnumber")
self.create_verse(
db_book.id, int(chapter_number), int(verse_number), VERS.text.replace('<BR/>', '\n'))
self.wizard.increment_progress_bar(
translate('BiblesPlugin.Zefnia',
'Importing {book} {chapter}...').format(book=db_book.name,
chapter=chapter_number))
self.session.commit()
self.application.process_events()
except Exception as e:
critical_error_message_box(
message=translate('BiblesPlugin.ZefaniaImport',
'Incorrect Bible file type supplied. Zefania Bibles may be '
'compressed. You must decompress them before import.'))
log.exception(str(e))
success = False
if self.stop_import_flag:
return False
else:
return success
def get_verse_count(self, book_id, chapter):
"""
Return the number of verses for the specified chapter and book.
:param book_id: The name of the book.
:param chapter: The chapter whose verses are being counted.
"""
log.debug('HTTPBible.get_verse_count("{ref}", {chapter})'.format(ref=book_id, chapter=chapter))
return BiblesResourcesDB.get_verse_count(book_id, chapter)
def get_verse_count(self, book_id, chapter):
"""
Return the number of verses for the specified chapter and book.
:param book_id: The name of the book.
:param chapter: The chapter whose verses are being counted.
"""
log.debug('HTTPBible.get_verse_count("%s", %s)', book_id, chapter)
return BiblesResourcesDB.get_verse_count(book_id, chapter)
def load_bible(self, bible):
"""
Loads a bible.
``bible``
:param bible: The name of the bible.
"""
log.debug('Load Bible')
self.bible = bible
book_name_language = self.manager.get_meta_data(self.bible, 'book_name_language')
"""
Try loading the metadata, if the field does not exist in the metadata, continue executing the code,
missing fields will be created on "self.accept" (save).
"""
meta = self.manager.get_meta_data(self.bible, 'name')
copyright = self.manager.get_meta_data(self.bible, 'copyright')
permission = self.manager.get_meta_data(self.bible, 'permissions')
full_license = self.manager.get_meta_data(self.bible, 'full_license')
if meta:
self.version_name_edit.setText(meta.value)
if copyright:
self.copyright_edit.setText(copyright.value)
if permission:
self.permissions_edit.setText(permission.value)
if full_license:
self.full_license_edit.setPlainText(full_license.value)
# Set placeholder texts for the fields.
self.version_name_edit.setPlaceholderText(UiStrings().RequiredShowInFooter)
self.copyright_edit.setPlaceholderText(UiStrings().RequiredShowInFooter)
self.permissions_edit.setPlaceholderText(UiStrings().OptionalShowInFooter)
self.full_license_edit.setPlaceholderText(UiStrings().OptionalHideInFooter)
if book_name_language and book_name_language.value != 'None':
self.language_selection_combo_box.setCurrentIndex(int(book_name_language.value) + 1)
self.books = {}
self.web_bible = self.manager.get_meta_data(self.bible, 'download_source')
if self.web_bible:
self.book_name_notice.setText(
translate('BiblesPlugin.EditBibleForm',
'This is a Web Download Bible.\nIt is not possible to customize the Book Names.'))
self.scroll_area.hide()
else:
self.book_name_notice.setText(
translate('BiblesPlugin.EditBibleForm',
'To use the customized book names, "Bible language" must be selected on the Meta Data tab '
'or, if "Global settings" is selected, on the Bible page in Configure OpenLP.'))
for book in BiblesResourcesDB.get_books():
self.books[book['abbreviation']] = self.manager.get_book_by_id(self.bible, book['id'])
if self.books[book['abbreviation']] and not self.web_bible:
self.book_name_edit[book['abbreviation']].setText(self.books[book['abbreviation']].name)
else:
# It is necessary to remove the Widget otherwise there still
# exists the vertical spacing in QFormLayout
self.book_name_widget_layout.removeWidget(self.book_name_label[book['abbreviation']])
self.book_name_label[book['abbreviation']].hide()
self.book_name_widget_layout.removeWidget(self.book_name_edit[book['abbreviation']])
self.book_name_edit[book['abbreviation']].hide()
def do_import(self, bible_name=None):
"""
Loads a Bible from file.
"""
log.debug('Starting Zefania import from "{name}"'.format(name=self.filename))
success = True
try:
xmlbible = self.parse_xml(self.filename, elements=REMOVABLE_ELEMENTS, tags=REMOVABLE_TAGS)
# Find bible language
language = xmlbible.xpath("/XMLBIBLE/INFORMATION/language/text()")
language_id = self.get_language_id(language[0] if language else None, bible_name=self.filename)
if not language_id:
return False
no_of_books = int(xmlbible.xpath('count(//BIBLEBOOK)'))
self.wizard.progress_bar.setMaximum(int(xmlbible.xpath('count(//CHAPTER)')))
for BIBLEBOOK in xmlbible:
if self.stop_import_flag:
break
bname = BIBLEBOOK.get('bname')
bnumber = BIBLEBOOK.get('bnumber')
if not bname and not bnumber:
continue
if bname:
book_ref_id = self.get_book_ref_id_by_name(bname, no_of_books, language_id)
else:
log.debug('Could not find a name, will use number, basically a guess.')
book_ref_id = int(bnumber)
if not book_ref_id:
log.error('Importing books from "{name}" failed'.format(name=self.filename))
return False
book_details = BiblesResourcesDB.get_book_by_id(book_ref_id)
db_book = self.create_book(book_details['name'], book_ref_id, book_details['testament_id'])
for CHAPTER in BIBLEBOOK:
if self.stop_import_flag:
break
chapter_number = CHAPTER.get("cnumber")
for VERS in CHAPTER:
verse_number = VERS.get("vnumber")
self.create_verse(
db_book.id, int(chapter_number), int(verse_number), VERS.text.replace('<BR/>', '\n'))
self.wizard.increment_progress_bar(
translate('BiblesPlugin.Zefnia',
'Importing {book} {chapter}...').format(book=db_book.name,
chapter=chapter_number))
self.session.commit()
self.application.process_events()
except Exception as e:
critical_error_message_box(
message=translate('BiblesPlugin.ZefaniaImport',
'Incorrect Bible file type supplied. Zefania Bibles may be '
'compressed. You must decompress them before import.'))
log.exception(str(e))
success = False
if self.stop_import_flag:
return False
else:
return success
def get_chapter_count(self, book):
"""
Return the number of chapters in a particular book.
``book``
The book object to get the chapter count for.
"""
log.debug('HTTPBible.get_chapter_count("%s")', book.name)
return BiblesResourcesDB.get_chapter_count(book.book_reference_id)
def do_import(self, bible_name=None):
"""
Run the import. This method overrides the parent class method. Returns ``True`` on success, ``False`` on
failure.
"""
self.wizard.progress_bar.setMaximum(68)
self.wizard.increment_progress_bar(translate('BiblesPlugin.HTTPBible',
'Registering Bible and loading books...'))
self.save_meta('download_source', self.download_source)
self.save_meta('download_name', self.download_name)
if self.proxy_server:
self.save_meta('proxy_server', self.proxy_server)
if self.proxy_username:
# Store the proxy userid.
self.save_meta('proxy_username', self.proxy_username)
if self.proxy_password:
# Store the proxy password.
self.save_meta('proxy_password', self.proxy_password)
if self.download_source.lower() == 'crosswalk':
handler = CWExtract(self.proxy_server)
elif self.download_source.lower() == 'biblegateway':
handler = BGExtract(self.proxy_server)
elif self.download_source.lower() == 'bibleserver':
handler = BSExtract(self.proxy_server)
books = handler.get_books_from_http(self.download_name)
if not books:
log.error('Importing books from %s - download name: "%s" failed' %
(self.download_source, self.download_name))
return False
self.wizard.progress_bar.setMaximum(len(books) + 2)
self.wizard.increment_progress_bar(translate('BiblesPlugin.HTTPBible', 'Registering Language...'))
if self.language_id:
self.save_meta('language_id', self.language_id)
else:
self.language_id = self.get_language(bible_name)
if not self.language_id:
log.error('Importing books from %s failed' % self.filename)
return False
for book in books:
if self.stop_import_flag:
break
self.wizard.increment_progress_bar(translate(
'BiblesPlugin.HTTPBible', 'Importing %s...', 'Importing <book name>...') % book)
book_ref_id = self.get_book_ref_id_by_name(book, len(books), self.language_id)
if not book_ref_id:
log.error('Importing books from %s - download name: "%s" failed' %
(self.download_source, self.download_name))
return False
book_details = BiblesResourcesDB.get_book_by_id(book_ref_id)
log.debug('Book details: Name:%s; id:%s; testament_id:%s',
book, book_ref_id, book_details['testament_id'])
self.create_book(book, book_ref_id, book_details['testament_id'])
if self.stop_import_flag:
return False
else:
return True
def do_import(self, bible_name=None):
"""
Run the import. This method overrides the parent class method. Returns ``True`` on success, ``False`` on
failure.
"""
self.wizard.progress_bar.setMaximum(68)
self.wizard.increment_progress_bar(
translate('BiblesPlugin.HTTPBible',
'Registering Bible and loading books...'))
self.save_meta('download_source', self.download_source)
self.save_meta('download_name', self.download_name)
if self.download_source.lower() == 'crosswalk':
handler = CWExtract()
elif self.download_source.lower() == 'biblegateway':
handler = BGExtract()
elif self.download_source.lower() == 'bibleserver':
handler = BSExtract()
books = handler.get_books_from_http(self.download_name)
if not books:
log.error(
'Importing books from {source} - download name: "{name}" '
'failed'.format(source=self.download_source,
name=self.download_name))
return False
self.wizard.progress_bar.setMaximum(len(books) + 2)
self.wizard.increment_progress_bar(
translate('BiblesPlugin.HTTPBible', 'Registering Language...'))
self.language_id = self.get_language_id(bible_name=bible_name)
if not self.language_id:
return False
for book in books:
if self.stop_import_flag:
break
self.wizard.increment_progress_bar(
translate('BiblesPlugin.HTTPBible', 'Importing {book}...',
'Importing <book name>...').format(book=book))
book_ref_id = self.get_book_ref_id_by_name(book, len(books),
self.language_id)
if not book_ref_id:
log.error(
'Importing books from {source} - download name: "{name}" '
'failed'.format(source=self.download_source,
name=self.download_name))
return False
book_details = BiblesResourcesDB.get_book_by_id(book_ref_id)
log.debug('Book details: Name:{book}; id:{ref}; '
'testament_id:{detail}'.format(
book=book,
ref=book_ref_id,
detail=book_details['testament_id']))
self.create_book(book, book_ref_id, book_details['testament_id'])
if self.stop_import_flag:
return False
else:
return True
def do_import(self, bible_name=None):
"""
Run the import. This method overrides the parent class method. Returns ``True`` on success, ``False`` on
failure.
"""
self.wizard.progress_bar.setMaximum(68)
self.wizard.increment_progress_bar(translate('BiblesPlugin.HTTPBible',
'Registering Bible and loading books...'))
self.save_meta('download_source', self.download_source)
self.save_meta('download_name', self.download_name)
if self.proxy_server:
self.save_meta('proxy_server', self.proxy_server)
if self.proxy_username:
# Store the proxy userid.
self.save_meta('proxy_username', self.proxy_username)
if self.proxy_password:
# Store the proxy password.
self.save_meta('proxy_password', self.proxy_password)
if self.download_source.lower() == 'crosswalk':
handler = CWExtract(self.proxy_server)
elif self.download_source.lower() == 'biblegateway':
handler = BGExtract(self.proxy_server)
elif self.download_source.lower() == 'bibleserver':
handler = BSExtract(self.proxy_server)
books = handler.get_books_from_http(self.download_name)
if not books:
log.error('Importing books from {source} - download name: "{name}" '
'failed'.format(source=self.download_source, name=self.download_name))
return False
self.wizard.progress_bar.setMaximum(len(books) + 2)
self.wizard.increment_progress_bar(translate('BiblesPlugin.HTTPBible', 'Registering Language...'))
self.language_id = self.get_language_id(bible_name=bible_name)
if not self.language_id:
return False
for book in books:
if self.stop_import_flag:
break
self.wizard.increment_progress_bar(translate('BiblesPlugin.HTTPBible',
'Importing {book}...',
'Importing <book name>...').format(book=book))
book_ref_id = self.get_book_ref_id_by_name(book, len(books), self.language_id)
if not book_ref_id:
log.error('Importing books from {source} - download name: "{name}" '
'failed'.format(source=self.download_source, name=self.download_name))
return False
book_details = BiblesResourcesDB.get_book_by_id(book_ref_id)
log.debug('Book details: Name:{book}; id:{ref}; '
'testament_id:{detail}'.format(book=book,
ref=book_ref_id,
detail=book_details['testament_id']))
self.create_book(book, book_ref_id, book_details['testament_id'])
if self.stop_import_flag:
return False
else:
return True
def updateAutoCompleter(self):
"""
This updates the bible book completion list for the search field. The
completion depends on the bible. It is only updated when we are doing a
reference search, otherwise the auto completion list is removed.
"""
log.debug('updateAutoCompleter')
# Save the current search type to the configuration.
Settings().setValue('%s/last search type' % self.settings_section, self.quickSearchEdit.current_search_type())
# Save the current bible to the configuration.
Settings().setValue(self.settings_section + '/quick bible', self.quickVersionComboBox.currentText())
books = []
# We have to do a 'Reference Search'.
if self.quickSearchEdit.current_search_type() == BibleSearch.Reference:
bibles = self.plugin.manager.get_bibles()
bible = self.quickVersionComboBox.currentText()
if bible:
book_data = bibles[bible].get_books()
secondbible = self.quickSecondComboBox.currentText()
if secondbible != '':
secondbook_data = bibles[secondbible].get_books()
book_data_temp = []
for book in book_data:
for secondbook in secondbook_data:
if book.book_reference_id == secondbook.book_reference_id:
book_data_temp.append(book)
book_data = book_data_temp
language_selection = self.plugin.manager.get_language_selection(bible)
if language_selection == LanguageSelection.Bible:
books = [book.name + ' ' for book in book_data]
elif language_selection == LanguageSelection.Application:
book_names = BibleStrings().BookNames
for book in book_data:
data = BiblesResourcesDB.get_book_by_id(book.book_reference_id)
books.append(str(book_names[data['abbreviation']]) + ' ')
elif language_selection == LanguageSelection.English:
for book in book_data:
data = BiblesResourcesDB.get_book_by_id(book.book_reference_id)
books.append(data['name'] + ' ')
books.sort(key=get_locale_key)
set_case_insensitive_completer(books, self.quickSearchEdit)
def get_verse_count(self, book_id, chapter):
"""
Return the number of verses for the specified chapter and book.
``book``
The name of the book.
``chapter``
The chapter whose verses are being counted.
"""
log.debug('HTTPBible.get_verse_count("%s", %s)', book_id, chapter)
return BiblesResourcesDB.get_verse_count(book_id, chapter)
def load_bible(self, bible):
"""
Loads a bible.
``bible``
:param bible: The name of the bible.
"""
log.debug('Load Bible')
self.bible = bible
self.version_name_edit.setText(
self.manager.get_meta_data(self.bible, 'name').value)
self.copyright_edit.setText(
self.manager.get_meta_data(self.bible, 'copyright').value)
self.permissions_edit.setText(
self.manager.get_meta_data(self.bible, 'permissions').value)
book_name_language = self.manager.get_meta_data(
self.bible, 'book_name_language')
if book_name_language and book_name_language.value != 'None':
self.language_selection_combo_box.setCurrentIndex(
int(book_name_language.value) + 1)
self.books = {}
self.web_bible = self.manager.get_meta_data(self.bible,
'download_source')
if self.web_bible:
self.book_name_notice.setText(
translate(
'BiblesPlugin.EditBibleForm',
'This is a Web Download Bible.\nIt is not possible to customize the Book Names.'
))
self.scroll_area.hide()
else:
self.book_name_notice.setText(
translate(
'BiblesPlugin.EditBibleForm',
'To use the customized book names, "Bible language" must be selected on the Meta Data tab '
'or, if "Global settings" is selected, on the Bible page in Configure OpenLP.'
))
for book in BiblesResourcesDB.get_books():
self.books[book['abbreviation']] = self.manager.get_book_by_id(
self.bible, book['id'])
if self.books[book['abbreviation']] and not self.web_bible:
self.book_name_edit[book['abbreviation']].setText(
self.books[book['abbreviation']].name)
else:
# It is necessary to remove the Widget otherwise there still
# exists the vertical spacing in QFormLayout
self.book_name_widget_layout.removeWidget(
self.book_name_label[book['abbreviation']])
self.book_name_label[book['abbreviation']].hide()
self.book_name_widget_layout.removeWidget(
self.book_name_edit[book['abbreviation']])
self.book_name_edit[book['abbreviation']].hide()
def do_import(self, bible_name=None):
"""
Loads a Bible from SWORD module.
"""
log.debug('Starting SWORD import from "{key}"'.format(key=self.sword_key))
success = True
try:
pysword_modules = modules.SwordModules(self.sword_path)
pysword_module_json = pysword_modules.parse_modules()[self.sword_key]
bible = pysword_modules.get_bible_from_module(self.sword_key)
language = pysword_module_json['lang']
language = language[language.find('.') + 1:]
language_id = self.get_language_id(language, bible_name=self.filename)
if not language_id:
return False
books = bible.get_structure().get_books()
# Count number of books
num_books = 0
if 'ot' in books:
num_books += len(books['ot'])
if 'nt' in books:
num_books += len(books['nt'])
self.wizard.progress_bar.setMaximum(num_books)
# Import the bible
for testament in books.keys():
for book in books[testament]:
book_ref_id = self.get_book_ref_id_by_name(book.name, num_books, language_id)
book_details = BiblesResourcesDB.get_book_by_id(book_ref_id)
db_book = self.create_book(book_details['name'], book_ref_id, book_details['testament_id'])
for chapter_number in range(1, book.num_chapters + 1):
if self.stop_import_flag:
break
verses = bible.get_iter(book.name, chapter_number)
verse_number = 0
for verse in verses:
verse_number += 1
self.create_verse(db_book.id, chapter_number, verse_number, verse)
self.wizard.increment_progress_bar(
translate('BiblesPlugin.Sword', 'Importing {name}...').format(name=db_book.name))
self.session.commit()
self.application.process_events()
except Exception as e:
critical_error_message_box(
message=translate('BiblesPlugin.SwordImport', 'An unexpected error happened while importing the SWORD '
'bible, please report this to the OpenLP developers.\n'
'{error}').format(error=e))
log.exception(str(e))
success = False
if self.stop_import_flag:
return False
else:
return success
def loadBibleResource(self, download_type):
"""
Loads a web bible from bible_resources.sqlite.
``download_type``
The WebDownload type e.g. bibleserver.
"""
self.web_bible_list[download_type] = {}
bibles = BiblesResourcesDB.get_webbibles(WebDownload.Names[download_type])
for bible in bibles:
version = bible[u'name']
name = bible[u'abbreviation']
self.web_bible_list[download_type][version] = name.strip()
def get_book_ref_id_by_name(self, book, maxbooks=66, language_id=None):
"""
Find the book id from the name or abbreviation of the book. If it doesn't currently exist, ask the user.
:param book: The name or abbreviation of the book
:param maxbooks: The number of books in the bible
:param language_id: The language_id of the bible
:return: The id of the bible, or None
"""
self.log_debug('BibleDB.get_book_ref_id_by_name:("{book}", "{lang}")'.format(book=book, lang=language_id))
book_temp = BiblesResourcesDB.get_book(book, True)
if book_temp:
return book_temp['id']
book_id = BiblesResourcesDB.get_alternative_book_name(book)
if book_id:
return book_id
book_id = AlternativeBookNamesDB.get_book_reference_id(book)
if book_id:
return book_id
from openlp.plugins.bibles.forms import BookNameForm
book_name = BookNameForm(self.wizard)
if book_name.exec(book, self.get_books(), maxbooks) and book_name.book_id:
AlternativeBookNamesDB.create_alternative_book_name(book, book_name.book_id, language_id)
return book_name.book_id
def reload_combo_box(self):
"""
Reload the Combobox items
"""
self.corresponding_combo_box.clear()
items = BiblesResourcesDB.get_books()
for item in items:
add_book = True
for book in self.books:
if book.book_reference_id == item['id']:
add_book = False
break
if self.old_testament_check_box.checkState() == QtCore.Qt.Unchecked and item['testament_id'] == 1:
add_book = False
elif self.new_testament_check_box.checkState() == QtCore.Qt.Unchecked and item['testament_id'] == 2:
add_book = False
elif self.apocrypha_check_box.checkState() == QtCore.Qt.Unchecked and item['testament_id'] == 3:
add_book = False
if add_book:
self.corresponding_combo_box.addItem(self.book_names[item['abbreviation']])
def get_books_from_http(self, version):
"""
Load a list of all books a Bible contains from BiblesResourcesDB.
:param version: The version of the Bible like NIV for New International Version
"""
log.debug('BSExtract.get_books_from_http("{version}")'.format(
version=version))
# Parsing the book list from the website is near impossible, so we use the list from BiblesResourcesDB
bible = BIBLESERVER_TRANSLATIONS[version]
all_books = BiblesResourcesDB.get_books()
books = []
for book in all_books:
if book['testament_id'] == 1 and 'OT' in bible['sections']:
books.append(book['name'])
elif book['testament_id'] == 2 and 'NT' in bible['sections']:
books.append(book['name'])
elif book['testament_id'] == 3 and 'Apocrypha' in bible['sections']:
books.append(book['name'])
return books
def reloadComboBox(self):
"""
Reload the Combobox items
"""
self.correspondingComboBox.clear()
items = BiblesResourcesDB.get_books()
for item in items:
addBook = True
for book in self.books:
if book.book_reference_id == item[u'id']:
addBook = False
break
if self.oldTestamentCheckBox.checkState() == QtCore.Qt.Unchecked and item[u'testament_id'] == 1:
addBook = False
elif self.newTestamentCheckBox.checkState() == QtCore.Qt.Unchecked and item[u'testament_id'] == 2:
addBook = False
elif self.apocryphaCheckBox.checkState() == QtCore.Qt.Unchecked and item[u'testament_id'] == 3:
addBook = False
if addBook:
self.correspondingComboBox.addItem(self.book_names[item[u'abbreviation']])
def load_bible(self, bible):
"""
Loads a bible.
``bible``
:param bible: The name of the bible.
"""
log.debug('Load Bible')
self.bible = bible
self.version_name_edit.setText(self.manager.get_meta_data(self.bible, 'name').value)
self.copyright_edit.setText(self.manager.get_meta_data(self.bible, 'copyright').value)
self.permissions_edit.setText(self.manager.get_meta_data(self.bible, 'permissions').value)
book_name_language = self.manager.get_meta_data(self.bible, 'book_name_language')
if book_name_language and book_name_language.value != 'None':
self.language_selection_combo_box.setCurrentIndex(int(book_name_language.value) + 1)
self.books = {}
self.web_bible = self.manager.get_meta_data(self.bible, 'download_source')
if self.web_bible:
self.book_name_notice.setText(
translate('BiblesPlugin.EditBibleForm',
'This is a Web Download Bible.\nIt is not possible to customize the Book Names.'))
self.scroll_area.hide()
else:
self.book_name_notice.setText(
translate('BiblesPlugin.EditBibleForm',
'To use the customized book names, "Bible language" must be selected on the Meta Data tab '
'or, if "Global settings" is selected, on the Bible page in Configure OpenLP.'))
for book in BiblesResourcesDB.get_books():
self.books[book['abbreviation']] = self.manager.get_book_by_id(self.bible, book['id'])
if self.books[book['abbreviation']] and not self.web_bible:
self.book_name_edit[book['abbreviation']].setText(self.books[book['abbreviation']].name)
else:
# It is necessary to remove the Widget otherwise there still
# exists the vertical spacing in QFormLayout
self.book_name_widget_layout.removeWidget(self.book_name_label[book['abbreviation']])
self.book_name_label[book['abbreviation']].hide()
self.book_name_widget_layout.removeWidget(self.book_name_edit[book['abbreviation']])
self.book_name_edit[book['abbreviation']].hide()
def find_and_create_book(self, name, no_of_books, language_id, guess_id=None):
"""
Find the OpenLP book id and then create the book in this bible db
:param name: Name of the book. If None, then fall back to the guess_id Str
:param no_of_books: The total number of books contained in this bible Int
:param language_id: The OpenLP id of the language of this bible Int
:param guess_id: The guessed id of the book, used if name is None Int
:return:
"""
if name:
book_ref_id = self.get_book_ref_id_by_name(name, no_of_books, language_id)
else:
self.log_debug('No book name supplied. Falling back to guess_id')
book_ref_id = guess_id
if not book_ref_id:
raise ValidationError(msg='Could not resolve book_ref_id in "{}"'.format(self.filename))
book_details = BiblesResourcesDB.get_book_by_id(book_ref_id)
if book_details is None:
raise ValidationError(msg='book_ref_id: {book_ref} Could not be found in the BibleResourcesDB while '
'importing {file}'.format(book_ref=book_ref_id, file=self.filename))
return self.create_book(name, book_ref_id, book_details['testament_id'])
def setupUi(self, edit_bible_dialog):
edit_bible_dialog.setObjectName('edit_bible_dialog')
edit_bible_dialog.resize(520, 400)
edit_bible_dialog.setWindowIcon(build_icon(':/icon/openlp-logo-16x16.png'))
edit_bible_dialog.setModal(True)
self.dialog_layout = QtGui.QVBoxLayout(edit_bible_dialog)
self.dialog_layout.setSpacing(8)
self.dialog_layout.setContentsMargins(8, 8, 8, 8)
self.dialog_layout.setObjectName('dialog_layout')
self.bible_tab_widget = QtGui.QTabWidget(edit_bible_dialog)
self.bible_tab_widget.setObjectName('BibleTabWidget')
# Meta tab
self.meta_tab = QtGui.QWidget()
self.meta_tab.setObjectName('meta_tab')
self.meta_tab_layout = QtGui.QVBoxLayout(self.meta_tab)
self.meta_tab_layout.setObjectName('meta_tab_layout')
self.license_details_group_box = QtGui.QGroupBox(self.meta_tab)
self.license_details_group_box.setObjectName('license_details_group_box')
self.license_details_layout = QtGui.QFormLayout(self.license_details_group_box)
self.license_details_layout.setObjectName('license_details_layout')
self.version_name_label = QtGui.QLabel(self.license_details_group_box)
self.version_name_label.setObjectName('version_name_label')
self.version_name_edit = QtGui.QLineEdit(self.license_details_group_box)
self.version_name_edit.setObjectName('version_name_edit')
self.version_name_label.setBuddy(self.version_name_edit)
self.license_details_layout.addRow(self.version_name_label, self.version_name_edit)
self.copyright_label = QtGui.QLabel(self.license_details_group_box)
self.copyright_label.setObjectName('copyright_label')
self.copyright_edit = QtGui.QLineEdit(self.license_details_group_box)
self.copyright_edit.setObjectName('copyright_edit')
self.copyright_label.setBuddy(self.copyright_edit)
self.license_details_layout.addRow(self.copyright_label, self.copyright_edit)
self.permissions_label = QtGui.QLabel(self.license_details_group_box)
self.permissions_label.setObjectName('permissions_label')
self.permissions_edit = QtGui.QLineEdit(self.license_details_group_box)
self.permissions_edit.setObjectName('permissions_edit')
self.permissions_label.setBuddy(self.permissions_edit)
self.license_details_layout.addRow(self.permissions_label, self.permissions_edit)
self.meta_tab_layout.addWidget(self.license_details_group_box)
self.language_selection_group_box = QtGui.QGroupBox(self.meta_tab)
self.language_selection_group_box.setObjectName('language_selection_group_box')
self.language_selection_layout = QtGui.QVBoxLayout(self.language_selection_group_box)
self.language_selection_label = QtGui.QLabel(self.language_selection_group_box)
self.language_selection_label.setObjectName('language_selection_label')
self.language_selection_combo_box = QtGui.QComboBox(self.language_selection_group_box)
self.language_selection_combo_box.setObjectName('language_selection_combo_box')
self.language_selection_combo_box.addItems(['', '', '', ''])
self.language_selection_layout.addWidget(self.language_selection_label)
self.language_selection_layout.addWidget(self.language_selection_combo_box)
self.meta_tab_layout.addWidget(self.language_selection_group_box)
self.meta_tab_layout.addStretch()
self.bible_tab_widget.addTab(self.meta_tab, '')
# Book name tab
self.book_name_tab = QtGui.QWidget()
self.book_name_tab.setObjectName('book_name_tab')
self.book_name_tab_layout = QtGui.QVBoxLayout(self.book_name_tab)
self.book_name_tab_layout.setObjectName('book_name_tab_layout')
self.book_name_notice = QtGui.QLabel(self.book_name_tab)
self.book_name_notice.setObjectName('book_name_notice')
self.book_name_notice.setWordWrap(True)
self.book_name_tab_layout.addWidget(self.book_name_notice)
self.scroll_area = QtGui.QScrollArea(self.book_name_tab)
self.scroll_area.setWidgetResizable(True)
self.scroll_area.setObjectName('scroll_area')
self.scroll_area.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.book_name_widget = QtGui.QWidget(self.scroll_area)
self.book_name_widget.setObjectName('book_name_widget')
self.book_name_widget_layout = QtGui.QFormLayout(self.book_name_widget)
self.book_name_widget_layout.setObjectName('book_name_widget_layout')
self.book_name_label = {}
self.book_name_edit= {}
for book in BiblesResourcesDB.get_books():
self.book_name_label[book['abbreviation']] = QtGui.QLabel(self.book_name_widget)
self.book_name_label[book['abbreviation']].setObjectName('book_name_label[%s]' % book['abbreviation'])
self.book_name_edit[book['abbreviation']] = QtGui.QLineEdit(self.book_name_widget)
self.book_name_edit[book['abbreviation']].setObjectName('book_name_edit[%s]' % book['abbreviation'])
self.book_name_widget_layout.addRow(
self.book_name_label[book['abbreviation']],
self.book_name_edit[book['abbreviation']])
self.scroll_area.setWidget(self.book_name_widget)
self.book_name_tab_layout.addWidget(self.scroll_area)
self.book_name_tab_layout.addStretch()
self.bible_tab_widget.addTab(self.book_name_tab, '')
# Last few bits
self.dialog_layout.addWidget(self.bible_tab_widget)
self.button_box = create_button_box(edit_bible_dialog, 'button_box', ['cancel', 'save'])
self.dialog_layout.addWidget(self.button_box)
self.retranslateUi(edit_bible_dialog)
QtCore.QMetaObject.connectSlotsByName(edit_bible_dialog)
def do_import(self, bible_name=None):
"""
Imports an openlp.org v1 bible.
"""
connection = None
cursor = None
try:
connection = sqlite.connect(self.filename.encode(sys.getfilesystemencoding()))
cursor = connection.cursor()
except sqlite.DatabaseError:
log.exception(u'File "%s" is encrypted or not a sqlite database, '
'therefore not an openlp.org 1.x database either' % self.filename)
# Please add an user error here!
# This file is not an openlp.org 1.x bible database.
return False
#Create the bible language
language_id = self.get_language(bible_name)
if not language_id:
log.exception(u'Importing books from "%s" failed' % self.filename)
return False
# Create all books.
try:
cursor.execute(u'SELECT id, testament_id, name, abbreviation FROM book')
except sqlite.DatabaseError as error:
log.exception(u'DatabaseError: %s' % error)
# Please add an user error here!
# This file is not an openlp.org 1.x bible database.
return False
books = cursor.fetchall()
self.wizard.progressBar.setMaximum(len(books) + 1)
for book in books:
if self.stop_import_flag:
connection.close()
return False
book_id = int(book[0])
testament_id = int(book[1])
name = unicode(book[2], u'cp1252')
abbreviation = unicode(book[3], u'cp1252')
book_ref_id = self.get_book_ref_id_by_name(name, len(books),
language_id)
if not book_ref_id:
log.exception(u'Importing books from "%s" failed' % self.filename)
return False
book_details = BiblesResourcesDB.get_book_by_id(book_ref_id)
db_book = self.create_book(name, book_ref_id, book_details[u'testament_id'])
# Update the progess bar.
self.wizard.incrementProgressBar(WizardStrings.ImportingType % name)
# Import the verses for this book.
cursor.execute(u'SELECT chapter, verse, text || \'\' AS text FROM '
'verse WHERE book_id=%s' % book_id)
verses = cursor.fetchall()
for verse in verses:
if self.stop_import_flag:
connection.close()
return False
chapter = int(verse[0])
verse_number = int(verse[1])
text = unicode(verse[2], u'cp1252')
self.create_verse(db_book.id, chapter, verse_number, text)
self.application.process_events()
self.session.commit()
connection.close()
return True
def do_import(self, bible_name=None):
"""
Loads a Bible from file.
"""
log.debug('Starting OSIS import from "%s"' % self.filename)
if not isinstance(self.filename, str):
self.filename = str(self.filename, 'utf8')
import_file = None
success = True
try:
# NOTE: We don't need to do any of the normal encoding detection here, because lxml does it's own encoding
# detection, and the two mechanisms together interfere with each other.
import_file = open(self.filename, 'rb')
osis_bible_tree = etree.parse(import_file,
parser=etree.XMLParser(recover=True))
namespace = {
'ns': 'http://www.bibletechnologies.net/2003/OSIS/namespace'
}
# Find bible language
language_id = None
language = osis_bible_tree.xpath("//ns:osisText/@xml:lang",
namespaces=namespace)
if language:
language_id = BiblesResourcesDB.get_language(language[0])
# The language couldn't be detected, ask the user
if not language_id:
language_id = self.get_language(bible_name)
if not language_id:
log.error('Importing books from "%s" failed' % self.filename)
return False
self.save_meta('language_id', language_id)
num_books = int(
osis_bible_tree.xpath("count(//ns:div[@type='book'])",
namespaces=namespace))
self.wizard.increment_progress_bar(
translate(
'BiblesPlugin.OsisImport',
'Removing unused tags (this may take a few minutes)...'))
# We strip unused tags from the XML, this should leave us with only chapter, verse and div tags.
# Strip tags we don't use - remove content
etree.strip_elements(osis_bible_tree, (
'{http://www.bibletechnologies.net/2003/OSIS/namespace}note',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}milestone',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}title',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}abbr',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}catchWord',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}index',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}rdg',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}rdgGroup',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}figure'
),
with_tail=False)
# Strip tags we don't use - keep content
etree.strip_tags(osis_bible_tree, (
'{http://www.bibletechnologies.net/2003/OSIS/namespace}p',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}l',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}lg',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}q',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}a',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}w',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}divineName',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}foreign',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}hi',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}inscription',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}mentioned',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}name',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}reference',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}seg',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}transChange',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}salute',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}signed',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}closer',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}speech',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}speaker',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}list',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}item',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}table',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}head',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}row',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}cell',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}caption'
))
# Precompile a few xpath-querys
verse_in_chapter = etree.XPath('count(//ns:chapter[1]/ns:verse)',
namespaces=namespace)
text_in_verse = etree.XPath('count(//ns:verse[1]/text())',
namespaces=namespace)
# Find books in the bible
bible_books = osis_bible_tree.xpath("//ns:div[@type='book']",
namespaces=namespace)
for book in bible_books:
if self.stop_import_flag:
break
# Remove div-tags in the book
etree.strip_tags(book, (
'{http://www.bibletechnologies.net/2003/OSIS/namespace}div'
))
book_ref_id = self.get_book_ref_id_by_name(
book.get('osisID'), num_books, language_id)
if not book_ref_id:
book_ref_id = self.get_book_ref_id_by_localised_name(
book.get('osisID'))
if not book_ref_id:
log.error('Importing books from "%s" failed' %
self.filename)
return False
book_details = BiblesResourcesDB.get_book_by_id(book_ref_id)
db_book = self.create_book(book_details['name'], book_ref_id,
book_details['testament_id'])
# Find out if chapter-tags contains the verses, or if it is used as milestone/anchor
if int(verse_in_chapter(book)) > 0:
# The chapter tags contains the verses
for chapter in book:
chapter_number = chapter.get("osisID").split('.')[1]
# Find out if verse-tags contains the text, or if it is used as milestone/anchor
if int(text_in_verse(chapter)) == 0:
# verse-tags are used as milestone
for verse in chapter:
# If this tag marks the start of a verse, the verse text is between this tag and
# the next tag, which the "tail" attribute gives us.
if verse.get('sID'):
verse_number = verse.get("osisID").split(
'.')[2]
verse_text = verse.tail
if verse_text:
self.create_verse(
db_book.id, chapter_number,
verse_number, verse_text.strip())
else:
# Verse-tags contains the text
for verse in chapter:
verse_number = verse.get("osisID").split(
'.')[2]
if verse.text:
self.create_verse(db_book.id,
chapter_number,
verse_number,
verse.text.strip())
self.wizard.increment_progress_bar(
translate('BiblesPlugin.OsisImport',
'Importing %(bookname)s %(chapter)s...')
% {
'bookname': db_book.name,
'chapter': chapter_number
})
else:
# The chapter tags is used as milestones. For now we assume verses is also milestones
chapter_number = 0
for element in book:
if element.tag == '{http://www.bibletechnologies.net/2003/OSIS/namespace}chapter' \
and element.get('sID'):
chapter_number = element.get("osisID").split(
'.')[1]
self.wizard.increment_progress_bar(
translate(
'BiblesPlugin.OsisImport',
'Importing %(bookname)s %(chapter)s...') %
{
'bookname': db_book.name,
'chapter': chapter_number
})
elif element.tag == '{http://www.bibletechnologies.net/2003/OSIS/namespace}verse' \
and element.get('sID'):
# If this tag marks the start of a verse, the verse text is between this tag and
# the next tag, which the "tail" attribute gives us.
verse_number = element.get("osisID").split('.')[2]
verse_text = element.tail
if verse_text:
self.create_verse(db_book.id, chapter_number,
verse_number,
verse_text.strip())
self.session.commit()
self.application.process_events()
except (ValueError, IOError):
log.exception('Loading bible from OSIS file failed')
trace_error_handler(log)
success = False
except etree.XMLSyntaxError as e:
log.exception('Loading bible from OSIS file failed')
trace_error_handler(log)
success = False
critical_error_message_box(message=translate(
'BiblesPlugin.OsisImport',
'The file is not a valid OSIS-XML file: \n%s' % e.msg))
finally:
if import_file:
import_file.close()
if self.stop_import_flag:
return False
else:
return success
def setupUi(self, edit_bible_dialog):
edit_bible_dialog.setObjectName('edit_bible_dialog')
edit_bible_dialog.setWindowIcon(build_icon(u':/icon/openlp-logo.svg'))
edit_bible_dialog.resize(520, 400)
edit_bible_dialog.setModal(True)
self.dialog_layout = QtWidgets.QVBoxLayout(edit_bible_dialog)
self.dialog_layout.setSpacing(8)
self.dialog_layout.setContentsMargins(8, 8, 8, 8)
self.dialog_layout.setObjectName('dialog_layout')
self.bible_tab_widget = QtWidgets.QTabWidget(edit_bible_dialog)
self.bible_tab_widget.setObjectName('BibleTabWidget')
# Meta tab
self.meta_tab = QtWidgets.QWidget()
self.meta_tab.setObjectName('meta_tab')
self.meta_tab_layout = QtWidgets.QVBoxLayout(self.meta_tab)
self.meta_tab_layout.setObjectName('meta_tab_layout')
self.license_details_group_box = QtWidgets.QGroupBox(self.meta_tab)
self.license_details_group_box.setObjectName('license_details_group_box')
self.license_details_layout = QtWidgets.QFormLayout(self.license_details_group_box)
self.license_details_layout.setObjectName('license_details_layout')
self.version_name_label = QtWidgets.QLabel(self.license_details_group_box)
self.version_name_label.setObjectName('version_name_label')
self.version_name_edit = QtWidgets.QLineEdit(self.license_details_group_box)
self.version_name_edit.setObjectName('version_name_edit')
self.version_name_label.setBuddy(self.version_name_edit)
self.license_details_layout.addRow(self.version_name_label, self.version_name_edit)
self.copyright_label = QtWidgets.QLabel(self.license_details_group_box)
self.copyright_label.setObjectName('copyright_label')
self.copyright_edit = QtWidgets.QLineEdit(self.license_details_group_box)
self.copyright_edit.setObjectName('copyright_edit')
self.copyright_label.setBuddy(self.copyright_edit)
self.license_details_layout.addRow(self.copyright_label, self.copyright_edit)
self.permissions_label = QtWidgets.QLabel(self.license_details_group_box)
self.permissions_label.setObjectName('permissions_label')
self.permissions_edit = QtWidgets.QLineEdit(self.license_details_group_box)
self.permissions_edit.setObjectName('permissions_edit')
self.permissions_label.setBuddy(self.permissions_edit)
self.license_details_layout.addRow(self.permissions_label, self.permissions_edit)
self.meta_tab_layout.addWidget(self.license_details_group_box)
self.language_selection_group_box = QtWidgets.QGroupBox(self.meta_tab)
self.language_selection_group_box.setObjectName('language_selection_group_box')
self.language_selection_layout = QtWidgets.QVBoxLayout(self.language_selection_group_box)
self.language_selection_label = QtWidgets.QLabel(self.language_selection_group_box)
self.language_selection_label.setObjectName('language_selection_label')
self.language_selection_combo_box = QtWidgets.QComboBox(self.language_selection_group_box)
self.language_selection_combo_box.setObjectName('language_selection_combo_box')
self.language_selection_combo_box.addItems(['', '', '', ''])
self.language_selection_layout.addWidget(self.language_selection_label)
self.language_selection_layout.addWidget(self.language_selection_combo_box)
self.meta_tab_layout.addWidget(self.language_selection_group_box)
self.meta_tab_layout.addStretch()
self.bible_tab_widget.addTab(self.meta_tab, '')
# Book name tab
self.book_name_tab = QtWidgets.QWidget()
self.book_name_tab.setObjectName('book_name_tab')
self.book_name_tab_layout = QtWidgets.QVBoxLayout(self.book_name_tab)
self.book_name_tab_layout.setObjectName('book_name_tab_layout')
self.book_name_notice = QtWidgets.QLabel(self.book_name_tab)
self.book_name_notice.setObjectName('book_name_notice')
self.book_name_notice.setWordWrap(True)
self.book_name_tab_layout.addWidget(self.book_name_notice)
self.scroll_area = QtWidgets.QScrollArea(self.book_name_tab)
self.scroll_area.setWidgetResizable(True)
self.scroll_area.setObjectName('scroll_area')
self.scroll_area.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.book_name_widget = QtWidgets.QWidget(self.scroll_area)
self.book_name_widget.setObjectName('book_name_widget')
self.book_name_widget_layout = QtWidgets.QFormLayout(self.book_name_widget)
self.book_name_widget_layout.setObjectName('book_name_widget_layout')
self.book_name_label = {}
self.book_name_edit = {}
for book in BiblesResourcesDB.get_books():
self.book_name_label[book['abbreviation']] = QtWidgets.QLabel(self.book_name_widget)
self.book_name_label[book['abbreviation']].setObjectName('book_name_label[%s]' % book['abbreviation'])
self.book_name_edit[book['abbreviation']] = QtWidgets.QLineEdit(self.book_name_widget)
self.book_name_edit[book['abbreviation']].setObjectName('book_name_edit[%s]' % book['abbreviation'])
self.book_name_widget_layout.addRow(
self.book_name_label[book['abbreviation']],
self.book_name_edit[book['abbreviation']])
self.scroll_area.setWidget(self.book_name_widget)
self.book_name_tab_layout.addWidget(self.scroll_area)
self.book_name_tab_layout.addStretch()
self.bible_tab_widget.addTab(self.book_name_tab, '')
# Last few bits
self.dialog_layout.addWidget(self.bible_tab_widget)
self.button_box = create_button_box(edit_bible_dialog, 'button_box', ['cancel', 'save'])
self.dialog_layout.addWidget(self.button_box)
self.retranslateUi(edit_bible_dialog)
QtCore.QMetaObject.connectSlotsByName(edit_bible_dialog)
def perform_wizard(self):
"""
Perform the actual upgrade.
"""
self.includeWebBible = False
proxy_server = None
if not self.files:
self.progress_label.setText(
translate('BiblesPlugin.UpgradeWizardForm',
'There are no Bibles that need to be upgraded.'))
self.progress_bar.hide()
return
max_bibles = 0
for number, file in enumerate(self.files):
if self.checkBox[number].checkState() == QtCore.Qt.Checked:
max_bibles += 1
old_bible = None
for number, filename in enumerate(self.files):
# Close the previous bible's connection.
if old_bible is not None:
old_bible.close_connection()
# Set to None to make obvious that we have already closed the
# database.
old_bible = None
if self.stop_import_flag:
self.success[number] = False
break
if not self.checkBox[number].checkState() == QtCore.Qt.Checked:
self.success[number] = False
continue
self.progress_bar.reset()
old_bible = OldBibleDB(self.media_item,
path=self.temp_dir,
file=filename[0])
name = filename[1]
self.progress_label.setText(
translate('BiblesPlugin.UpgradeWizardForm',
'Upgrading Bible %s of %s: "%s"\nUpgrading ...') %
(number + 1, max_bibles, name))
self.new_bibles[number] = BibleDB(self.media_item,
path=self.path,
name=name,
file=filename[0])
self.new_bibles[number].register(self.plugin.upgrade_wizard)
metadata = old_bible.get_metadata()
web_bible = False
meta_data = {}
for meta in metadata:
# Upgrade the names of the metadata keys
if meta['key'] == 'Version':
meta['key'] = 'name'
if meta['key'] == 'Bookname language':
meta['key'] = 'book_name_language'
meta['key'] = meta['key'].lower().replace(' ', '_')
# Copy the metadata
meta_data[meta['key']] = meta['value']
if meta['key'] != 'name' and meta['key'] != 'dbversion':
self.new_bibles[number].save_meta(meta['key'],
meta['value'])
if meta['key'] == 'download_source':
web_bible = True
self.includeWebBible = True
proxy_server = meta.get('proxy_server')
if web_bible:
if meta_data['download_source'].lower() == 'crosswalk':
handler = CWExtract(proxy_server)
elif meta_data['download_source'].lower() == 'biblegateway':
handler = BGExtract(proxy_server)
elif meta_data['download_source'].lower() == 'bibleserver':
handler = BSExtract(proxy_server)
books = handler.get_books_from_http(meta_data['download_name'])
if not books:
log.error(
'Upgrading books from %s - download name: "%s" failed'
% (meta_data['download_source'],
meta_data['download_name']))
self.new_bibles[number].session.close()
del self.new_bibles[number]
critical_error_message_box(
translate('BiblesPlugin.UpgradeWizardForm',
'Download Error'),
translate(
'BiblesPlugin.UpgradeWizardForm',
'To upgrade your Web Bibles an Internet connection is required.'
))
self.increment_progress_bar(
translate('BiblesPlugin.UpgradeWizardForm',
'Upgrading Bible %s of %s: "%s"\nFailed') %
(number + 1, max_bibles, name),
self.progress_bar.maximum() -
self.progress_bar.value())
self.success[number] = False
continue
bible = BiblesResourcesDB.get_webbible(
meta_data['download_name'],
meta_data['download_source'].lower())
if bible and bible['language_id']:
language_id = bible['language_id']
self.new_bibles[number].save_meta('language_id',
language_id)
else:
language_id = self.new_bibles[number].get_language(name)
if not language_id:
log.warning('Upgrading from "%s" failed' % filename[0])
self.new_bibles[number].session.close()
del self.new_bibles[number]
self.increment_progress_bar(
translate('BiblesPlugin.UpgradeWizardForm',
'Upgrading Bible %s of %s: "%s"\nFailed') %
(number + 1, max_bibles, name),
self.progress_bar.maximum() -
self.progress_bar.value())
self.success[number] = False
continue
self.progress_bar.setMaximum(len(books))
for book in books:
if self.stop_import_flag:
self.success[number] = False
break
self.increment_progress_bar(
translate(
'BiblesPlugin.UpgradeWizardForm',
'Upgrading Bible %s of %s: "%s"\nUpgrading %s ...')
% (number + 1, max_bibles, name, book))
book_ref_id = self.new_bibles[number].\
get_book_ref_id_by_name(book, len(books), language_id)
if not book_ref_id:
log.warning(
'Upgrading books from %s - download name: "%s" aborted by user'
% (meta_data['download_source'],
meta_data['download_name']))
self.new_bibles[number].session.close()
del self.new_bibles[number]
self.success[number] = False
break
book_details = BiblesResourcesDB.get_book_by_id(
book_ref_id)
db_book = self.new_bibles[number].create_book(
book, book_ref_id, book_details['testament_id'])
# Try to import already downloaded verses.
oldbook = old_bible.get_book(book)
if oldbook:
verses = old_bible.get_verses(oldbook['id'])
if not verses:
log.warning(
'No verses found to import for book "%s"',
book)
continue
for verse in verses:
if self.stop_import_flag:
self.success[number] = False
break
self.new_bibles[number].create_verse(
db_book.id, int(verse['chapter']),
int(verse['verse']), str(verse['text']))
self.application.process_events()
self.new_bibles[number].session.commit()
else:
language_id = self.new_bibles[number].get_object(
BibleMeta, 'language_id')
if not language_id:
language_id = self.new_bibles[number].get_language(name)
if not language_id:
log.warning('Upgrading books from "%s" failed' % name)
self.new_bibles[number].session.close()
del self.new_bibles[number]
self.increment_progress_bar(
translate('BiblesPlugin.UpgradeWizardForm',
'Upgrading Bible %s of %s: "%s"\nFailed') %
(number + 1, max_bibles, name),
self.progress_bar.maximum() -
self.progress_bar.value())
self.success[number] = False
continue
books = old_bible.get_books()
self.progress_bar.setMaximum(len(books))
for book in books:
if self.stop_import_flag:
self.success[number] = False
break
self.increment_progress_bar(
translate(
'BiblesPlugin.UpgradeWizardForm',
'Upgrading Bible %s of %s: "%s"\nUpgrading %s ...')
% (number + 1, max_bibles, name, book['name']))
book_ref_id = self.new_bibles[
number].get_book_ref_id_by_name(
book['name'], len(books), language_id)
if not book_ref_id:
log.warning(
'Upgrading books from %s " failed - aborted by user'
% name)
self.new_bibles[number].session.close()
del self.new_bibles[number]
self.success[number] = False
break
book_details = BiblesResourcesDB.get_book_by_id(
book_ref_id)
db_book = self.new_bibles[number].create_book(
book['name'], book_ref_id,
book_details['testament_id'])
verses = old_bible.get_verses(book['id'])
if not verses:
log.warning('No verses found to import for book "%s"',
book['name'])
self.new_bibles[number].delete_book(db_book)
continue
for verse in verses:
if self.stop_import_flag:
self.success[number] = False
break
self.new_bibles[number].create_verse(
db_book.id, int(verse['chapter']),
int(verse['verse']), str(verse['text']))
self.application.process_events()
self.new_bibles[number].session.commit()
if not self.success.get(number, True):
self.increment_progress_bar(
translate('BiblesPlugin.UpgradeWizardForm',
'Upgrading Bible %s of %s: "%s"\nFailed') %
(number + 1, max_bibles, name),
self.progress_bar.maximum() - self.progress_bar.value())
else:
self.success[number] = True
self.new_bibles[number].save_meta('name', name)
self.increment_progress_bar(
translate('BiblesPlugin.UpgradeWizardForm',
'Upgrading Bible %s of %s: "%s"\nComplete') %
(number + 1, max_bibles, name))
if number in self.new_bibles:
self.new_bibles[number].session.close()
# Close the last bible's connection if possible.
if old_bible is not None:
old_bible.close_connection()
def do_import(self, bible_name=None):
"""
Loads a Bible from file.
"""
log.debug('Starting Zefania import from "%s"' % self.filename)
if not isinstance(self.filename, str):
self.filename = str(self.filename, 'utf8')
import_file = None
success = True
try:
# NOTE: We don't need to do any of the normal encoding detection here, because lxml does it's own encoding
# detection, and the two mechanisms together interfere with each other.
import_file = open(self.filename, 'rb')
zefania_bible_tree = etree.parse(import_file, parser=etree.XMLParser(recover=True))
# Find bible language
language_id = None
language = zefania_bible_tree.xpath("/XMLBIBLE/INFORMATION/language/text()")
if language:
language_id = BiblesResourcesDB.get_language(language[0])
# The language couldn't be detected, ask the user
if not language_id:
language_id = self.get_language(bible_name)
if not language_id:
log.error('Importing books from "%s" failed' % self.filename)
return False
self.save_meta('language_id', language_id)
num_books = int(zefania_bible_tree.xpath("count(//BIBLEBOOK)"))
# Strip tags we don't use - keep content
etree.strip_tags(zefania_bible_tree, ('STYLE', 'GRAM', 'NOTE', 'SUP', 'XREF'))
# Strip tags we don't use - remove content
etree.strip_elements(zefania_bible_tree, ('PROLOG', 'REMARK', 'CAPTION', 'MEDIA'), with_tail=False)
xmlbible = zefania_bible_tree.getroot()
for BIBLEBOOK in xmlbible:
if self.stop_import_flag:
break
bname = BIBLEBOOK.get('bname')
bnumber = BIBLEBOOK.get('bnumber')
if not bname and not bnumber:
continue
if bname:
book_ref_id = self.get_book_ref_id_by_name(bname, num_books, language_id)
if not book_ref_id:
book_ref_id = self.get_book_ref_id_by_localised_name(bname)
else:
log.debug('Could not find a name, will use number, basically a guess.')
book_ref_id = int(bnumber)
if not book_ref_id:
log.error('Importing books from "%s" failed' % self.filename)
return False
book_details = BiblesResourcesDB.get_book_by_id(book_ref_id)
db_book = self.create_book(book_details['name'], book_ref_id, book_details['testament_id'])
for CHAPTER in BIBLEBOOK:
if self.stop_import_flag:
break
chapter_number = CHAPTER.get("cnumber")
for VERS in CHAPTER:
verse_number = VERS.get("vnumber")
self.create_verse(db_book.id, chapter_number, verse_number, VERS.text.replace('<BR/>', '\n'))
self.wizard.increment_progress_bar(
translate('BiblesPlugin.Zefnia', 'Importing %(bookname)s %(chapter)s...') %
{'bookname': db_book.name, 'chapter': chapter_number})
self.session.commit()
self.application.process_events()
except Exception as e:
critical_error_message_box(
message=translate('BiblesPlugin.ZefaniaImport',
'Incorrect Bible file type supplied. Zefania Bibles may be '
'compressed. You must decompress them before import.'))
log.exception(str(e))
success = False
finally:
if import_file:
import_file.close()
if self.stop_import_flag:
return False
else:
return success
def do_import(self, bible_name=None):
"""
Loads a Bible from file.
"""
log.debug('Starting OSIS import from "%s"' % self.filename)
if not isinstance(self.filename, str):
self.filename = str(self.filename, 'utf8')
import_file = None
success = True
try:
# NOTE: We don't need to do any of the normal encoding detection here, because lxml does it's own encoding
# detection, and the two mechanisms together interfere with each other.
import_file = open(self.filename, 'rb')
osis_bible_tree = etree.parse(import_file, parser=etree.XMLParser(recover=True))
namespace = {'ns': 'http://www.bibletechnologies.net/2003/OSIS/namespace'}
# Find bible language
language_id = None
language = osis_bible_tree.xpath("//ns:osisText/@xml:lang", namespaces=namespace)
if language:
language_id = BiblesResourcesDB.get_language(language[0])
# The language couldn't be detected, ask the user
if not language_id:
language_id = self.get_language(bible_name)
if not language_id:
log.error('Importing books from "%s" failed' % self.filename)
return False
self.save_meta('language_id', language_id)
num_books = int(osis_bible_tree.xpath("count(//ns:div[@type='book'])", namespaces=namespace))
self.wizard.increment_progress_bar(translate('BiblesPlugin.OsisImport',
'Removing unused tags (this may take a few minutes)...'))
# We strip unused tags from the XML, this should leave us with only chapter, verse and div tags.
# Strip tags we don't use - remove content
etree.strip_elements(osis_bible_tree, ('{http://www.bibletechnologies.net/2003/OSIS/namespace}note',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}milestone',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}title',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}abbr',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}catchWord',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}index',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}rdg',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}rdgGroup',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}figure'),
with_tail=False)
# Strip tags we don't use - keep content
etree.strip_tags(osis_bible_tree, ('{http://www.bibletechnologies.net/2003/OSIS/namespace}p',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}l',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}lg',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}q',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}a',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}w',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}divineName',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}foreign',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}hi',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}inscription',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}mentioned',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}name',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}reference',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}seg',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}transChange',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}salute',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}signed',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}closer',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}speech',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}speaker',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}list',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}item',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}table',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}head',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}row',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}cell',
'{http://www.bibletechnologies.net/2003/OSIS/namespace}caption'))
# Precompile a few xpath-querys
verse_in_chapter = etree.XPath('count(//ns:chapter[1]/ns:verse)', namespaces=namespace)
text_in_verse = etree.XPath('count(//ns:verse[1]/text())', namespaces=namespace)
# Find books in the bible
bible_books = osis_bible_tree.xpath("//ns:div[@type='book']", namespaces=namespace)
for book in bible_books:
if self.stop_import_flag:
break
# Remove div-tags in the book
etree.strip_tags(book, ('{http://www.bibletechnologies.net/2003/OSIS/namespace}div'))
book_ref_id = self.get_book_ref_id_by_name(book.get('osisID'), num_books, language_id)
if not book_ref_id:
book_ref_id = self.get_book_ref_id_by_localised_name(book.get('osisID'))
if not book_ref_id:
log.error('Importing books from "%s" failed' % self.filename)
return False
book_details = BiblesResourcesDB.get_book_by_id(book_ref_id)
db_book = self.create_book(book_details['name'], book_ref_id, book_details['testament_id'])
# Find out if chapter-tags contains the verses, or if it is used as milestone/anchor
if int(verse_in_chapter(book)) > 0:
# The chapter tags contains the verses
for chapter in book:
chapter_number = chapter.get("osisID").split('.')[1]
# Find out if verse-tags contains the text, or if it is used as milestone/anchor
if int(text_in_verse(chapter)) == 0:
# verse-tags are used as milestone
for verse in chapter:
# If this tag marks the start of a verse, the verse text is between this tag and
# the next tag, which the "tail" attribute gives us.
if verse.get('sID'):
verse_number = verse.get("osisID").split('.')[2]
verse_text = verse.tail
if verse_text:
self.create_verse(db_book.id, chapter_number, verse_number, verse_text.strip())
else:
# Verse-tags contains the text
for verse in chapter:
verse_number = verse.get("osisID").split('.')[2]
if verse.text:
self.create_verse(db_book.id, chapter_number, verse_number, verse.text.strip())
self.wizard.increment_progress_bar(
translate('BiblesPlugin.OsisImport', 'Importing %(bookname)s %(chapter)s...') %
{'bookname': db_book.name, 'chapter': chapter_number})
else:
# The chapter tags is used as milestones. For now we assume verses is also milestones
chapter_number = 0
for element in book:
if element.tag == '{http://www.bibletechnologies.net/2003/OSIS/namespace}chapter' \
and element.get('sID'):
chapter_number = element.get("osisID").split('.')[1]
self.wizard.increment_progress_bar(
translate('BiblesPlugin.OsisImport', 'Importing %(bookname)s %(chapter)s...') %
{'bookname': db_book.name, 'chapter': chapter_number})
elif element.tag == '{http://www.bibletechnologies.net/2003/OSIS/namespace}verse' \
and element.get('sID'):
# If this tag marks the start of a verse, the verse text is between this tag and
# the next tag, which the "tail" attribute gives us.
verse_number = element.get("osisID").split('.')[2]
verse_text = element.tail
if verse_text:
self.create_verse(db_book.id, chapter_number, verse_number, verse_text.strip())
self.session.commit()
self.application.process_events()
except (ValueError, IOError):
log.exception('Loading bible from OSIS file failed')
trace_error_handler(log)
success = False
except etree.XMLSyntaxError as e:
log.exception('Loading bible from OSIS file failed')
trace_error_handler(log)
success = False
critical_error_message_box(message=translate('BiblesPlugin.OsisImport',
'The file is not a valid OSIS-XML file: \n%s' % e.msg))
finally:
if import_file:
import_file.close()
if self.stop_import_flag:
return False
else:
return success
def do_import(self, bible_name=None):
"""
Loads a Bible from file.
"""
log.debug(u'Starting OSIS import from "%s"' % self.filename)
detect_file = None
db_book = None
osis = None
success = True
last_chapter = 0
match_count = 0
self.wizard.incrementProgressBar(translate('BiblesPlugin.OsisImport',
'Detecting encoding (this may take a few minutes)...'))
try:
detect_file = open(self.filename, u'r')
details = chardet.detect(detect_file.read(1048576))
detect_file.seek(0)
lines_in_file = int(len(detect_file.readlines()))
except IOError:
log.exception(u'Failed to detect OSIS file encoding')
return
finally:
if detect_file:
detect_file.close()
try:
osis = codecs.open(self.filename, u'r', details['encoding'])
repl = replacement
language_id = False
# Decide if the bible propably contains only NT or AT and NT or
# AT, NT and Apocrypha
if lines_in_file < 11500:
book_count = 27
chapter_count = 260
elif lines_in_file < 34200:
book_count = 66
chapter_count = 1188
else:
book_count = 67
chapter_count = 1336
for file_record in osis:
if self.stop_import_flag:
break
# Try to find the bible language
if not language_id:
language_match = self.language_regex.search(file_record)
if language_match:
language = BiblesResourcesDB.get_language(
language_match.group(1))
if language:
language_id = language[u'id']
self.save_meta(u'language_id', language_id)
continue
match = self.verse_regex.search(file_record)
if match:
# Set meta language_id if not detected till now
if not language_id:
language_id = self.get_language(bible_name)
if not language_id:
log.exception(u'Importing books from "%s" failed' % self.filename)
return False
match_count += 1
book = unicode(match.group(1))
chapter = int(match.group(2))
verse = int(match.group(3))
verse_text = match.group(4)
book_ref_id = self.get_book_ref_id_by_name(book, book_count, language_id)
if not book_ref_id:
log.exception(u'Importing books from "%s" failed' % self.filename)
return False
book_details = BiblesResourcesDB.get_book_by_id(book_ref_id)
if not db_book or db_book.name != book_details[u'name']:
log.debug(u'New book: "%s"' % book_details[u'name'])
db_book = self.create_book(
book_details[u'name'],
book_ref_id,
book_details[u'testament_id'])
if last_chapter == 0:
self.wizard.progressBar.setMaximum(chapter_count)
if last_chapter != chapter:
if last_chapter != 0:
self.session.commit()
self.wizard.incrementProgressBar(translate('BiblesPlugin.OsisImport', 'Importing %s %s...',
'Importing <book name> <chapter>...') % (book_details[u'name'], chapter))
last_chapter = chapter
# All of this rigmarol below is because the mod2osis
# tool from the Sword library embeds XML in the OSIS
# but neglects to enclose the verse text (with XML) in
# <[CDATA[ ]]> tags.
verse_text = self.note_regex.sub(u'', verse_text)
verse_text = self.title_regex.sub(u'', verse_text)
verse_text = self.milestone_regex.sub(u'', verse_text)
verse_text = self.fi_regex.sub(u'', verse_text)
verse_text = self.rf_regex.sub(u'', verse_text)
verse_text = self.lb_regex.sub(u' ', verse_text)
verse_text = self.lg_regex.sub(u'', verse_text)
verse_text = self.l_regex.sub(u' ', verse_text)
verse_text = self.w_regex.sub(u'', verse_text)
verse_text = self.q1_regex.sub(u'"', verse_text)
verse_text = self.q2_regex.sub(u'\'', verse_text)
verse_text = self.q_regex.sub(u'', verse_text)
verse_text = self.divine_name_regex.sub(repl, verse_text)
verse_text = self.trans_regex.sub(u'', verse_text)
verse_text = verse_text.replace(u'</lb>', u'') \
.replace(u'</l>', u'').replace(u'<lg>', u'') \
.replace(u'</lg>', u'').replace(u'</q>', u'') \
.replace(u'</div>', u'').replace(u'</w>', u'')
verse_text = self.spaces_regex.sub(u' ', verse_text)
self.create_verse(db_book.id, chapter, verse, verse_text)
self.application.process_events()
self.session.commit()
if match_count == 0:
success = False
except (ValueError, IOError):
log.exception(u'Loading bible from OSIS file failed')
success = False
finally:
if osis:
osis.close()
if self.stop_import_flag:
return False
else:
return success
def do_import(self, bible_name=None):
"""
Loads a Bible from file.
"""
log.debug('Starting OpenSong import from "%s"' % self.filename)
if not isinstance(self.filename, str):
self.filename = str(self.filename, 'utf8')
file = None
success = True
try:
# NOTE: We don't need to do any of the normal encoding detection here, because lxml does it's own encoding
# detection, and the two mechanisms together interfere with each other.
file = open(self.filename, 'r')
opensong = objectify.parse(file)
bible = opensong.getroot()
language_id = self.get_language(bible_name)
if not language_id:
log.exception('Importing books from "%s" failed' % self.filename)
return False
for book in bible.b:
if self.stop_import_flag:
break
book_ref_id = self.get_book_ref_id_by_name(str(book.attrib['n']), len(bible.b), language_id)
if not book_ref_id:
log.exception('Importing books from "%s" failed' % self.filename)
return False
book_details = BiblesResourcesDB.get_book_by_id(book_ref_id)
db_book = self.create_book(str(book.attrib['n']), book_ref_id, book_details['testament_id'])
chapter_number = 0
for chapter in book.c:
if self.stop_import_flag:
break
number = chapter.attrib['n']
if number:
chapter_number = int(number.split()[-1])
else:
chapter_number += 1
verse_number = 0
for verse in chapter.v:
if self.stop_import_flag:
break
number = verse.attrib['n']
if number:
try:
number = int(number)
except ValueError:
verse_parts = number.split('-')
if len(verse_parts) > 1:
number = int(verse_parts[0])
except TypeError:
log.warn('Illegal verse number: %s', str(verse.attrib['n']))
verse_number = number
else:
verse_number += 1
self.create_verse(db_book.id, chapter_number, verse_number, self.get_text(verse))
self.wizard.increment_progress_bar(translate('BiblesPlugin.Opensong', 'Importing %s %s...',
'Importing <book name> <chapter>...')) % (db_book.name, chapter_number)
self.session.commit()
self.application.process_events()
except etree.XMLSyntaxError as inst:
critical_error_message_box(message=translate('BiblesPlugin.OpenSongImport',
'Incorrect Bible file type supplied. OpenSong Bibles may be '
'compressed. You must decompress them before import.'))
log.exception(inst)
success = False
except (IOError, AttributeError):
log.exception('Loading Bible from OpenSong file failed')
success = False
finally:
if file:
file.close()
if self.stop_import_flag:
return False
else:
return success
def do_import(self, bible_name=None):
"""
Import the bible books and verses.
"""
self.wizard.progress_bar.setValue(0)
self.wizard.progress_bar.setMinimum(0)
self.wizard.progress_bar.setMaximum(66)
success = True
language_id = self.get_language(bible_name)
if not language_id:
log.exception('Importing books from "%s" failed' % self.filename)
return False
books_file = None
book_list = {}
# Populate the Tables
try:
details = get_file_encoding(self.booksfile)
books_file = open(self.booksfile, 'r')
if not books_file.read(3) == '\xEF\xBB\xBF':
# no BOM was found
books_file.seek(0)
books_reader = csv.reader(books_file, delimiter=',', quotechar='"')
for line in books_reader:
if self.stop_import_flag:
break
self.wizard.increment_progress_bar(translate('BiblesPlugin.CSVBible', 'Importing books... %s') %
str(line[2], details['encoding']))
book_ref_id = self.get_book_ref_id_by_name(str(line[2], details['encoding']), 67, language_id)
if not book_ref_id:
log.exception('Importing books from "%s" failed' % self.booksfile)
return False
book_details = BiblesResourcesDB.get_book_by_id(book_ref_id)
self.create_book(str(line[2], details['encoding']), book_ref_id, book_details['testament_id'])
book_list[int(line[0])] = str(line[2], details['encoding'])
self.application.process_events()
except (IOError, IndexError):
log.exception('Loading books from file failed')
success = False
finally:
if books_file:
books_file.close()
if self.stop_import_flag or not success:
return False
self.wizard.progress_bar.setValue(0)
self.wizard.progress_bar.setMaximum(67)
verse_file = None
try:
book_ptr = None
details = get_file_encoding(self.versesfile)
verse_file = open(self.versesfile, 'rb')
if not verse_file.read(3) == '\xEF\xBB\xBF':
# no BOM was found
verse_file.seek(0)
verse_reader = csv.reader(verse_file, delimiter=',', quotechar='"')
for line in verse_reader:
if self.stop_import_flag:
break
try:
line_book = book_list[int(line[0])]
except ValueError:
line_book = str(line[0], details['encoding'])
if book_ptr != line_book:
book = self.get_book(line_book)
book_ptr = book.name
self.wizard.increment_progress_bar(translate('BiblesPlugin.CSVBible',
'Importing verses from %s... Importing verses from <book name>...') % book.name)
self.session.commit()
try:
verse_text = str(line[3], details['encoding'])
except UnicodeError:
verse_text = str(line[3], 'cp1252')
self.create_verse(book.id, line[1], line[2], verse_text)
self.wizard.increment_progress_bar(translate('BiblesPlugin.CSVBible', 'Importing verses... done.'))
self.application.process_events()
self.session.commit()
except IOError:
log.exception('Loading verses from file failed')
success = False
finally:
if verse_file:
verse_file.close()
if self.stop_import_flag:
return False
else:
return success
def do_import(self, bible_name=None):
"""
Loads a Bible from file.
"""
log.debug('Starting OpenSong import from "%s"' % self.filename)
if not isinstance(self.filename, str):
self.filename = str(self.filename, 'utf8')
import_file = None
success = True
try:
# NOTE: We don't need to do any of the normal encoding detection here, because lxml does it's own encoding
# detection, and the two mechanisms together interfere with each other.
import_file = open(self.filename, 'rb')
opensong = objectify.parse(import_file)
bible = opensong.getroot()
# Check that we're not trying to import a Zefania XML bible, it is sometimes refered to as 'OpenSong'
if bible.tag.upper() == 'XMLBIBLE':
critical_error_message_box(message=translate(
'BiblesPlugin.OpenSongImport',
'Incorrect Bible file type supplied. This looks like a Zefania XML bible, '
'please use the Zefania import option.'))
return False
# No language info in the opensong format, so ask the user
language_id = self.get_language(bible_name)
if not language_id:
log.error('Importing books from "%s" failed' % self.filename)
return False
for book in bible.b:
if self.stop_import_flag:
break
book_ref_id = self.get_book_ref_id_by_name(
str(book.attrib['n']), len(bible.b), language_id)
if not book_ref_id:
log.error('Importing books from "%s" failed' %
self.filename)
return False
book_details = BiblesResourcesDB.get_book_by_id(book_ref_id)
db_book = self.create_book(book.attrib['n'], book_ref_id,
book_details['testament_id'])
chapter_number = 0
for chapter in book.c:
if self.stop_import_flag:
break
number = chapter.attrib['n']
if number:
chapter_number = int(number.split()[-1])
else:
chapter_number += 1
verse_number = 0
for verse in chapter.v:
if self.stop_import_flag:
break
number = verse.attrib['n']
if number:
try:
number = int(number)
except ValueError:
verse_parts = number.split('-')
if len(verse_parts) > 1:
number = int(verse_parts[0])
except TypeError:
log.warning('Illegal verse number: %s',
str(verse.attrib['n']))
verse_number = number
else:
verse_number += 1
self.create_verse(db_book.id, chapter_number,
verse_number, self.get_text(verse))
self.wizard.increment_progress_bar(
translate('BiblesPlugin.Opensong',
'Importing %(bookname)s %(chapter)s...') % {
'bookname': db_book.name,
'chapter': chapter_number
})
self.session.commit()
self.application.process_events()
except etree.XMLSyntaxError as inst:
trace_error_handler(log)
critical_error_message_box(message=translate(
'BiblesPlugin.OpenSongImport',
'Incorrect Bible file type supplied. OpenSong Bibles may be '
'compressed. You must decompress them before import.'))
log.exception(inst)
success = False
except (IOError, AttributeError):
log.exception('Loading Bible from OpenSong file failed')
success = False
finally:
if import_file:
import_file.close()
if self.stop_import_flag:
return False
else:
return success
def do_import(self, bible_name=None):
"""
Loads a Bible from SWORD module.
"""
log.debug(
'Starting SWORD import from "{key}"'.format(key=self.sword_key))
success = True
try:
pysword_modules = modules.SwordModules(self.sword_path)
pysword_module_json = pysword_modules.parse_modules()[
self.sword_key]
bible = pysword_modules.get_bible_from_module(self.sword_key)
language = pysword_module_json['lang']
language = language[language.find('.') + 1:]
language_id = self.get_language_id(language,
bible_name=str(self.file_path))
if not language_id:
return False
books = bible.get_structure().get_books()
# Count number of books
num_books = 0
if 'ot' in books:
num_books += len(books['ot'])
if 'nt' in books:
num_books += len(books['nt'])
self.wizard.progress_bar.setMaximum(num_books)
# Import the bible
for testament in books.keys():
for book in books[testament]:
book_ref_id = self.get_book_ref_id_by_name(
book.name, num_books, language_id)
book_details = BiblesResourcesDB.get_book_by_id(
book_ref_id)
db_book = self.create_book(book_details['name'],
book_ref_id,
book_details['testament_id'])
for chapter_number in range(1, book.num_chapters + 1):
if self.stop_import_flag:
break
verses = bible.get_iter(book.name, chapter_number)
verse_number = 0
for verse in verses:
verse_number += 1
self.create_verse(db_book.id, chapter_number,
verse_number, verse)
self.wizard.increment_progress_bar(
translate(
'BiblesPlugin.Sword',
'Importing {name}...').format(name=db_book.name))
self.session.commit()
self.application.process_events()
except Exception as e:
critical_error_message_box(message=translate(
'BiblesPlugin.SwordImport',
'An unexpected error happened while importing the SWORD '
'bible, please report this to the OpenLP developers.\n'
'{error}').format(error=e))
log.exception(str(e))
success = False
if self.stop_import_flag:
return False
else:
return success
def do_import(self, bible_name=None):
"""
Import the bible books and verses.
"""
self.wizard.progress_bar.setValue(0)
self.wizard.progress_bar.setMinimum(0)
self.wizard.progress_bar.setMaximum(66)
success = True
language_id = self.get_language(bible_name)
if not language_id:
log.error('Importing books from "%s" failed' % self.filename)
return False
books_file = None
book_list = {}
# Populate the Tables
try:
details = get_file_encoding(self.books_file)
books_file = open(self.books_file,
'r',
encoding=details['encoding'])
books_reader = csv.reader(books_file, delimiter=',', quotechar='"')
for line in books_reader:
if self.stop_import_flag:
break
self.wizard.increment_progress_bar(
translate('BiblesPlugin.CSVBible', 'Importing books... %s')
% line[2])
book_ref_id = self.get_book_ref_id_by_name(
line[2], 67, language_id)
if not book_ref_id:
log.error('Importing books from "%s" failed' %
self.books_file)
return False
book_details = BiblesResourcesDB.get_book_by_id(book_ref_id)
self.create_book(line[2], book_ref_id,
book_details['testament_id'])
book_list.update({int(line[0]): line[2]})
self.application.process_events()
except (IOError, IndexError):
log.exception('Loading books from file failed')
success = False
finally:
if books_file:
books_file.close()
if self.stop_import_flag or not success:
return False
self.wizard.progress_bar.setValue(0)
self.wizard.progress_bar.setMaximum(67)
verse_file = None
try:
book_ptr = None
details = get_file_encoding(self.verses_file)
verse_file = open(self.verses_file,
'r',
encoding=details['encoding'])
verse_reader = csv.reader(verse_file, delimiter=',', quotechar='"')
for line in verse_reader:
if self.stop_import_flag:
break
try:
line_book = book_list[int(line[0])]
except ValueError:
line_book = line[0]
if book_ptr != line_book:
book = self.get_book(line_book)
book_ptr = book.name
self.wizard.increment_progress_bar(
translate('BiblesPlugin.CSVBible',
'Importing verses from %s...' % book.name,
'Importing verses from <book name>...'))
self.session.commit()
verse_text = line[3]
self.create_verse(book.id, line[1], line[2], verse_text)
self.wizard.increment_progress_bar(
translate('BiblesPlugin.CSVBible',
'Importing verses... done.'))
self.application.process_events()
self.session.commit()
except IOError:
log.exception('Loading verses from file failed')
success = False
finally:
if verse_file:
verse_file.close()
if self.stop_import_flag:
return False
else:
return success
def load_bible(self, bible):
"""
Loads a bible.
``bible``
:param bible: The name of the bible.
"""
log.debug('Load Bible')
self.bible = bible
book_name_language = self.manager.get_meta_data(
self.bible, 'book_name_language')
"""
Try loading the metadata, if the field does not exist in the metadata, continue executing the code,
missing fields will be created on "self.accept" (save).
"""
meta = self.manager.get_meta_data(self.bible, 'name')
copyright = self.manager.get_meta_data(self.bible, 'copyright')
permission = self.manager.get_meta_data(self.bible, 'permissions')
full_license = self.manager.get_meta_data(self.bible, 'full_license')
if meta:
self.version_name_edit.setText(meta.value)
if copyright:
self.copyright_edit.setText(copyright.value)
if permission:
self.permissions_edit.setText(permission.value)
if full_license:
self.full_license_edit.setPlainText(full_license.value)
# Set placeholder texts for the fields.
self.version_name_edit.setPlaceholderText(
UiStrings().RequiredShowInFooter)
self.copyright_edit.setPlaceholderText(
UiStrings().RequiredShowInFooter)
self.permissions_edit.setPlaceholderText(
UiStrings().OptionalShowInFooter)
self.full_license_edit.setPlaceholderText(
UiStrings().OptionalHideInFooter)
if book_name_language and book_name_language.value != 'None':
self.language_selection_combo_box.setCurrentIndex(
int(book_name_language.value) + 1)
self.books = {}
self.web_bible = self.manager.get_meta_data(self.bible,
'download_source')
if self.web_bible:
self.book_name_notice.setText(
translate(
'BiblesPlugin.EditBibleForm',
'This is a Web Download Bible.\nIt is not possible to customize the Book Names.'
))
self.scroll_area.hide()
else:
self.book_name_notice.setText(
translate(
'BiblesPlugin.EditBibleForm',
'To use the customized book names, "Bible language" must be selected on the Meta Data tab '
'or, if "Global settings" is selected, on the Bible page in Configure OpenLP.'
))
for book in BiblesResourcesDB.get_books():
self.books[book['abbreviation']] = self.manager.get_book_by_id(
self.bible, book['id'])
if self.books[book['abbreviation']] and not self.web_bible:
self.book_name_edit[book['abbreviation']].setText(
self.books[book['abbreviation']].name)
else:
# It is necessary to remove the Widget otherwise there still
# exists the vertical spacing in QFormLayout
self.book_name_widget_layout.removeWidget(
self.book_name_label[book['abbreviation']])
self.book_name_label[book['abbreviation']].hide()
self.book_name_widget_layout.removeWidget(
self.book_name_edit[book['abbreviation']])
self.book_name_edit[book['abbreviation']].hide()
def performWizard(self):
"""
Perform the actual upgrade.
"""
self.includeWebBible = False
proxy_server = None
if not self.files:
self.progress_label.setText(translate('BiblesPlugin.UpgradeWizardForm',
'There are no Bibles that need to be upgraded.'))
self.progress_bar.hide()
return
max_bibles = 0
for number, file in enumerate(self.files):
if self.checkBox[number].checkState() == QtCore.Qt.Checked:
max_bibles += 1
old_bible = None
for number, filename in enumerate(self.files):
# Close the previous bible's connection.
if old_bible is not None:
old_bible.close_connection()
# Set to None to make obvious that we have already closed the
# database.
old_bible = None
if self.stop_import_flag:
self.success[number] = False
break
if not self.checkBox[number].checkState() == QtCore.Qt.Checked:
self.success[number] = False
continue
self.progress_bar.reset()
old_bible = OldBibleDB(self.media_item, path=self.temp_dir,
file=filename[0])
name = filename[1]
self.progress_label.setText(translate('BiblesPlugin.UpgradeWizardForm',
'Upgrading Bible %s of %s: "%s"\nUpgrading ...') % (number + 1, max_bibles, name))
self.new_bibles[number] = BibleDB(self.media_item, path=self.path, name=name, file=filename[0])
self.new_bibles[number].register(self.plugin.upgrade_wizard)
metadata = old_bible.get_metadata()
web_bible = False
meta_data = {}
for meta in metadata:
# Upgrade the names of the metadata keys
if meta['key'] == 'Version':
meta['key'] = 'name'
if meta['key'] == 'Bookname language':
meta['key'] = 'book_name_language'
meta['key'] = meta['key'].lower().replace(' ', '_')
# Copy the metadata
meta_data[meta['key']] = meta['value']
if meta['key'] != 'name' and meta['key'] != 'dbversion':
self.new_bibles[number].save_meta(meta['key'], meta['value'])
if meta['key'] == 'download_source':
web_bible = True
self.includeWebBible = True
proxy_server = meta.get('proxy_server')
if web_bible:
if meta_data['download_source'].lower() == 'crosswalk':
handler = CWExtract(proxy_server)
elif meta_data['download_source'].lower() == 'biblegateway':
handler = BGExtract(proxy_server)
elif meta_data['download_source'].lower() == 'bibleserver':
handler = BSExtract(proxy_server)
books = handler.get_books_from_http(meta_data['download_name'])
if not books:
log.error('Upgrading books from %s - download name: "%s" failed' % (
meta_data['download_source'], meta_data['download_name']))
self.new_bibles[number].session.close()
del self.new_bibles[number]
critical_error_message_box(
translate('BiblesPlugin.UpgradeWizardForm', 'Download Error'),
translate('BiblesPlugin.UpgradeWizardForm',
'To upgrade your Web Bibles an Internet connection is required.'))
self.increment_progress_bar(translate(
'BiblesPlugin.UpgradeWizardForm', 'Upgrading Bible %s of %s: "%s"\nFailed') %
(number + 1, max_bibles, name), self.progress_bar.maximum() - self.progress_bar.value())
self.success[number] = False
continue
bible = BiblesResourcesDB.get_webbible(
meta_data['download_name'],
meta_data['download_source'].lower())
if bible and bible['language_id']:
language_id = bible['language_id']
self.new_bibles[number].save_meta('language_id',
language_id)
else:
language_id = self.new_bibles[number].get_language(name)
if not language_id:
log.warn('Upgrading from "%s" failed' % filename[0])
self.new_bibles[number].session.close()
del self.new_bibles[number]
self.increment_progress_bar(translate('BiblesPlugin.UpgradeWizardForm',
'Upgrading Bible %s of %s: "%s"\nFailed') % (number + 1, max_bibles, name),
self.progress_bar.maximum() - self.progress_bar.value())
self.success[number] = False
continue
self.progress_bar.setMaximum(len(books))
for book in books:
if self.stop_import_flag:
self.success[number] = False
break
self.increment_progress_bar(translate('BiblesPlugin.UpgradeWizardForm',
'Upgrading Bible %s of %s: "%s"\nUpgrading %s ...') % (number + 1, max_bibles, name, book))
book_ref_id = self.new_bibles[number].\
get_book_ref_id_by_name(book, len(books), language_id)
if not book_ref_id:
log.warn('Upgrading books from %s - download name: "%s" aborted by user' % (
meta_data['download_source'], meta_data['download_name']))
self.new_bibles[number].session.close()
del self.new_bibles[number]
self.success[number] = False
break
book_details = BiblesResourcesDB.get_book_by_id(book_ref_id)
db_book = self.new_bibles[number].create_book(book,
book_ref_id, book_details['testament_id'])
# Try to import already downloaded verses.
oldbook = old_bible.get_book(book)
if oldbook:
verses = old_bible.get_verses(oldbook['id'])
if not verses:
log.warn('No verses found to import for book "%s"', book)
continue
for verse in verses:
if self.stop_import_flag:
self.success[number] = False
break
self.new_bibles[number].create_verse(db_book.id,
int(verse['chapter']),
int(verse['verse']), str(verse['text']))
self.application.process_events()
self.new_bibles[number].session.commit()
else:
language_id = self.new_bibles[number].get_object(BibleMeta, 'language_id')
if not language_id:
language_id = self.new_bibles[number].get_language(name)
if not language_id:
log.warn('Upgrading books from "%s" failed' % name)
self.new_bibles[number].session.close()
del self.new_bibles[number]
self.increment_progress_bar(translate('BiblesPlugin.UpgradeWizardForm',
'Upgrading Bible %s of %s: "%s"\nFailed') % (number + 1, max_bibles, name),
self.progress_bar.maximum() - self.progress_bar.value())
self.success[number] = False
continue
books = old_bible.get_books()
self.progress_bar.setMaximum(len(books))
for book in books:
if self.stop_import_flag:
self.success[number] = False
break
self.increment_progress_bar(translate('BiblesPlugin.UpgradeWizardForm',
'Upgrading Bible %s of %s: "%s"\nUpgrading %s ...') %
(number + 1, max_bibles, name, book['name']))
book_ref_id = self.new_bibles[number].get_book_ref_id_by_name(book['name'], len(books), language_id)
if not book_ref_id:
log.warn('Upgrading books from %s " failed - aborted by user' % name)
self.new_bibles[number].session.close()
del self.new_bibles[number]
self.success[number] = False
break
book_details = BiblesResourcesDB.get_book_by_id(book_ref_id)
db_book = self.new_bibles[number].create_book(book['name'],
book_ref_id, book_details['testament_id'])
verses = old_bible.get_verses(book['id'])
if not verses:
log.warn('No verses found to import for book "%s"', book['name'])
self.new_bibles[number].delete_book(db_book)
continue
for verse in verses:
if self.stop_import_flag:
self.success[number] = False
break
self.new_bibles[number].create_verse(db_book.id,
int(verse['chapter']),
int(verse['verse']), str(verse['text']))
self.application.process_events()
self.new_bibles[number].session.commit()
if not self.success.get(number, True):
self.increment_progress_bar(translate('BiblesPlugin.UpgradeWizardForm',
'Upgrading Bible %s of %s: "%s"\nFailed') % (number + 1, max_bibles, name),
self.progress_bar.maximum() - self.progress_bar.value())
else:
self.success[number] = True
self.new_bibles[number].save_meta('name', name)
self.increment_progress_bar(translate('BiblesPlugin.UpgradeWizardForm',
'Upgrading Bible %s of %s: "%s"\nComplete') % (number + 1, max_bibles, name))
if number in self.new_bibles:
self.new_bibles[number].session.close()
# Close the last bible's connection if possible.
if old_bible is not None:
old_bible.close_connection()
