feat(audiobook_library): sorting key, normalize names

new sorting key to extract track numbers
get codec from audio file
normalize album name to remove brackets and series name
create book dir from metadata
load all tables into database object
This commit is contained in:
Lucas Vivo authored and Lucas Media committed 2026-10-30 10:27:41 +01:00
1 parent 0d8ad253f3
commit 93efb2cb02
1 file changed
+356 -213
+356 -213
View File
@@ -11,13 +11,19 @@ import sqlite3
from collections import defaultdict
from concurrent.futures import ThreadPoolExecutor, as_completed
from pathlib import Path
from serverlibrary import *
logging.setLoggerClass(CustomLogger)
logger: CustomLogger = logging.getLogger(__name__) # type: ignore[assignment]
metadata_fields = ["artist", "album", "composer", "comment", "genre", "grouping", "album artist", "description"]
SEP = r"\s*[-_:,.]+\s*"
series_patterns = [
rf'^(\d+){SEP}(.+)$',
rf'^(.+?){SEP}(\d+)$',
rf'^(.+?)(?:{SEP}?(?:Book|Band|Volume)\s+(\d+))?$'
]
def ffmpeg_escape(path: Path) -> str:
return str(path.resolve()).replace("'", r"'\''")
@@ -189,10 +195,39 @@ def write_metadata(file, fields, values,dry_run=False):
return
return
def normalize_name(name: str,series: str) -> str:
# Remove anything in (), [], {}
name_out = ""
name = re.sub(series,"",name)
name = re.sub(r"\s*[\(\[\{].*?[\)\]\}]\s*", " ", name).strip()
name = re.sub(r"\s+", " ", name)
for pattern in series_patterns:
match = re.match(pattern, name, re.IGNORECASE)
if match:
if pattern.startswith(r"^(\d+)"):
name_out = match.group(2).strip()
else:
name_out = match.group(1).strip()
break
else:
name_out = name
pattern = rf'^(.+?){SEP}(?:Book|Band|Volume)\s+(\d+){SEP}(.+)$'
match = re.match(pattern, name, re.IGNORECASE)
if match:
name_out1 = match.group(1).strip()
name_out3 = match.group(3).strip()
if score_match_jaccard(words(name_out1), words(series)) > score_match_jaccard(words(name_out3), words(series)):
return name_out3
else:
return name_out1
return name_out
def cleanup(text: str) -> str:
# Collapse repeated punctuation groups like ", ,", ". .", "! !", "? ?"
while True:
new_text = re.sub(r'([.,!?;:])(?:\s+\1)+', r'\1', text)
new_text = re.sub(r'([.,!?;:-])(?:\s+\1)+', r'\1', text)
if new_text == text:
break
text = new_text
@@ -207,25 +242,42 @@ def get_empty_keys(data: dict) -> str:
return f"Empty: {', '.join(empty_keys)}" if empty_keys else ""
def natural_key(path):
return [
int(part) if part.isdigit() else part.casefold()
for part in re.split(r"(\d+)", path.stem)
]
def get_codec_bitrate(file: Path) -> tuple[str, str]:
info = json.loads(
subprocess.check_output(
[
"ffprobe",
"-v", "error",
"-select_streams", "a:0",
"-show_entries", "stream=codec_name,bit_rate",
"-of", "json",
str(file),
],
text=True,
)
)
stream = info["streams"][0]
bitrate = int(stream.get("bit_rate") or 128000)
bitrate_k = f"{bitrate // 1000}k"
return stream["codec_name"].lower(), bitrate_k # codec, bits/s
class Audiobook:
def __init__(self, book_path: Path, library_root_path : Path) -> None:
self.series_num = None
self.pdf_file = None
self.description = None
self.epub_file = None
self.files_extra = []
self.action_required = False
self.series_and_num = ""
self.series = ""
self.singleFile = False
SEP = r"\s*[-_:,.]+\s*"
self.series_patterns = [
rf'^(\d+){SEP}(.+)$',
rf'^(.+?){SEP}(\d+)$',
rf'^(.+?)(?:{SEP}?Book\s+(\d+)|\s+Book\s+(\d+))?$',
]
self.fileConunt = 0
self.size = 0
self.firstFile = ""
self.firstFile = None
self.changed = None
self.metadata = {}
self.artist = ""
@@ -241,15 +293,24 @@ class Audiobook:
self.files = sorted(
(
file
for pattern in AUDIO_SUFFIXES
for file in self.bookPath.glob(pattern)
for file in self.bookPath.iterdir()
if file.is_file() and file.suffix.lower() in AUDIO_SUFFIXES
),
key=natural_key,
key=self.extract_track_number,
)
epubs = list(self.bookPath.glob("*.epub"))
self.epub_file = epubs[0] if len(epubs) == 1 else None
pdfs = list(self.bookPath.glob("*.pdf"))
self.pdf_file = pdfs[0] if len(pdfs) == 1 else None
self.files_extra = [
file
for file in self.bookPath.glob("*") if file.suffix.lower() not in AUDIO_SUFFIXES
]
self.firstFile = self.get_first_file()
self.size = sum(
file.stat().st_size
for pattern in AUDIO_SUFFIXES
for pattern in AUDIO_RE_SUFFIXES
for file in self.bookPath.glob(pattern)
)
self.fileConunt = len(self.files)
@@ -270,7 +331,7 @@ class Audiobook:
f"fileConunt={self.fileConunt!r}, "
)
def get_first_file(self):
def get_first_file(self) -> Path:
return self.files[0]
def write_fields_from_metadata(self) -> None:
@@ -278,7 +339,10 @@ class Audiobook:
self.composer = self.metadata["composer"]
self.comment = self.metadata["comment"]
self.genre = self.metadata["genre"]
self.series = self.metadata["grouping"]
if "#" in self.metadata["grouping"]:
self.series, self.series_num = self.metadata["grouping"].rsplit("#", 1)
self.series = self.series.strip()
self.series_and_num = self.metadata["grouping"]
artist = self.metadata.get("artist", "").strip()
self.artist = artist or self.metadata.get("album artist")
self.description = self.metadata["description"]
@@ -287,12 +351,71 @@ class Audiobook:
self.metadata["album"] = self.name
self.metadata["composer"] = self.composer
self.metadata["genre"] = self.genre
self.metadata["grouping"] = self.series
self.metadata["grouping"] = self.series_and_num
self.metadata["comment"] = self.comment
self.metadata["description"] = self.description
self.metadata["artist"] = self.artist
self.metadata["album artist"] = self.artist
def extract_track_number(self, file: Path) -> int:
stem = file.stem
title = self.name
# Remove title if it appears at the beginning
if title:
escaped_title = re.escape(title)
stem = re.sub(
rf"^{escaped_title}(?:\s*[-_:]\s*)?",
"",
stem,
flags=re.IGNORECASE,
).strip()
patterns = [
# 01 Title, 02GLCK~1.WMA
r"^(\d{2,3})(?=\D|$)",
# CD1-01, CD 1 - 01, CD1 - 01.
r"CD\s*(\d+)\s*-\s*(\d{1,3})",
# 018-01, 018 - 01, 138-01, 01-01
r"^(\d{1,3})\s*-\s*(\d{1,3})(?:\D|$)",
# Track 01
r"Track\s+(\d+)$",
# 01 - Kapitel 01
r"^(\d+)\s*-",
# Rubinrot 101, 102, 201, 202
r".*?(\d)(\d{2})$",
# A Thousand Ships - 007
r".*?-\s*(\d+)\s*$",
]
for pattern in patterns:
m = re.search(pattern, stem, re.IGNORECASE)
if not m:
continue
groups = m.groups()
if len(groups) == 1:
return int(groups[0])
if len(groups) == 2 and "CD" in pattern:
disc = int(groups[0])
track = int(groups[1])
return (disc - 1) * 1000 + track
if len(groups) == 2 and stem.startswith(groups[0]):
disc = int(groups[0])
track = int(groups[1])
if track < 100:
return disc * 1000 + track
if len(groups) == 2 and len(groups[0]) == 1:
disc = int(groups[0])
track = int(groups[1])
return disc * 1000 + track
return int(groups[-1])
return 0
def load_metadata(self):
self.metadata = get_metadata_all(self.get_first_file())
self.write_fields_from_metadata()
@@ -300,6 +423,16 @@ class Audiobook:
f"Load metadata {self.metadata}"
)
def fix_artist_dir(self):
rel_path = self.bookPath.relative_to(self.library_root_path).parts
if not self.artist:
logger.trace(f"No artist tag for {self.name}")
return
if len(rel_path) < 2:
desired_path,desired_name = self.generate_dir_from_metadata()
self.move(desired_path,desired_name)
logger.debug(f"Artist not visible in folder structure: {rel_path}")
def fix_artist_from_comment(self):
m = re.search(
r"(?:"
@@ -344,8 +477,9 @@ class Audiobook:
elif self.artist != artist:
logger.warning(
f"[Action Required] artist {artist} found not matching {self.artist} for {self.name}"
f"{red_tag("Action Required")} artist {artist} found not matching {self.artist} for {self.bookPath}"
)
self.action_required = True
else:
logger.debug(f"Artist {artist} matches file metadata for {self.name}")
@@ -404,30 +538,25 @@ class Audiobook:
def fix_name(self):
if not self.name:
name = self.bookPath.name
for pattern in self.series_patterns:
match = re.match(pattern, name, re.IGNORECASE)
if match:
if pattern.startswith(r'^(\d+)'):
self.name = match.group(2).strip()
else:
self.name = match.group(1).strip()
break
else:
self.name = name
self.name = normalize_name(self.bookPath.name)
self.changed = True
logger.info(f"[Updated] name found in path for {self.bookPath}")#
return
name = normalize_name(self.name, self.series)
if name != self.name:
logger.info(f"[Updated] name by cleaning {self.name} to {name}")
self.name = name
self.changed = True
logger.info(f"[Updated] name found in path for {self.bookPath}")
def fix_series(self):
if self.series:
logger.trace(f"{self.name} already has series: {self.series}")
if self.series_and_num:
logger.trace(f"{self.name} already has series: {self.series_and_num}")
rel_path = self.bookPath.relative_to(self.library_root_path).parts
number=""
if len(rel_path) <= 2:
logger.trace(f"No series found for {self.name}")
return
for i, pattern in enumerate(self.series_patterns):
for i, pattern in enumerate(series_patterns):
match = re.match(pattern, rel_path[2], re.IGNORECASE)
if not match:
continue
@@ -437,7 +566,6 @@ class Audiobook:
number = match.group(2)
else:
number = match.group(2) or match.group(3)
break
number_str = ""
and_number =""
@@ -446,24 +574,55 @@ class Audiobook:
else:
number_str = " #" + number
and_number = " and number"
self.series = rel_path[1] + number_str
self.series_num = number
self.series_and_num = rel_path[1] + number_str
self.series =rel_path[1]
self.changed = True
logger.info(f"[Updated] series{and_number} found for {self.name}")
logger.info(f"[Updated] series{and_number} found for {self.name} to {self.series_and_num}")
return
def fix_genre(self):
self.genre = clean_genre(self.genre)
self.changed = True
def move(self, desiredPath: Path, desired_name: str, dry_run=False):
logger.trace(f"Moving {self.bookPath} to {desiredPath}")
def move(self, desired_path: Path, desired_name_stem: str, dry_run=False):
logger.trace(f"Moving {self.bookPath} to {desired_path}")
if dry_run:
return
desiredPath.mkdir(parents=True, exist_ok=True)
desired_path.mkdir(parents=True, exist_ok=True)
padding = len(str(len(self.files)))
for number, file in enumerate(self.files, start=1):
if self.singleFile:
new_name = f"{desired_name_stem}{file.suffix.lower()}"
else:
new_name = f"{number:0{padding}d} - {desired_name_stem}{file.suffix}"
self.files[number-1] = file.rename(desired_path / new_name)
for file in self.files_extra:
if file.suffix.lower() in {".cue", ".log"} or file in {
self.epub_file,
self.pdf_file,
}:
filename = f"{desired_name_stem}{file.suffix.lower()}"
else:
filename = file.name
new_file = file.rename(desired_path / filename)
if file == self.epub_file:
self.epub_file = new_file
elif file == self.pdf_file:
self.pdf_file = new_file
for file in self.files:
file.rename(desiredPath / file.name)
if self.bookPath != desired_path:
remaining = list(self.bookPath.iterdir())
if not remaining:
self.bookPath.rmdir()
else:
logger.warning(f"{red_tag('Action Required')} old path not empty after move: "
f"{self.bookPath}: {remaining}"
)
self.bookPath = desired_path
self.files = sorted(self.files, key=self.extract_track_number)
self.firstFile = self.get_first_file()
logger.debug(f"Moving {self.bookPath} to {desired_path}")
def generate_dir_from_metadata(self):
composer =""
@@ -471,21 +630,29 @@ class Audiobook:
if self.composer:
composer = f" (by {self.composer})"
name = self.name + composer
desired_path = self.library_root_path / self.artist /name
if self.series:
desired_path = self.library_root_path / self.artist / self.series / name
desired_name = self.artist + " - " + self.name + composer + self.bookPath.ext
return desired_path, desired_name
desired_path = self.library_root_path / self.artist / name
if self.series_and_num:
series = self.series_and_num
number = ""
if "#" in self.series_and_num:
series = self.series_and_num.split("#")
number = f"{series[1]} - "
series = series[0].rstrip()
desired_path = self.library_root_path / self.artist / series / f"{number}{name}"
desired_name_stem = self.artist + " - " + self.name + composer + self.bookPath.suffix
return desired_path, desired_name_stem
def create_m4b_from_book(self, creat_m4b_no_delete: bool = False) -> None:
output_file_final = self.bookPath / f"{self.bookPath.name}.m4b"
if self.action_required:
logger.warning(f"Action required, resolve before creating m4b file")
return
if output_file_final.exists():
logger.info(f"{red}[SKIP]{reset} {output_file_final}")
logger.info(f"{red_tag("SKIP")} {output_file_final}")
logger.info("Book already present")
return
logger.info(f"[CREATE] {output_file_final}")
logger.info(f"{blue_tag("create")} {output_file_final}")
with tempfile.TemporaryDirectory(dir=self.library_root_path.parent) as tmp:
tmpdir = Path(tmp)
@@ -514,11 +681,11 @@ class Audiobook:
has_existing_chapters = True
if has_existing_chapters:
logger.info(
logger.debug(
"Existing chapter tracks found; preserving chapter metadata"
)
else:
logger.info(
logger.debug(
"No existing chapters found; generating chapters from filenames"
)
@@ -573,18 +740,16 @@ class Audiobook:
mf.write(f"title={ffmetadata_escape(media.stem)}\n")
current_ms += duration_ms
codec = subprocess.check_output(
[
"ffprobe",
"-v", "error",
"-select_streams", "a:0",
"-show_entries", "stream=codec_name",
"-of", "default=noprint_wrappers=1:nokey=1",
str(self.firstFile),
],
text=True,
).strip()
cmd_backup = [
codec, bitrate_k = get_codec_bitrate(self.firstFile)
codec_args = ["-c:a", "copy"]
if codec == "mp3":
codec_args = ["-c:a", "aac", "-b:a", bitrate_k]
elif codec == "flac":
codec_args = ["-c:a", "alac", "-b:a", bitrate_k]
elif codec not in {"aac", "alac"}:
codec_args = ["-c:a", "aac", "-b:a", bitrate_k]
cmd = [
"ffmpeg",
"-y",
"-f",
@@ -608,73 +773,20 @@ class Audiobook:
"1",
"-map_chapters",
"1",
"-c:a",
"aac",
"-b:a",
"128k",
*codec_args,
"-c:v",
"copy",
"-disposition:v:0",
"attached_pic",
str(output_file_tmp),
]
cmd_default = [
"ffmpeg",
"-y",
"-f",
"concat",
"-safe",
"0",
"-i",
str(concat_file),
"-i",
str(metadata_file),
"-i",
str(self.firstFile),
"-map",
"0:a",
"-map",
"2:v?",
# Metadata and chapters from our generated FFMETADATA file
"-map_metadata",
"1",
"-map_chapters",
"1",
"-c:a",
"copy",
"-c:v",
"copy",
"-disposition:v:0",
"attached_pic",
str(output_file_tmp),
]
cmd = cmd_default
if codec == "mp3":
cmd = cmd_backup
try:
result = subprocess.run(
cmd,
capture_output=True,
text=True,
check=True,
)
except subprocess.CalledProcessError as e:
logger.warning(e.stderr)
logger.info(result.stdout)
if result.returncode == 234:
logger.warning(
f"{yellow}[WARNING]{reset} - {self.bookPath.name} - {result.returncode} retrying with aac encoder"
)
result = subprocess.run(
cmd_backup,
capture_output=True,
text=True,
check=True,
)
logger.info(result.stdout)
result = subprocess.run(
cmd,
capture_output=True,
text=True,
check=True,
)
logger.trace(result.stdout)
if result.returncode == 0:
output_file_tmp.rename(output_file_final)
for media in self.files:
@@ -688,14 +800,19 @@ class Audiobook:
self.changed = False
self.size = Path(output_file_final).stat().st_size
logger.info(
f"{green}[SUCCESS]{reset} - {self.bookPath.name} - delete media files"
f"{green_tag("SUCCESS")} - {self.bookPath.name} - delete media files"
)
else:
logger.error(
f"{red}[ERROR]{reset} - {self.bookPath.name} - Code: {result.returncode}, Stderr: {result.stderr}"
f"{red_tag("ERROR")} - {self.bookPath.name} - Code: {result.returncode}, Stderr: {result.stderr}"
)
def write_metadata(self, keys=None, dry_run=False):
if self.action_required:
logger.warning(f"Action required, resolve before writing metadata file")
return
self.write_metadata_from_fields()
if keys is None:
keys = self.metadata.keys()
@@ -730,14 +847,16 @@ class AudiobookLibrary:
class SqlDatabase:
def __init__(self, sql_database_path: Path):
self.tables = []
self.data = {}
self.db = None
self.path = sql_database_path
self.books = []
def connect(self):
if not self.path.is_file() or self.path.suffix != ".db":
if not self.path.is_file():
logger.error(f"{self.path} does not exist")
return False
raise FileExistsError
self.db = sqlite3.connect(self.path)
self.db.row_factory = sqlite3.Row
return True
@@ -753,26 +872,32 @@ class AudiobookLibrary:
def init(self):
if not self.connect():
return
self.load_database_data()
return False
def load_database_data(self):
books = []
return self.load_database_data()
for row in self.db.execute("SELECT * FROM books"):
book = dict(row)
def load_database_data(self) -> bool:
self.tables = self.db.execute(
"SELECT name FROM sqlite_master WHERE type='table'"
).fetchall()
for table in self.tables:
table_name = table["name"]
rows = []
for row in self.db.execute(f'SELECT * FROM "{table_name}"'):
record = dict(row)
# Auto-decode JSON columns
for key, value in record.items():
if isinstance(value, str) and value[:1] in "[{":
try:
record[key] = json.loads(value)
except json.JSONDecodeError:
pass
# auto-decode JSON columns
for key, value in book.items():
if isinstance(value, str) and value[:1] in "[{":
try:
book[key] = json.loads(value)
except json.JSONDecodeError:
pass
rows.append(record)
books.append(book)
self.books = books
self.data[table_name] = rows
self.books = self.data["books"]
return True
def update_books(self):
for book in self.books:
@@ -800,57 +925,57 @@ class AudiobookLibrary:
# commit once after all updates
def fix_sql_database(self, dry_run):
def fix_genres(self):
for book in self.books:
genres = book.get("genres")
if not genres or not any(g.strip() for g in genres):
continue
new_genres = []
for genre in genres:
genre = clean_genre(genre)
if "," in genre:
genre = genre.split(",")
elif " - " in genre:
genre = genre.split(" - ")
elif "Historical Adventure Thriller Mystery" in genre:
genre = genre.split(" ")
for book in self.sql_database_instance.books:
genres = book.get("genres")
if not genres or not any(g.strip() for g in genres):
continue
new_genres = []
for genre in genres:
genre = clean_genre(genre)
if "," in genre:
genre = genre.split(",")
elif " - " in genre:
genre = genre.split(" - ")
elif "Historical Adventure Thriller Mystery" in genre:
genre = genre.split(" ")
if isinstance(genre, str):
if len(genre) > 50 or (5 > len(genre) > 0):
genre = ""
logger.trace(f"Too long or too short: {genre}")
genre = genre.strip()
genre = genre.lstrip()
new_genres.append(genre)
elif isinstance(genre, list):
if len(genres) > 1:
genres = [g for g in genres if g]
new_genres.extend(genre)
if isinstance(genre, str):
if len(genre) > 50 or (5 > len(genre) > 0):
genre = ""
logger.trace(f"Too long or too short: {genre}")
genre = genre.strip()
genre = genre.lstrip()
new_genres.append(genre)
elif isinstance(genre, list):
if len(genres) > 1:
genres = [g for g in genres if g]
new_genres.extend(genre)
new_genres = sorted(set(new_genres))
list_difference = False
if len(new_genres) < len(genres):
list_difference = True
for old, new in zip(genres, new_genres):
if old != new:
new_genres = sorted(set(new_genres))
list_difference = False
if len(new_genres) < len(genres):
list_difference = True
break
for old, new in zip(genres, new_genres):
if old != new:
list_difference = True
break
if not list_difference:
logger.trace("No difference: Dont Commit to Database")
continue
logger.trace(f"{genres} -> {new_genres}")
book["genres"] = new_genres
if dry_run:
return
self.sql_database_instance.update_books()
self.sql_database_instance.commit()
self.sql_database_instance.close()
if not list_difference:
logger.trace("No difference: Dont Commit to Database")
continue
logger.debug(f"{genres} -> {new_genres}")
book["genres"] = new_genres
def fix_comments(self):
for book in self.books:
for file in book.get("audioFiles"):
comment = file.get("metaTags").get("tagComment")
if comment and len(comment) < 40:
logger.debug(f"Fix short comment for {book.get("title")}")
comment = ""
file["metaTags"]["tagComment"] = comment
def add(self, book: Audiobook):
self.audiobooks.append(book)
@@ -908,10 +1033,11 @@ class AudiobookLibrary:
A book directory is any directory containing more than one
audiobook file (.mp3, .m4a, .m4b)
"""
media_files = []
for ext in AUDIO_SUFFIXES:
media_files.extend(list(self.libraryPath.rglob(ext)))
media_files = [
file
for file in self.libraryPath.rglob("*")
if file.is_file() and file.suffix.lower() in AUDIO_SUFFIXES
]
dirs = {file.parent for file in media_files}
for directory in dirs:
self.add(Audiobook(directory,self.libraryPath))
@@ -928,6 +1054,15 @@ class AudiobookLibrary:
logger.trace(f"Writing metadata: {audiobook.name}")
audiobook.write_metadata(keys,dry_run=self.dry_run)
def fix_artist_dir(self):
for book in self.audiobooks:
book.fix_artist_dir()
def create_structured_directories(self):
for book in self.audiobooks:
desired_path, desired_name = book.generate_dir_from_metadata()
book.move(desired_path, desired_name)
def fix_artists(self):
for book in self.audiobooks:
book.fix_artist_from_comment()
@@ -957,18 +1092,6 @@ class AudiobookLibrary:
for book in self.audiobooks:
book.fix_series()
def move_library(self):
for audiobook in self.audiobooks:
desired_path,desired_name = audiobook.generate_dir_from_metadata()
audiobook.move(desired_path,desired_name,dry_run=self.dry_run)
def generate_folder_structure(self):
for audiobook in self.audiobooks:
desired_path = (
self.libraryPath / Path(audiobook.artist) / Path(audiobook.name)
)
audiobook.move(desired_path)
def create_m4b_from_dir(
self, path: Path = Path(""), name: str = "", keep_originals: bool = False
) -> None:
@@ -1002,6 +1125,8 @@ class AudiobookLibrary:
except Exception:
logger.exception(f"Failed to create m4b for {audiobook.name}")
def main():
parser = argparse.ArgumentParser(description="Audiobook Directory Processing")
@@ -1057,12 +1182,21 @@ def main():
help="SQL Database Path",
)
parser.add_argument(
"-fd"
"--fix-db",
action="store_true",
help="Fix the Database",
)
parser.add_argument(
"-m",
"--move",
action="store_true",
help="Create structured directories for all books: /artist/series/book(read by X)/file.m4b",
)
args = parser.parse_args()
if "--sql-database" in sys.argv:
args.fix_db = True
setup_logging(args.log_level, "audiobook_library")
library_dir = args.library.expanduser()
@@ -1081,10 +1215,11 @@ def main():
if args.fix_db:
library.sql_database_instance.init()
library.fix_artist_dir()
library.fix_artists()
library.fix_composers()
library.fix_names()
library.fix_series()
library.fix_names()
library.fix_comments()
library.fix_genres()
@@ -1098,7 +1233,15 @@ def main():
library.write_metadata()
if args.fix_db:
library.fix_sql_database(True)
library.sql_database_instance.fix_genres()
library.sql_database_instance.fix_comments()
if not args.dry_run:
library.sql_database_instance.update_books()
library.sql_database_instance.commit()
library.sql_database_instance.close()
if args.move:
library.create_structured_directories()
print("Fin")