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:
1 parent
0d8ad253f3
commit
93efb2cb02
1 file changed
+356
-213
@@ -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")
|
||||
|
||||
|
||||
Reference in new issue
Block a user