def conversion_status(ctx, rd, job_id):
with cache_lock:
job_status = conversion_jobs.get(job_id)
if job_status is None:
raise HTTPNotFound('No job with id: {}'.format(job_id))
job_status.last_check_at = monotonic()
if job_status.running:
percent, msg = job_status.current_status
if rd.query.get('abort_job'):
ctx.abort_job(job_id)
return {'running': True, 'percent': percent, 'msg': msg}
del conversion_jobs[job_id]
try:
ans = {'running': False, 'ok': job_status.ok, 'was_aborted':
job_status.was_aborted, 'traceback': job_status.traceback,
'log': job_status.log}
if job_status.ok:
db, library_id = get_library_data(ctx, rd)[:2]
if library_id != job_status.library_id:
raise HTTPNotFound('job library_id does not match')
fmt = job_status.output_path.rpartition('.')[-1]
try:
db.add_format(job_status.book_id, fmt, job_status.output_path)
except NoSuchBook:
raise HTTPNotFound(
'book_id {} not found in library'.format(job_status.book_id))
formats_added({job_status.book_id: (fmt,)})
ans['size'] = os.path.getsize(job_status.output_path)
ans['fmt'] = fmt
return ans
finally:
job_status.cleanup()
def implementation(db, notify_changes, book_id, data, fmt, replace):
is_remote = notify_changes is not None
if is_remote:
data = BytesIO(data[1])
added = db.add_format(book_id, fmt, data, replace=replace)
if is_remote and added:
notify_changes(formats_added({book_id: (fmt, )}))
return added
def implementation(db, notify_changes, book_id, data, fmt, replace):
is_remote = notify_changes is not None
if is_remote:
data = BytesIO(data[1])
added = db.add_format(book_id, fmt, data, replace=replace)
if is_remote and added:
notify_changes(formats_added({book_id: (fmt,)}))
return added
def implementation(db, notify_changes, book_id, only_fmts):
if book_id is None:
return db.all_book_ids()
with db.write_lock:
if db.has_id(book_id):
db.embed_metadata((book_id, ), only_fmts=only_fmts)
if notify_changes is not None:
notify_changes(formats_added({book_id: db.formats(book_id)}))
return db.field_for('title', book_id)
def implementation(db, notify_changes, book_id, only_fmts):
if book_id is None:
return db.all_book_ids()
with db.write_lock:
if db.has_id(book_id):
db.embed_metadata((book_id,), only_fmts=only_fmts)
if notify_changes is not None:
notify_changes(formats_added({book_id: db.formats(book_id)}))
return db.field_for('title', book_id)
def do_adding(db, request_id, notify_changes, is_remote, mi, format_map,
add_duplicates, oautomerge):
identical_book_list, added_ids, updated_ids = set(), set(), set()
duplicates = []
identical_books_data = None
def add_format(book_id, fmt):
db.add_format(book_id,
fmt,
format_map[fmt],
replace=True,
run_hooks=False)
updated_ids.add(book_id)
def add_book():
nonlocal added_ids
added_ids_, duplicates_ = db.add_books([(mi, format_map)],
add_duplicates=True,
run_hooks=False)
added_ids |= set(added_ids_)
duplicates.extend(duplicates_)
if oautomerge != 'disabled' or not add_duplicates:
identical_books_data = cached_identical_book_data(db, request_id)
identical_book_list = find_identical_books(mi, identical_books_data)
if oautomerge != 'disabled':
if identical_book_list:
needs_add = False
duplicated_formats = set()
for book_id in identical_book_list:
book_formats = {q.upper() for q in db.formats(book_id)}
input_formats = {q.upper(): q for q in format_map}
common_formats = book_formats & set(input_formats)
if not common_formats:
for x in input_formats:
add_format(book_id, input_formats[x])
else:
new_formats = set(input_formats) - book_formats
if new_formats:
for x in new_formats:
add_format(book_id, input_formats[x])
if oautomerge == 'overwrite':
for x in common_formats:
add_format(book_id, input_formats[x])
elif oautomerge == 'ignore':
for x in common_formats:
duplicated_formats.add(input_formats[x])
elif oautomerge == 'new_record':
needs_add = True
if needs_add:
add_book()
if duplicated_formats:
duplicates.append(
(mi, {x: format_map[x]
for x in duplicated_formats}))
else:
add_book()
else:
if identical_book_list:
duplicates.append((mi, format_map))
else:
add_book()
if added_ids and identical_books_data is not None:
for book_id in added_ids:
db.update_data_for_find_identical_books(book_id,
identical_books_data)
if is_remote:
notify_changes(books_added(added_ids))
if updated_ids:
notify_changes(
formats_added(
{book_id: tuple(format_map)
for book_id in updated_ids}))
db.dump_metadata()
return added_ids, updated_ids, duplicates