rekordbox-edit 0.7.0.dev64__tar.gz → 0.7.0.dev69__tar.gz

{rekordbox_edit-0.7.0.dev64 → rekordbox_edit-0.7.0.dev69}/CHANGELOG.md

@@ -1,6 +1,16 @@
-## v0.7.0.dev64 (2026-07-31)
-
-
+## v0.7.0.dev69 (2026-07-31)
+
+
+- feat(convert): verify source codec against FileType before converting
+- test(cli): mock rekordbox pid check in edit CLI tests
+- feat: add probe/file-type matcher and codec_mismatch skip reason
+- feat(utils): probe codec and container in get_audio_info
+- feat: adds display and filtering support for all rekordbox file types
+- - creates a FileTypeInfo registry to map all the different dimensions of
+  FileType under one database code
+- adds AAC and ALAC .m4a FileTypes (4 and 6)
+- adds .mp4 FileType (3)
+- adds video FileType (16)
 - chore(deps): update dependency ty to v0.0.64 (#152)
 - Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
 - chore(deps): update pre-commit hook astral-sh/ruff-pre-commit to v0.16.0 (#149)

{rekordbox_edit-0.7.0.dev64 → rekordbox_edit-0.7.0.dev69}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rekordbox-edit
-Version: 0.7.0.dev64
+Version: 0.7.0.dev69
 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.dev64 → rekordbox_edit-0.7.0.dev69}/docs/filtering.md

@@ -17,7 +17,7 @@ Repeating a filter, or combining different filters, matches tracks that satisfy
 | `--exact-album TEXT` | album name is exactly `TEXT` |
 | `--playlist TEXT` | playlist name contains `TEXT` |
 | `--exact-playlist TEXT` | playlist name is exactly `TEXT` |
-| `--format FMT` | file format is `FMT` (`mp3`, `flac`, `aiff`, `wav`, `m4a`) |
+| `--format FMT` | Rekordbox file type is `FMT` (`mp3`, `mp4`, `aac`, `flac`, `alac`, `wav`, `aiff`, `video`, `invalid`) |
 | `--path TEXT` | file path contains `TEXT` (matched against the folder path, filename, or both) |
 | `--exact-path TEXT` | file path is exactly `TEXT` (resolved to an absolute path before matching) |
 | `--first N` | return only the first N results |

{rekordbox_edit-0.7.0.dev64 → rekordbox_edit-0.7.0.dev69}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "rekordbox-edit"
-version = "0.7.0.dev64"
+version = "0.7.0.dev69"
 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.dev64 → rekordbox_edit-0.7.0.dev69}/rekordbox_edit/_click.py

@@ -91,7 +91,10 @@ global_click_filters = [
     ),
     click.option(
         "--format",
-        type=click.Choice(["mp3", "flac", "aiff", "wav", "m4a"], case_sensitive=False),
+        type=click.Choice(
+            ["mp3", "mp4", "aac", "flac", "alac", "wav", "aiff", "video", "invalid"],
+            case_sensitive=False,
+        ),
         multiple=True,
         help="Find tracks of this format",
     ),

{rekordbox_edit-0.7.0.dev64 → rekordbox_edit-0.7.0.dev69}/rekordbox_edit/api/convert.py

@@ -21,12 +21,14 @@ from rekordbox_edit.models import (
 )
 from rekordbox_edit.query import get_filtered_content
 from rekordbox_edit.utils import (
-    InputFormats,
+    FILE_TYPES,
+    AudioInfo,
     OutputFormats,
     get_audio_info,
     get_extension_for_format,
     get_file_type_for_format,
     get_file_type_name,
+    probe_matches_file_type,
 )
 
 logger = logging.getLogger(__name__)
@@ -34,8 +36,8 @@ 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}
+# Rekordbox FileType codes RBE converts from: the lossless whitelist.
+_INPUT_FILE_TYPES = {code for code, info in FILE_TYPES.items() if info.convertable}
 
 _HI_RES_CODECS = {
     "aiff": "pcm_s16be",
@@ -55,16 +57,14 @@ def _effective_sample_rate(source_rate: int | None) -> int:
     return TARGET_SAMPLE_RATE
 
 
-def _classify_source_fidelity(
-    source_path,
+def _classify_fidelity(
+    audio_info: AudioInfo,
 ) -> Tuple[Literal["lossless", "lossy"], int]:
-    """Probe a source file and return the conversion's fidelity along with
-    its effective sample rate. "lossless" means no audio information is lost:
-    the source is at the target bit depth and at or below the target sample
-    rate. An unknown bit depth counts as lossy so originals are kept when in
-    doubt.
+    """The conversion's fidelity and effective sample rate for a probed
+    source. "lossless" means no audio information is lost: the source is at
+    the target bit depth and at or below the target sample rate. An unknown
+    bit depth counts as lossy so originals are kept when in doubt.
     """
-    audio_info = get_audio_info(source_path)
     bit_depth = audio_info["bit_depth"]
     sample_rate = audio_info["sample_rate"]
     logger.debug(
@@ -374,13 +374,25 @@ def convert(
             if not os.path.exists(src):
                 raise RuntimeError(f"Source not found: {src}")
 
+            audio_info = get_audio_info(src)
+            if not probe_matches_file_type(
+                content.FileType, audio_info["codec"], audio_info["container"]
+            ):
+                logger.warning(
+                    f"Skipping {content.FileNameL}: probed codec "
+                    f"{audio_info['codec']!r} does not match its Rekordbox "
+                    f"file type {get_file_type_name(content.FileType)!r}"
+                )
+                skipped.append(SkippedTrack(id=op.id, reason="codec_mismatch"))
+                continue
+
             if args.format_out.upper() == "MP3":
                 output_sample_rate = TARGET_SAMPLE_RATE
                 success = _run_ffmpeg(
                     src, op.output_path, _mp3_output_kwargs(output_sample_rate), "mp3"
                 )
             else:
-                fidelity, output_sample_rate = _classify_source_fidelity(src)
+                fidelity, output_sample_rate = _classify_fidelity(audio_info)
                 if fidelity == "lossless":
                     lossless_op_ids.add(op.id)
                 output_format = OutputFormats(args.format_out.lower())

{rekordbox_edit-0.7.0.dev64 → rekordbox_edit-0.7.0.dev69}/rekordbox_edit/cli/convert.py

@@ -48,9 +48,10 @@ logger = logging.getLogger(__name__)
 def convert_command(db, **kwargs):
     """Convert hi-res audio files between formats and update RekordBox database.
 
-    Supports conversion from any hi-res format (FLAC, AIFF, WAV) to:
-    AIFF, FLAC, WAV, or MP3. Skips lossy formats and files already in
-    the target format.
+    Supports conversion from any hi-res format (FLAC, ALAC, AIFF, WAV) to:
+    AIFF, FLAC, WAV, or MP3. Skips lossy formats, video, and files already
+    in the target format. Each source's codec is verified against its
+    database file type before converting; mismatches are skipped.
 
     Lossless conversions target 16-bit/44.1 kHz: higher-resolution sources
     are down-sampled, and sources below the target keep their own sample
@@ -122,6 +123,9 @@ def convert_command(db, **kwargs):
             return
         response = convert(db, args)
 
+    # The preview cannot surface codec_mismatch (dry runs never probe), so
+    # report skips found only during the live run.
+    _report_skips([s for s in response.result.skipped if s.reason == "codec_mismatch"])
     _print_convert_result(response, print_opt, scripting_mode, dry_run=False)
 
 
@@ -129,17 +133,23 @@ 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")
+    mismatches = sum(1 for s in skipped if s.reason == "codec_mismatch")
     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)"
+            "(only FLAC, ALAC, AIFF, WAV are converted)"
         )
     if conflicts:
         logger.warning(
             f"Skipping {conflicts} file(s): output exists (use --overwrite to convert)"
         )
+    if mismatches:
+        logger.warning(
+            f"Skipping {mismatches} file(s): file content does not match its "
+            "Rekordbox file type"
+        )
 
 
 def _print_convert_result(

{rekordbox_edit-0.7.0.dev64 → rekordbox_edit-0.7.0.dev69}/rekordbox_edit/models.py

@@ -130,6 +130,7 @@ SkipReason: TypeAlias = Literal[
     "already_target_format",
     "unsupported_source_format",
     "output_file_exists",
+    "codec_mismatch",
 ]
 
 

{rekordbox_edit-0.7.0.dev64 → rekordbox_edit-0.7.0.dev69}/rekordbox_edit/query.py

@@ -132,7 +132,7 @@ class CollectionQuery:
 
     def by_format(self, format_name: str) -> "CollectionQuery":
         """Filter by file format."""
-        from rekordbox_edit.utils import get_file_type_for_format
+        from rekordbox_edit.utils import get_file_type_codes_for_format
 
         if not format_name:
             logger.warning("Empty format filter has no effect")
@@ -141,8 +141,8 @@ class CollectionQuery:
         new_inst = self._copy()
 
         try:
-            file_type_code = get_file_type_for_format(format_name)
-            condition = DjmdContent.FileType == file_type_code
+            file_type_codes = get_file_type_codes_for_format(format_name)
+            condition = DjmdContent.FileType.in_(file_type_codes)
             new_inst._conditions.append(condition)
         except ValueError:
             logger.warning(f"Invalid format: {format_name}")

{rekordbox_edit-0.7.0.dev64 → rekordbox_edit-0.7.0.dev69}/rekordbox_edit/utils.py

@@ -3,7 +3,9 @@
 import logging
 import platform
 import shutil
+from dataclasses import dataclass
 from enum import Enum
+from typing import TypedDict
 
 import click
 import ffmpeg
@@ -17,61 +19,131 @@ class UserQuit(Exception):
     pass
 
 
-# File type mappings for Rekordbox database
-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.
+@dataclass(frozen=True)
+class FileTypeInfo:
+    """One Rekordbox FileType code: how RBE names, filters, probes, and
+    converts it. ``codecs`` are ffprobe codec_name prefixes and
+    ``containers`` are format_name substrings; a probe must satisfy both
+    (WAV and AIFF share PCM codecs, so their containers disambiguate)."""
+
+    code: int
+    name: str
+    token: str
+    extension: str | None = None
+    codecs: tuple[str, ...] = ()
+    containers: tuple[str, ...] = ()
+    convertable: bool = False
+
+
+FILE_TYPES: dict[int, FileTypeInfo] = {
+    # Corrupt or empty content, independent of container.
+    0: FileTypeInfo(code=0, name="INVALID", token="invalid"),
+    1: FileTypeInfo(code=1, name="MP3", token="mp3", extension=".mp3", codecs=("mp3",)),
+    # 3 is the .mp4 container regardless of content: audio-only AAC/ALAC
+    # .mp4 files land here alongside video .mp4, so RBE never converts it.
+    3: FileTypeInfo(code=3, name="MP4", token="mp4"),
+    4: FileTypeInfo(code=4, name="AAC", token="aac", codecs=("aac",)),
+    5: FileTypeInfo(
+        code=5,
+        name="FLAC",
+        token="flac",
+        extension=".flac",
+        codecs=("flac",),
+        convertable=True,
+    ),
+    6: FileTypeInfo(
+        code=6,
+        name="ALAC",
+        token="alac",
+        codecs=("alac",),
+        convertable=True,
+    ),
+    11: FileTypeInfo(
+        code=11,
+        name="WAV",
+        token="wav",
+        extension=".wav",
+        codecs=("pcm_",),
+        containers=("wav",),
+        convertable=True,
+    ),
+    12: FileTypeInfo(
+        code=12,
+        name="AIFF",
+        token="aiff",
+        extension=".aiff",
+        codecs=("pcm_",),
+        containers=("aiff",),
+        convertable=True,
+    ),
+    # Catch-all for non-mp4 video containers (avi, m4v, mov, mpg).
+    16: FileTypeInfo(code=16, name="VIDEO", token="video"),
+}
 
-    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.
-    """
+
+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."""
     if file_type_code is None:
         return None
-    _get_file_type_name = {
-        0: "MP3",
-        1: "MP3",
-        4: "M4A",
-        5: "FLAC",
-        11: "WAV",
-        12: "AIFF",
-    }
-    return _get_file_type_name.get(file_type_code)
-
-
-def get_file_type_for_format(format_name: str):
-    """Get file type code for format name (case-insensitive)."""
+    info = FILE_TYPES.get(file_type_code)
+    return info.name if info else None
+
+
+def get_file_type_codes_for_format(format_name: str) -> set[int]:
+    """All FileType codes a format token matches (case-insensitive).
+
+    Tokens mirror FileType values one to one.
+    """
     if not format_name:
         raise ValueError("Format name cannot be empty or None")
-    _get_file_type_for_format = {"MP3": 1, "M4A": 4, "FLAC": 5, "WAV": 11, "AIFF": 12}
-    file_type = _get_file_type_for_format.get(format_name.upper())
-    if file_type is None:
+    token = format_name.lower()
+    codes = {code for code, info in FILE_TYPES.items() if token == info.token}
+    if not codes:
         raise ValueError(f"Unknown format: {format_name}")
-    return file_type
+    return codes
 
 
-def get_extension_for_format(format_name: str):
-    """Get file extension for format name (case-insensitive)."""
+def get_file_type_for_format(format_name: str) -> int:
+    """The FileType code Rekordbox records for files RBE writes in this
+    output format (case-insensitive). Raises for non-output formats."""
     if not format_name:
         raise ValueError("Format name cannot be empty or None")
-    _get_extension_for_format = {
-        "MP3": ".mp3",
-        "AIFF": ".aiff",
-        "FLAC": ".flac",
-        "WAV": ".wav",
-    }
-    extension = _get_extension_for_format.get(format_name.upper())
-    if extension is None:
-        raise ValueError(f"Unknown format: {format_name}")
+    token = format_name.lower()
+    for code, info in FILE_TYPES.items():
+        if info.extension and token == info.token:
+            return code
+    raise ValueError(f"Unknown format: {format_name}")
+
+
+def get_extension_for_format(format_name: str) -> str:
+    """Get file extension for an output format name (case-insensitive)."""
+    code = get_file_type_for_format(format_name)
+    extension = FILE_TYPES[code].extension
+    assert extension is not None  # get_file_type_for_format only returns such codes
     return extension
 
 
-class OutputFormats(Enum):
-    MP3 = "mp3"
-    FLAC = "flac"
-    AIFF = "aiff"
-    WAV = "wav"
+def probe_matches_file_type(
+    file_type_code: int | None, codec: str | None, container: str | None
+) -> bool:
+    """Whether a probed codec/container is consistent with a Rekordbox
+    FileType code. Unknown codes never match, so callers treat them as
+    mismatches instead of converting blind."""
+    if file_type_code is None:
+        return False
+    info = FILE_TYPES.get(file_type_code)
+    if info is None:
+        return False
+    if info.codecs and not (codec or "").startswith(info.codecs):
+        return False
+    if info.containers:
+        if not container or not any(c in container for c in info.containers):
+            return False
+    return True
 
 
-class InputFormats(Enum):
+class OutputFormats(Enum):
+    MP3 = "mp3"
     FLAC = "flac"
     AIFF = "aiff"
     WAV = "wav"
@@ -99,12 +171,24 @@ or https://ffmpeg.org/download.html
 """
 
 
-def get_audio_info(file_path) -> dict[str, int | None]:
+class AudioInfo(TypedDict):
+    """Fields extracted from an ffmpeg probe of one audio file."""
+
+    bit_depth: int | None
+    sample_rate: int
+    channels: int
+    bitrate: int | None
+    codec: str | None
+    container: str | None
+
+
+def get_audio_info(file_path) -> AudioInfo:
     """Get audio information from file using ffmpeg probe.
 
     Returns None for any field that cannot be determined from the probe data.
-    Callers are responsible for handling None values and applying format-specific
-    assumptions (e.g. MP3 has no true bit depth).
+    Callers are responsible for handling None values and applying
+    format-specific assumptions (e.g. MP3 has no true bit depth). ``codec``
+    is the stream's codec_name and ``container`` the probe's format_name.
     """
     try:
         # Check if ffmpeg is available first
@@ -163,6 +247,8 @@ def get_audio_info(file_path) -> dict[str, int | None]:
             "sample_rate": int(audio_stream.get("sample_rate", 44100)),
             "channels": int(audio_stream.get("channels", 2)),
             "bitrate": bitrate,
+            "codec": audio_stream.get("codec_name"),
+            "container": probe.get("format", {}).get("format_name"),
         }
     except Exception as e:
         logger.error(f"Failed to get audio info for {file_path}: {e}")