def listModules(self, c, args):
modules = SwordModules()
result = []
try:
found_modules = modules.parse_modules()
except FileNotFoundError:
category = 'list'
else:
for key in found_modules:
row = []
row.append(key)
#for item in found_modules[key]:
# row.append(found_modules[key][item])
row.append(found_modules[key]['lang'])
row.append(found_modules[key]['about'].replace('\par', "\n"))
row.append(found_modules[key]['version'])
if len(args) == 1:
category = "itemized"
if found_modules[key]['lang'] == args[0]:
result.append(row)
else:
category = "table"
result.append(row)
result_object = Result()
result_object.category = category
result_object.payload = sorted(result)
return result_object
def __init__(self, indices):
# loads first available bible in current directory
# TODO: give user choice
self.indices = indices
self.bible = None
zips = glob.glob("*.zip")
for zipfile in zips:
modules = SwordModules(zipfile)
found_modules = modules.parse_modules()
found_module_keys = list(found_modules.keys())
if len(found_module_keys) == 0:
continue
else:
module_key_choice = found_module_keys[0]
self.bible = modules.get_bible_from_module(module_key_choice)
self.zipfile = zipfile
print("Loaded bible from " + str(zipfile))
if self.bible is None:
raise NoOfflineBibleException("No bibles found")
self.bible = modules.get_bible_from_module(module_key_choice)
def test_load_sparv1909_zip(self):
"""
Test that the encrypted SpaRV1909.zip file is loaded correctly.
"""
# GIVEN: The SpaRV1909.zip file
modules = SwordModules(
os.path.join(TEST_RESOURCE_FOLDER, u'SpaRV1909.zip'))
# WHEN: Parsing the SpaRV1909 module and reading a passage.
found_modules = modules.parse_modules()
bible = modules.get_bible_from_module(u'SpaRV1909')
output = bible.get(books=[u'gen'], chapters=[3], verses=[20])
# THEN: The SpaRV1909 module should be the only one found. And the passage should be equal to the known text.
assert u'SpaRV1909' in found_modules
assert len(found_modules) == 1
print(output)
assert output == u'Y llamó el hombre el nombre de su mujer, Eva; por cuanto ella era madre de todos ' \
u'los vivientes.'
# WHEN: Reading a second passage
output = bible.get(books=[u'john'], chapters=[3], verses=[17])
# THEN: The the passage should be equal to the expected text
assert output == u'Porque no envió Dios á su Hijo al mundo para que condene al mundo, mas para ' \
u'que el mundo sea salvo por él.'
def test_parse_modules_folder(self):
"""
Test that conf file from a folder can be parsed.
"""
# GIVEN: A SwordModules object using a folder for input
modules = SwordModules(TEST_RESOURCE_FOLDER)
# WHEN: parsing the modules conf files
mods_metadata = modules.parse_modules()
# THEN: Modules should be detectable and information extractable
module_list = [
u'ChiPinyin', u'FinPR', u'BSV', u'ASV', u'AraNAV', u'SpaRV1909'
]
self.assertTrue(all(x in module_list for x in mods_metadata.keys()),
u'Some expected bibles were not detected')
# Depending on the operating system, the handling of non-utf8 encoded conf-files is different
self.assertEqual(mods_metadata[u'FinPR'][u'description'],
u'Finnish Pyhä Raamattu (1933/1938)',
u'Could not extract "description" for "FinPR"')
self.assertEqual(mods_metadata[u'BSV'][u'description'],
u'The Bond Slave Version Bible',
u'Could not extract "description" for "BSV"')
self.assertEqual(mods_metadata[u'ASV'][u'description'],
u'American Standard Version (1901)',
u'Could not extract "description" for "ASV"')
self.assertEqual(mods_metadata[u'AraNAV'][u'description'],
u'New Arabic Version (Ketab El Hayat)',
u'Could not extract "description" for "AraNAV"')
def generate_dict(source_file, bible_version):
modules = SwordModules(source_file)
found_modules = modules.parse_modules()
bible = modules.get_bible_from_module(bible_version)
books = bible.get_structure()._books['ot'] + bible.get_structure()._books['nt']
bib = {}
bib['books'] = []
for book in books:
chapters = []
for chapter in xrange(1, book.num_chapters+1):
verses = []
for verse in xrange(1, len(book.get_indicies(chapter))+1 ):
verses.append({
'verse': verse,
'chapter': chapter,
'name': book.name + " " + str(chapter) + ":" + str(verse),
'text': bible.get(books=[book.name], chapters=[chapter], verses=[verse])
})
chapters.append({
'chapter': chapter,
'name': book.name + " " + str(chapter),
'verses': verses
})
bib['books'].append({
'name': book.name,
'chapters': chapters
})
return bib
def __init__(self,
left,
right,
modules_dir="Modules/",
hyphen_lang="en_GB"):
self.left = left
self.right = right
modules = SwordModules(modules_dir + left + '.zip')
found_modules = modules.parse_modules()
self.bible1 = modules.get_bible_from_module(left)
self.books1 = self.bible1.get_structure().get_books()
self.books1 = self.books1.get('ot', []) + self.books1.get('nt', [])
modules = SwordModules(modules_dir + right + '.zip')
found_modules = modules.parse_modules()
self.bible2 = modules.get_bible_from_module(right)
self.books2 = self.bible2.get_structure().get_books()
self.books2 = self.books2['ot'] + self.books2['nt']
self.uuid = str(uuid.uuid4())
self.hyphenator2 = pyphen.Pyphen(lang=hyphen_lang)
def __init__(self, library_path):
self.library_path = library_path
self.modules = {}
for filename in os.listdir(self.library_path):
if filename.endswith(".zip"):
try:
zip_modules = SwordModules(os.path.join(self.library_path, filename))
except:
raise # DEBUG - Remove when issues have been sorted out
continue
discovered = zip_modules.parse_modules()
for m in discovered:
self.modules[m] = Bible(m, zip_modules.get_bible_from_module(m))
if discovered[m]["feature"] == "NoParagraphs":
self.modules[m].use_paragraphs = False
def test_load_asv_zip(self):
"""
Test that the ASV.zip file is loaded correctly.
"""
# GIVEN: The ASV.zip file
modules = SwordModules(os.path.join(TEST_RESOURCE_FOLDER, u'ASV.zip'))
# WHEN: Parsing the ASV module and reading a passage.
found_modules = modules.parse_modules()
bible = modules.get_bible_from_module(u'ASV')
output = bible.get(books=[u'gen'], chapters=[3], verses=[20])
# THEN: The ASV module should be the only one found. And the passage should be equal to the known text.
assert u'ASV' in found_modules
assert len(found_modules) == 1
assert output == u'And the man called his wife’s name Eve; because she was the mother of all living.'
def test_load_bsv_zip(self):
"""
Test that the bsv.zip file is loaded correctly.
"""
# GIVEN: The bsv.zip file
modules = SwordModules(os.path.join(TEST_RESOURCE_FOLDER, u'bsv.zip'))
# WHEN: Parsing the BSV module and reading a passage.
found_modules = modules.parse_modules()
bible = modules.get_bible_from_module(u'BSV')
output = bible.get(books=[u'john'], chapters=[3], verses=[16])
# THEN: The BSV module should be the only one found. And the passage should be equal to the known text.
assert u'BSV' in found_modules
assert len(found_modules) == 1
assert output == u'For God so loved the world, that he gave his only begotten Son, that whoever believes in ' \
u'him should not perish, but have everlasting life.'
def test_load_finpr_zip(self):
"""
Test that the FinPR.zip file is loaded correctly.
"""
# GIVEN: The FinPR.zip file
modules = SwordModules(os.path.join(TEST_RESOURCE_FOLDER,
u'FinPR.zip'))
# WHEN: Parsing the FinPR module and reading a passage.
found_modules = modules.parse_modules()
bible = modules.get_bible_from_module(u'FinPR')
output = bible.get(books=[u'john'], chapters=[3], verses=[16])
# THEN: The FinPR module should be the only one found. And the passage should be equal to the known text.
assert u'FinPR' in found_modules
assert len(found_modules) == 1
assert output == u'Sillä niin on Jumala maailmaa rakastanut, että hän antoi ainokaisen Poikansa, ' \
u'ettei yksikään, joka häneen uskoo, hukkuisi, vaan hänellä olisi iankaikkinen elämä.'
def test_load_chipinyin_zip(self):
"""
Test that the chipinyin.zip file is loaded correctly.
"""
# GIVEN: The chipinyin.zip file
modules = SwordModules(
os.path.join(TEST_RESOURCE_FOLDER, u'chipinyin.zip'))
# WHEN: Parsing the chipinyin module and reading a passage.
found_modules = modules.parse_modules()
bible = modules.get_bible_from_module(u'ChiPinyin')
output = bible.get(books=[u'john'], chapters=[3], verses=[16])
# THEN: The ChiPinyin module should be the only one found. And the passage should be equal to the known text.
assert u'ChiPinyin' in found_modules
assert len(found_modules) == 1
assert output == u' Shén aì shìrén , shènzhì jiāng tāde dú shēng zǐ cìgĕi tāmen , jiào yīqiè xìn tāde , bú ' \
u'zhì mièwáng , fǎn dé yǒngshēng . '
def test_parse_modules_zip(self):
"""
Test that conf file from a zip can be parsed.
"""
# GIVEN: A SwordModules object using a folder for input
modules = SwordModules(os.path.join(TEST_RESOURCE_FOLDER,
u'FinPR.zip'))
# WHEN: parsing the modules conf files
mods_metadata = modules.parse_modules()
# THEN: Modules should be detectable and information extractable
self.assertEqual(1, len(mods_metadata.keys()),
u'There should be only 1 module in a zip.')
self.assertIn(u'FinPR', mods_metadata.keys(),
u'FinPR should be available')
self.assertEqual(mods_metadata['FinPR']['description'],
u'Finnish Pyhä Raamattu (1933/1938)',
u'Could not extract "description" for "FinPR"')
def test_load_aranav_zip(self):
"""
Test that the AraNAV.zip file is loaded correctly.
"""
# GIVEN: The AraNAV.zip file
modules = SwordModules(
os.path.join(TEST_RESOURCE_FOLDER, u'AraNAV.zip'))
# WHEN: Parsing the AraNAV module and reading a passage.
found_modules = modules.parse_modules()
bible = modules.get_bible_from_module(u'AraNAV')
output = bible.get(books=[u'rev'], chapters=[22], verses=[19])
# THEN: The AraNAV module should be the only one found.
assert u'AraNAV' in found_modules
assert len(found_modules) == 1
# The passage should be empty since that verse is not in this translation.
assert output.strip(
) == u' وَلْتَكُنْ نِعْمَةُ رَبِّنَا يَسُوعَ الْمَسِيحِ مَعَكُمْ جَمِيعاً.'.strip(
)
def _import_bible_format():
prog_dict = {}
prog_dict[FORMAT_MYBIBLE] = MyBibleFormat()
prog_dict[FORMAT_MYSWORD] = MySwordFormat()
try:
from pysword.modules import SwordModules
modules = SwordModules()
found_modules = modules.parse_modules()
prog_dict[FORMAT_SWORD] = SwordFormat(modules, found_modules)
except ImportError:
pass
except FileNotFoundError:
pass
prog_dict[FORMAT_ZEFANIA] = ZefaniaFormat()
return prog_dict
def listLanguages(self, c, a):
result_object = Result()
result = []
modules = SwordModules()
try:
found_modules = modules.parse_modules()
except FileNotFoundError:
result_object.category = "error"
result_object.error = "no sword modules could be found!"
else:
for main_key in found_modules:
language = found_modules[main_key]['lang']
if not language in result:
result.append(language)
result = sorted(result)
result_object.category = "list"
result_object.payload = result
return result_object
def generate_sqlite(source, bible_version):
# Create sqlite file
db = sqlite3.connect(bible_version + ".sqlite", isolation_level=None)
# Create table if not exists
db.cursor().execute("CREATE TABLE IF NOT EXISTS key_" + bible_version +
" (book Int,name varchar);")
db.cursor().execute("CREATE TABLE IF NOT EXISTS " + bible_version +
" (book Int,chapter Int,verse Int,text varchar);")
# Define query
query_key = "INSERT INTO key_" + bible_version + " values (?,?)"
query_verse = "INSERT INTO " + bible_version + " values (?,?,?,?)"
query_delete = "DELETE FROM "
# Remove table if any exists
db.cursor().execute(query_delete + "key_" + bible_version)
db.cursor().execute(query_delete + bible_version)
# Get books data from module
modules = SwordModules(source)
found_modules = modules.parse_modules()
bible = modules.get_bible_from_module(bible_version)
books = bible.get_structure()._books['ot'] + bible.get_structure(
)._books['nt']
for idx, book in enumerate(books, start=1):
loadingBar(idx, len(books), 2)
db.cursor().execute(query_key, (idx, book.name))
for chapter in xrange(1, book.num_chapters + 1):
for verse in xrange(1, len(book.get_indicies(chapter)) + 1):
db.cursor().execute(query_verse, (idx, chapter, verse,
bible.get(books=[book.name],
chapters=[chapter],
verses=[verse])))
print("Yay!!")
def get_bible_json(path, overwrite):
modules = SwordModules(path)
found_modules = modules.parse_modules()
keys = found_modules.keys()
version = list(keys)[0]
validate = Validate(version)
report = Report(version)
validate.keys(len(keys))
comparator = get_comparator(version)
exists_obj = does_bible_json_exist(version)
if exists_obj['exists'] and not overwrite:
print(f'{version} - skipping')
return None
bible = modules.get_bible_from_module(version)
# noinspection PyProtectedMember
raw_books = bible.get_structure()._books['ot'] + bible.get_structure()._books['nt']
validate.books(len(raw_books))
print('==================================================')
print(f'{version} - processing in progress, please wait')
chapter_count = 0
all_verses = []
omitted_verses = []
actual_eoc_differences = []
books = []
start = time.time()
for book_idx, book in enumerate(raw_books):
# TODO: Add more checks based on book info
# pprint(vars(book))
report.processed(book_idx + 1, book.osis_name, start)
range_chapters = range(1, book.num_chapters + 1)
chapters = []
for chapter in range_chapters:
raw_verses = book.get_indicies(chapter)
verses = []
for verseIdx, verse in enumerate(raw_verses):
verse_ref = book.osis_name + ' ' + str(chapter) + ':' + str(verseIdx + 1)
try:
text = bible.get(books=[book.name], chapters=[chapter], verses=[verseIdx + 1])
except Exception as e:
if 'incorrect header' in str(e):
if verse_ref in omissible_verses or verse_ref in permissible_eoc_differences:
text = None
else:
print(f'{version} - aborting with error on {verse_ref}')
print(f'{version} - {str(e)}')
return None
else:
raise e
# if verse_ref == 'Romans 16:25':
# print(f'{verse_ref} = "{text}"')
if text is not None:
text = text.strip()
if text == '':
text = None
if text is None:
if verse_ref in omissible_verses:
omitted_verses.append(verse_ref)
elif verse_ref in permissible_eoc_differences:
pass
else:
raise Exception(f'{version} - text is none for {verse_ref}')
else:
if comparator is not None:
text = comparator.compare(text)
verse = {
'verse': verseIdx + 1,
'chapter': chapter,
'ref': verse_ref,
'text': text
}
verses.append(verse)
all_verses.append(verse)
# TODO: Add testament
chapters.append({
'chapter': chapter,
'name': book.osis_name + ' ' + str(chapter),
'verses': verses
})
chapter_count += len(chapters)
books.append({
'name': book.osis_name,
'chapters': chapters
})
for eoc_difference in permissible_eoc_differences:
eoc_verse = next((x for x in all_verses if x['ref'] == eoc_difference), None)
if eoc_verse is None:
actual_eoc_differences.append(eoc_difference)
report.summary(len(books), chapter_count, len(all_verses))
report.omitted(omitted_verses)
report.eoc(actual_eoc_differences)
validate.chapters(chapter_count)
passed_extra_verse_checks = validate.verses(len(all_verses), actual_eoc_differences, omitted_verses)
return {
'version': version,
'omittedVerses': omitted_verses,
'endOfChapterDifferences': actual_eoc_differences,
'verseCount': len(all_verses),
'passedExtraVerseChecks': passed_extra_verse_checks,
'books': books
}
def get_bible_dict(source_file, bible_version, output_path, current_counter,
next_counter):
# set some counter values
counter = int(current_counter)
current = int(current_counter)
next = int(next_counter)
# load the sword module
module = SwordModules(source_file)
# get the config
module_config = module.parse_modules()[bible_version]
# load the bible version
bible_mod = module.get_bible_from_module(bible_version)
# load the list of books per/testament
testaments = bible_mod.get_structure()._books
# merge the books
books = []
for testament in testaments:
books += testaments[testament]
# set the abbreviation
abbreviation = v1_translation_names.get(bible_version,
bible_version.lower())
# get v1 Book Names (some are in the same language)
v1_book_names = {}
# check if this translations was in v1
if bible_version in v1_translation_names:
try:
v1_book_names = requests.get('https://getbible.net/v1/' +
abbreviation + '/books.json').json()
except ValueError:
# no json found
v1_book_names = {}
# start to build the complete scripture of the translation
bible_ = {}
bible_['translation'] = v1_translations.get(
abbreviation, module_config.get('description', bible_version))
bible_['abbreviation'] = abbreviation
bible_['discription'] = module_config.get('description', '')
# set language
lang_ = module_config.get('lang', '')
bible_['lang'] = lang_correction.get(lang_, lang_)
bible_['language'] = language_names.get(lang_, '')
bible_['direction'] = text_direction.get(lang_, 'LTR')
# not sure if this is relevant seeing that json.dump ensure_ascii=True
bible_['encoding'] = module_config.get('encoding', '')
# set global book
bible_book = {
'translation': bible_.get('translation'),
'abbreviation': abbreviation,
'lang': bible_.get('lang'),
'language': bible_.get('language'),
'direction': bible_.get('direction', 'LTR'),
'encoding': bible_.get('encoding')
}
# set global chapter
bible_chapter = {
'translation': bible_.get('translation'),
'abbreviation': abbreviation,
'lang': bible_.get('lang'),
'language': bible_.get('language'),
'direction': bible_.get('direction', 'LTR'),
'encoding': bible_.get('encoding')
}
# start building the books
bible_['books'] = []
for book in books:
# add the book only if it has verses
book_has_verses = False
# reset chapter bucket
chapters = []
# set book number
book_nr = book_numbers.get(book.name)
# get book name as set in v1
book_name = v1_book_names.get(str(book_nr), {}).get(
'name', book_names.get(book.name, book.name))
# get book path
book_path = os.path.join(output_path, bible_.get('abbreviation'),
str(book_nr))
# check if path is set
check_path(book_path)
# add the book only if it has verses
chapter_has_verses = False
for chapter in xrange(1, book.num_chapters + 1):
# reset verse bucket
verses = []
for verse in xrange(1, len(book.get_indicies(chapter)) + 1):
text = bible_mod.get(books=[book.name],
chapters=[chapter],
verses=[verse])
_text = text.replace('[]', '')
if len(text) > 0 and not _text.isspace():
book_has_verses = True
chapter_has_verses = True
verses.append({
'chapter':
chapter,
'verse':
verse,
'name':
book_name + " " + str(chapter) + ":" + str(verse),
'text':
text
})
if chapter_has_verses:
# load to complete Bible
chapters.append({
'chapter': chapter,
'name': book_name + " " + str(chapter),
'verses': verses
})
# set chapter
bible_chapter['book_nr'] = book_nr
bible_chapter['book_name'] = book_name
bible_chapter['chapter'] = chapter
bible_chapter['name'] = book_name + " " + str(chapter)
bible_chapter['verses'] = verses
# store to chapter file
write_json(bible_chapter,
os.path.join(book_path,
str(chapter) + '.json'))
print('XXX\n{}\nChapter {} was added to {}-{}\nXXX'.format(
counter, chapter, book_name, abbreviation))
counter = increment_counter(counter, next, current)
if book_has_verses:
# load to complete Bible
bible_['books'].append({
'nr': book_nr,
'name': book_name,
'chapters': chapters
})
# set book
bible_book['nr'] = book_nr
bible_book['name'] = book_name
bible_book['chapters'] = chapters
# store to book file
write_json(bible_book, book_path + '.json')
print('XXX\n{}\nBook ({}) was added to {}\nXXX'.format(
counter, book_name, abbreviation))
counter = increment_counter(counter, next, current)
# add distribution info
bible_['distribution_lcsh'] = module_config.get('lcsh', '')
bible_['distribution_version'] = module_config.get('version', '')
bible_['distribution_version_date'] = module_config.get(
'SwordVersionDate', module_config.get('swordversiondate', ''))
bible_['distribution_abbreviation'] = module_config.get(
'abbreviation', abbreviation)
bible_['distribution_about'] = module_config.get('about', '')
bible_['distribution_license'] = module_config.get('distributionlicense',
'')
bible_['distribution_sourcetype'] = module_config.get('sourcetype', '')
bible_['distribution_source'] = module_config.get('textsource', '')
bible_['distribution_versification'] = module_config.get(
'versification', '')
# load the distribution history
bible_['distribution_history'] = {}
for k, v in module_config.items():
if 'history' in k:
bible_['distribution_history'][k] = v
return bible_
def word(self, command, args):
result = None
result_object = Result()
modules = SwordModules()
try:
found_modules = modules.parse_modules()
except FileNotFoundError:
result_object.error = 'no sword modules found on this computer. please install some!'
else:
try:
bible = modules.get_bible_from_module(self.current_module)
try:
book = args[0]
import modules.sword.book_names.books_de as books_de
if book in books_de.books:
book = books_de.books[book]
if len(args) == 2:
result = bible.get(books=[book],
chapters=[int(args[1])],
clean=True,
join='#|#')
splitted = result.split('#|#')
result = []
for i, line in enumerate(splitted):
result.append([i + 1, line.strip()])
elif args[2].find('-') > -1:
verse_min, verse_max = args[2].split('-')
verse_range = range(int(verse_min), int(verse_max) + 1)
try:
result = bible.get(books=[book],
chapters=[int(args[1])],
verses=verse_range,
clean=True,
join='#|#')
except IndexError:
result_object.error = 'invalid verse range'
else:
splitted = result.split('#|#')
result = []
for i, line in enumerate(splitted):
result.append(
[i + int(verse_min),
line.strip()])
else:
verse_range = int(args[2])
result = bible.get(books=[book],
chapters=[int(args[1])],
verses=verse_range,
clean=True,
join='\n')
except ValueError as e:
result_object.error = str(e)
except KeyError as e:
result_object.error = 'book not found in current bible: ' + str(
book) + "\n\n" + str(e)
except IndexError as e:
result_object.error = 'invalid input. please have a look at the man-page' + "\n\n" + str(
e)
except KeyError:
result_object.error = 'current module does not exist: ' + self.current_module
except ValueError as e:
result_object.error = str(e)
result_object.category = "text"
if result:
for item in args:
command += ' ' + str(item)
if type(result) == list:
result.insert(0, command)
elif type(result) == str:
result = [result]
result.insert(0, command)
result_object.payload = result
return result_object
from pysword.modules import SwordModules
import re
# Load module in zip
# NB: the zip content is only available as long as the SwordModules object exists
modules = SwordModules('KJV.zip')
# In this case the module found is:
# {'KJV': {'description': 'KingJamesVersion(1769)withStrongsNumbersandMorphology', 'encoding': 'UTF-8', ...}}
found_modules = modules.parse_modules()
bible = modules.get_bible_from_module('KJV')
# Get John chapter 3 verse 16
#output = bible.get(books=['john'], chapters=[3], verses=[16], clean=False)
#print bible.get_structure()
#print output
f = open('text.txt', 'w')
n = 0
contents = u''
for item in bible.get_iter(clean=False):
sentens = re.findall(
r'<w lemma="(.+?)"( morph="(.+?)")?( src=".+?")?>(.+?)</w>(.)', item)
for word in sentens:
strongs = re.findall(r'strong:((G|H)\d+)', word[0])
morphs = re.findall(r'(robinson|strongMorph):(\S+)', word[2])
ww = word[4]
comma = word[5]
contents = contents + ww
comp1 = zip(strongs, morphs)
for strong, morph in comp1:
def get_bible_json(path, overwrite):
# load sword module
modules = SwordModules(path)
found_modules = modules.parse_modules()
keys = found_modules.keys()
assert len(keys) == 1
sword_version = list(keys)[0]
version = lookup_version_abbr(sword_version)
module = found_modules[sword_version]
report = Report(version)
print('==================================================')
print(f'{version} - processing in progress, please wait')
# pprint(module)
# get metadata
language = module['lang']
meta = {
'description':
module['description'] if module.get('description')
and 'Strong' not in module['description'] else None,
'source':
'sword',
'swordVersion':
module.get('version'),
'swordVersionDate':
module.get('swordversiondate'),
'encoding':
module['encoding'].lower() if module.get('encoding') else None,
'language':
language,
'license':
module['distributionlicense'] if module.get('distributionlicense')
and 'Strong' not in module['distributionlicense'] else None,
'copyright':
module.get('copyright') or module.get('shortcopyright')
}
actual_encoding = meta['encoding']
assert actual_encoding == default_encoding or actual_encoding is None, f'{version} - expected module encoding {default_encoding} but got {actual_encoding}'
# skip if JSON exists
exists_obj = does_bible_json_exist(version, language)
if exists_obj['exists'] and not overwrite:
print(f'{version} - skipping, already exists')
return None
# get raw bible books
# noinspection PyBroadException
try:
bible = modules.get_bible_from_module(sword_version)
except Exception as e:
print(f'{version} - aborting, pysword failure .. {e}')
return None
assert bible._encoding == default_encoding or bible._encoding is None, f'{version} - expected bible encoding {default_encoding} but got {bible._encoding}'
bible_structure = bible.get_structure()
assert bible_structure._book_offsets is None
if bible_structure._books.get('ot') is None:
print(f'{version} - aborting, old testament missing')
return None
if bible_structure._books.get('nt') is None:
print(f'{version} - aborting, new testament missing')
return None
raw_books = bible_structure._books['ot'] + bible_structure._books['nt']
assert len(raw_books) == 66
# init processing
start = time.time()
chapter_count = 0
verse_count = 0
# main processing
books = []
for book_idx, book in enumerate(raw_books):
report.processed(book_idx + 1, book.osis_name, start)
range_chapters = range(0, book.num_chapters)
chapters = []
for chapter_idx in range_chapters:
chapter_num = chapter_idx + 1
raw_verses = book.get_indicies(chapter_num)
verses = []
for verse_idx, xxxxx in enumerate(raw_verses):
verse_num = verse_idx + 1
try:
text = bible.get(books=[book.name],
chapters=[chapter_num],
verses=[verse_num],
clean=True)
except Exception as e:
if 'incorrect header' in str(e):
text = None
else:
raise e
# if text is not None and version == 'ASV':
# text = text.encode('latin-1').decode('cp1252')
if text is not None:
# TIDYUP - trim
text = text.strip()
if text == '':
text = None
if text is not None:
# TIDYUP - remove double spaces
while ' ' in text:
text = text.replace(' ', ' ')
# TIDYUP - replace horrible chars
text = text.replace('\u2013', '-')
text = text.replace('\u2019', '\'')
verses.append({'number': verse_num, 'text': text})
verse_count += 1
chapters.append({'number': chapter_num, 'verses': verses})
chapter_count += 1
books.append({
'name': book.osis_name,
'verses_per_chapter': book.chapter_lengths,
'chapters': chapters,
})
print()
report.summary(len(books), chapter_count, verse_count)
assert chapter_count == 1189
return {
'version': version,
'versionName': lookup_version_name(sword_version),
'meta': meta,
'books': books
}