rekordbox-edit 0.7.0.dev44__tar.gz → 0.7.0.dev49__tar.gz

{rekordbox_edit-0.7.0.dev44 → rekordbox_edit-0.7.0.dev49}/.gitignore

@@ -49,6 +49,8 @@ Thumbs.db
 
 .claude
 docs/superpowers
+docs/decisions
+research
 
 # MkDocs build output
 site/

{rekordbox_edit-0.7.0.dev44 → rekordbox_edit-0.7.0.dev49}/CHANGELOG.md

@@ -1,6 +1,15 @@
-## v0.7.0.dev44 (2026-07-16)
-
-
+## v0.7.0.dev49 (2026-07-17)
+
+
+- chore: ignore research/decision docs
+- fix(convert): update FileSize, OrgFilePath cols; PPTH ANLZ tag
+- refactor(convert): merge shared logic of ffmpeg helpers
+- Replace _convert_to_hi_res and _convert_to_mp3 with a single _run_ffmpeg
+runner and two pure output-kwargs builders.
+- fix(convert): skip unsupported source formats via input whitelist
+- Previously we were skipping via a blacklist, which allowed
+unknown/unsupported formats to create undefined behavior.
+- refactor(convert): change get_file_type_name a simple display map
 - chore(deps): update dependency ty to v0.0.59 (#134)
 - Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
 - chore(deps): update dependency syrupy to v5.5.3 (#133)

{rekordbox_edit-0.7.0.dev44 → rekordbox_edit-0.7.0.dev49}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rekordbox-edit
-Version: 0.7.0.dev44
+Version: 0.7.0.dev49
 Summary: Tools for managing and modifying a RekordBox library en-masse
 Project-URL: Homepage, https://github.com/jviall/rekordbox-edit
 Project-URL: Repository, https://github.com/jviall/rekordbox-edit

{rekordbox_edit-0.7.0.dev44 → rekordbox_edit-0.7.0.dev49}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "rekordbox-edit"
-version = "0.7.0.dev44"
+version = "0.7.0.dev49"
 description = "Tools for managing and modifying a RekordBox library en-masse"
 authors = [{ name = "James Viall", email= "jamesviall@pm.me"}]
 license = "MIT"

{rekordbox_edit-0.7.0.dev44 → rekordbox_edit-0.7.0.dev49}/rekordbox_edit/api/convert.py

@@ -2,7 +2,6 @@
 
 import logging
 import os
-import posixpath
 from pathlib import Path
 from typing import Literal, Tuple
 
@@ -22,6 +21,7 @@ from rekordbox_edit.models import (
 )
 from rekordbox_edit.query import get_filtered_content
 from rekordbox_edit.utils import (
+    InputFormats,
     OutputFormats,
     get_audio_info,
     get_extension_for_format,
@@ -34,6 +34,9 @@ logger = logging.getLogger(__name__)
 TARGET_BIT_DEPTH = 16
 TARGET_SAMPLE_RATE = 44100
 
+# Rekordbox FileType codes RBE converts from: the hi-res lossless whitelist.
+_INPUT_FILE_TYPES = {get_file_type_for_format(fmt.value) for fmt in InputFormats}
+
 _HI_RES_CODECS = {
     "aiff": "pcm_s16be",
     "wav": "pcm_s16le",
@@ -74,20 +77,13 @@ def _classify_source_fidelity(
     return "lossy", effective_rate
 
 
-def _convert_to_hi_res(input_path, output_path, output_format, sample_rate):
-    """Convert a hi-res file to another hi-res format at the target bit
-    depth and the given sample rate, down-sampling higher-resolution
-    sources."""
-    from rekordbox_edit.utils import ffmpeg_in_path, get_ffmpeg_directions
-
-    if not ffmpeg_in_path():
-        raise Exception(f"FFmpeg not found in PATH.{get_ffmpeg_directions()}")
-
+def _hi_res_output_kwargs(output_format, sample_rate) -> dict:
+    """ffmpeg output kwargs for a hi-res conversion at the target bit depth and
+    the given sample rate."""
     codec = _HI_RES_CODECS.get(output_format.value)
     if codec is None:
         raise Exception(f"Unsupported hi-res format: {output_format}")
-
-    output_kwargs = {
+    kwargs = {
         "acodec": codec,
         "ar": sample_rate,
         "map_metadata": 0,
@@ -95,35 +91,26 @@ def _convert_to_hi_res(input_path, output_path, output_format, sample_rate):
     }
     # PCM codecs fix the bit depth by name; the flac encoder needs it spelled out.
     if output_format.value == "flac":
-        output_kwargs["sample_fmt"] = "s16"
+        kwargs["sample_fmt"] = "s16"
+    return kwargs
 
-    logger.debug(
-        f"Selected codec: {codec} targeting {TARGET_BIT_DEPTH}-bit/{sample_rate} Hz"
-    )
 
-    try:
-        (
-            ffmpeg.input(input_path)
-            .output(output_path, **output_kwargs)
-            .overwrite_output()
-            .run(capture_stdout=True, capture_stderr=True)
-        )
-        logger.debug(f"Conversion to {output_format.value} succeeded: {output_path}")
-        return True
-    except FfmpegError as e:
-        logger.error(f"FFmpeg conversion failed for {input_path}: {e}")
-        if e.stderr:
-            stderr = e.stderr.decode() if isinstance(e.stderr, bytes) else e.stderr
-            logger.debug(f"FFmpeg stderr:\n{stderr}")
-        return False
-    except Exception as e:
-        logger.error(f"Conversion failed for {input_path}: {e}")
-        raise e
+def _mp3_output_kwargs(sample_rate) -> dict:
+    """ffmpeg output kwargs for MP3 320kbps CBR at the given sample rate."""
+    return {
+        "acodec": "libmp3lame",
+        "audio_bitrate": "320k",
+        "ar": sample_rate,
+        # libmp3lame takes planar input; s16p quantizes to 16-bit before encoding.
+        "sample_fmt": "s16p",
+        "map_metadata": 0,
+        "write_id3v2": 1,
+    }
 
 
-def _convert_to_mp3(input_path, mp3_path):
-    """Convert hi-res file to MP3 320kbps CBR at the target bit depth and
-    sample rate."""
+def _run_ffmpeg(input_path, output_path, output_kwargs: dict, label: str) -> bool:
+    """Run a single ffmpeg conversion. Returns True on success, False on an
+    ffmpeg error; re-raises anything else. `label` names the target for logs."""
     from rekordbox_edit.utils import ffmpeg_in_path, get_ffmpeg_directions
 
     if not ffmpeg_in_path():
@@ -132,21 +119,11 @@ def _convert_to_mp3(input_path, mp3_path):
     try:
         (
             ffmpeg.input(input_path)
-            .output(
-                mp3_path,
-                acodec="libmp3lame",
-                audio_bitrate="320k",
-                ar=TARGET_SAMPLE_RATE,
-                # libmp3lame takes planar input; s16p quantizes to 16-bit
-                # before encoding.
-                sample_fmt="s16p",
-                map_metadata=0,
-                write_id3v2=1,
-            )
+            .output(output_path, **output_kwargs)
             .overwrite_output()
             .run(capture_stdout=True, capture_stderr=True)
         )
-        logger.debug(f"Conversion to mp3 succeeded: {mp3_path}")
+        logger.debug(f"Conversion to {label} succeeded: {output_path}")
         return True
     except FfmpegError as e:
         logger.error(f"FFmpeg conversion failed for {input_path}: {e}")
@@ -160,15 +137,21 @@ def _convert_to_mp3(input_path, mp3_path):
 
 
 def _update_database_record(
-    db, content_id, new_filename, new_folder, output_format
+    db: Rekordbox6Database,
+    content_id: str,
+    new_filename: str,
+    new_folder: str,
+    output_format: str,
 ) -> None:
     """Update database record with new file information."""
     content = db.get_content().filter_by(ID=content_id).first()
     if not content:
         raise Exception(f"Content record with ID {content_id} not found")
 
-    converted_full_path = posixpath.join(new_folder, new_filename)
-    converted_audio_info = get_audio_info(converted_full_path)
+    old_path = content.FolderPath
+    converted_file_path = Path(new_folder, new_filename)
+    converted_db_path = str(converted_file_path).replace("\\", "/")
+    converted_audio_info = get_audio_info(converted_file_path)
     converted_bitrate = converted_audio_info["bitrate"]
 
     if output_format.upper() == "MP3" and converted_bitrate is None:
@@ -193,8 +176,13 @@ def _update_database_record(
             content.BitDepth = converted_bit_depth
 
     content.FileNameL = new_filename
-    content.FolderPath = converted_full_path
+    content.FolderPath = converted_db_path
     content.FileType = file_type
+    content.FileSize = os.path.getsize(converted_file_path)
+
+    # Original location: only update if it matches FolderPath
+    if content.OrgFolderPath == old_path:
+        content.OrgFolderPath = converted_db_path
 
     # FLAC stores bitrate as 0 in Rekordbox to represent VBR
     if output_format.upper() == "FLAC":
@@ -203,6 +191,24 @@ def _update_database_record(
         content.BitRate = converted_bitrate
 
 
+def _update_anlz_paths(
+    db: Rekordbox6Database, content: DjmdContent, new_filename: str
+) -> None:
+    """Rewrite the PPTH path tag in a track's ANLZ files to the converted file
+    name, in rekordbox's device-relative ``?/<name>`` form.
+
+    No-op for tracks without an analysis.
+    """
+    if not content.AnalysisDataPath:
+        return
+    new_ppth = f"?/{new_filename}"
+    anlz_files = db.read_anlz_files(content.ID)
+    for anlz_path, anlz in anlz_files.items():
+        anlz.set_path(new_ppth)
+        anlz.save(anlz_path)
+        logger.debug(f"Updated PPTH of {anlz_path} to {new_ppth}")
+
+
 def _cleanup_converted_files(converted_ops: list[ConvertOp]) -> None:
     """Clean up converted output files on error or rollback."""
     logger.debug("Cleaning up converted files due to aborted conversion.")
@@ -252,14 +258,18 @@ def _classify_convert(content, args: ConvertRequest) -> ConvertOp | SkippedTrack
     """Return ConvertOp if this track should be converted, or SkippedTrack with
     reason if not."""
     target = get_file_type_for_format(args.format_out)
-    mp3 = get_file_type_for_format("MP3")
-    m4a = get_file_type_for_format("M4A")
-    if content.FileType in (target, mp3, m4a):
+    if content.FileType == target:
         logger.debug(
             f"skip convert id={content.ID} reason=already_target_format "
             f"file_type={content.FileType} target={target}"
         )
         return SkippedTrack(id=str(content.ID), reason="already_target_format")
+    if content.FileType not in _INPUT_FILE_TYPES:
+        logger.debug(
+            f"skip convert id={content.ID} reason=unsupported_source_format "
+            f"file_type={content.FileType}"
+        )
+        return SkippedTrack(id=str(content.ID), reason="unsupported_source_format")
     output_path, _, _ = _get_output_path(content, args.format_out)
     if not args.overwrite and os.path.exists(output_path):
         logger.debug(
@@ -276,11 +286,7 @@ def _classify_convert(content, args: ConvertRequest) -> ConvertOp | SkippedTrack
         id=str(content.ID),
         source_path=content.FolderPath or "",
         output_path=output_path,
-        source_file_type=(
-            get_file_type_name(content.FileType)
-            if content.FileType is not None
-            else None
-        ),
+        source_file_type=get_file_type_name(content.FileType),
         source_bit_depth=content.BitDepth,
         source_sample_rate=content.SampleRate,
         output_file_type=args.format_out.upper(),
@@ -370,16 +376,19 @@ def convert(
 
             if args.format_out.upper() == "MP3":
                 output_sample_rate = TARGET_SAMPLE_RATE
-                success = _convert_to_mp3(src, op.output_path)
+                success = _run_ffmpeg(
+                    src, op.output_path, _mp3_output_kwargs(output_sample_rate), "mp3"
+                )
             else:
                 fidelity, output_sample_rate = _classify_source_fidelity(src)
                 if fidelity == "lossless":
                     lossless_op_ids.add(op.id)
-                success = _convert_to_hi_res(
+                output_format = OutputFormats(args.format_out.lower())
+                success = _run_ffmpeg(
                     src,
                     op.output_path,
-                    OutputFormats(args.format_out.lower()),
-                    output_sample_rate,
+                    _hi_res_output_kwargs(output_format, output_sample_rate),
+                    output_format.value,
                 )
 
             if not success:
@@ -415,6 +424,15 @@ def convert(
         _rollback_and_cleanup(db, converted_ops)
         raise
 
+    for op in converted_ops:
+        content = content_map[op.id]
+        try:
+            _update_anlz_paths(db, content, os.path.basename(op.output_path))
+        except Exception as e:
+            logger.warning(
+                f"Failed to update ANLZ path tags for {content.FileNameL}: {e}"
+            )
+
     if args.delete_originals == "all":
         deletable_ops = converted_ops
     elif args.delete_originals == "lossless":

{rekordbox_edit-0.7.0.dev44 → rekordbox_edit-0.7.0.dev49}/rekordbox_edit/cli/convert.py

@@ -127,9 +127,15 @@ def convert_command(db, **kwargs):
 
 def _report_skips(skipped) -> None:
     already_target = sum(1 for s in skipped if s.reason == "already_target_format")
+    unsupported = sum(1 for s in skipped if s.reason == "unsupported_source_format")
     conflicts = sum(1 for s in skipped if s.reason == "output_file_exists")
     if already_target:
         logger.warning(f"Skipping {already_target} file(s): already in target format")
+    if unsupported:
+        logger.warning(
+            f"Skipping {unsupported} file(s): unsupported source format "
+            "(only FLAC, AIFF, WAV are converted)"
+        )
     if conflicts:
         logger.warning(
             f"Skipping {conflicts} file(s): output exists (use --overwrite to convert)"

{rekordbox_edit-0.7.0.dev44 → rekordbox_edit-0.7.0.dev49}/rekordbox_edit/display.py

@@ -78,13 +78,13 @@ def _cell_value(track: Track, column: PrintableField) -> str:
     if column is PrintableField.FileType:
         if track.FileType is None:
             return ""
-        try:
-            return get_file_type_name(track.FileType)
-        except ValueError:
+        name = get_file_type_name(track.FileType)
+        if name is None:
             logger.warning(
                 f"Unexpected FileType [{track.FileType}] for track ID [{track.ID}]"
             )
             return "UNKNOWN"
+        return name
     if column is PrintableField.FolderPath:
         return os.path.dirname(track.FolderPath or "")
     value = getattr(track, column.value, None)

{rekordbox_edit-0.7.0.dev44 → rekordbox_edit-0.7.0.dev49}/rekordbox_edit/models.py

@@ -126,7 +126,10 @@ class Track(BaseModel):
 
 
 SkipReason: TypeAlias = Literal[
-    "no_change", "already_target_format", "output_file_exists"
+    "no_change",
+    "already_target_format",
+    "unsupported_source_format",
+    "output_file_exists",
 ]
 
 

{rekordbox_edit-0.7.0.dev44 → rekordbox_edit-0.7.0.dev49}/rekordbox_edit/utils.py

@@ -18,8 +18,14 @@ class UserQuit(Exception):
 
 
 # File type mappings for Rekordbox database
-def get_file_type_name(file_type_code: int):
-    """Get human-readable name for file type code."""
+def get_file_type_name(file_type_code: int | None) -> str | None:
+    """Map a Rekordbox FileType code to a display name, or None if unmapped.
+
+    A total display map, not a guard: Rekordbox stores many codes RBE does not
+    convert (AAC, ALAC, video). Each caller chooses its own fallback for None.
+    """
+    if file_type_code is None:
+        return None
     _get_file_type_name = {
         0: "MP3",
         1: "MP3",
@@ -28,10 +34,7 @@ def get_file_type_name(file_type_code: int):
         11: "WAV",
         12: "AIFF",
     }
-    name = _get_file_type_name.get(file_type_code)
-    if name is None:
-        raise ValueError(f"Unknown file_type: {file_type_code}")
-    return name
+    return _get_file_type_name.get(file_type_code)
 
 
 def get_file_type_for_format(format_name: str):

{rekordbox_edit-0.7.0.dev44 → rekordbox_edit-0.7.0.dev49}/ruff.toml

@@ -26,6 +26,8 @@ exclude = [
   "node_modules",
   "site-packages",
   "venv",
+  "docs",
+  "research"
 ]
 
 # Same as Black.