rekordbox-edit 0.7.0.dev72__tar.gz → 0.8.0.dev6__tar.gz

{rekordbox_edit-0.7.0.dev72 → rekordbox_edit-0.8.0.dev6}/.github/actions/build-release-notes/build_release_notes.py

@@ -3,10 +3,10 @@
 
 Lists one entry per commit (not per PR) between ``FROM_TAG`` (exclusive) and
 ``TO_TAG`` (inclusive). Each entry links the pull request that introduced the
-commit and credits its author. The PR (number and author login) is resolved via
-``GET /repos/{repo}/commits/{sha}/pulls``, which works for both squash and
-rebase merges. Commits with no associated PR fall back to a short-SHA reference
-and the git author name.
+commit and credits its author. PRs are resolved through a batched GraphQL query
+(``Commit.associatedPullRequests``), which works for both squash and rebase
+merges without a per-commit round trip. Commits with no associated PR fall back
+to a short-SHA reference and the git author name.
 """
 
 from __future__ import annotations
@@ -97,21 +97,63 @@ def read_commits(from_tag: str, to_tag: str) -> list[Commit]:
     return commits
 
 
-def resolve_pr(repo: str, sha: str) -> tuple[int, str] | None:
-    """Return the (number, author_login) of a commit's PR, or None if unresolved."""
-    result = _run(["gh", "api", f"repos/{repo}/commits/{sha}/pulls"])
-    if result.returncode != 0 or not result.stdout.strip():
-        return None
-    try:
-        prs = json.loads(result.stdout)
-    except json.JSONDecodeError:
-        return None
-    merged = [pr for pr in prs if pr.get("merged_at")]
-    chosen = merged[0] if merged else (prs[0] if prs else None)
+# GitHub's GraphQL node limit is generous; keep chunks small enough that the
+# query fits comfortably in a single command-line argument on any platform.
+_CHUNK = 100
+
+_COMMIT_FIELD = (
+    'c{i}: object(oid: "{sha}") {{ ... on Commit {{ '
+    "associatedPullRequests(first: 5) {{ nodes {{ number merged author {{ login }} }} }} "
+    "}} }}"
+)
+
+
+def _chunks(items: list[str], size: int):
+    for start in range(0, len(items), size):
+        yield items[start : start + size]
+
+
+def _pick_pr(nodes: list[dict]) -> tuple[int, str] | None:
+    merged = [pr for pr in nodes if pr.get("merged")]
+    chosen = merged[0] if merged else (nodes[0] if nodes else None)
     if not chosen:
         return None
-    login = (chosen.get("user") or {}).get("login", "")
-    return chosen["number"], login
+    return chosen["number"], (chosen.get("author") or {}).get("login", "")
+
+
+def resolve_prs(repo: str, shas: list[str]) -> dict[str, tuple[int, str]]:
+    """Resolve every commit's PR (number, author_login) in batched GraphQL calls.
+
+    One request per ``_CHUNK`` commits replaces the previous per-commit REST call,
+    which dominated runtime. Commits with no associated PR are simply absent from
+    the returned mapping.
+    """
+    owner, _, name = repo.partition("/")
+    resolved: dict[str, tuple[int, str]] = {}
+    for chunk in _chunks(shas, _CHUNK):
+        fields = " ".join(
+            _COMMIT_FIELD.format(i=i, sha=sha) for i, sha in enumerate(chunk)
+        )
+        query = (
+            f'query {{ repository(owner: "{owner}", name: "{name}") {{ {fields} }} }}'
+        )
+        result = _run(["gh", "api", "graphql", "-f", f"query={query}"])
+        if result.returncode != 0 or not result.stdout.strip():
+            continue
+        try:
+            repository = (json.loads(result.stdout).get("data") or {}).get("repository")
+        except json.JSONDecodeError:
+            continue
+        if not repository:
+            continue
+        for i, sha in enumerate(chunk):
+            node = repository.get(f"c{i}")
+            if not node:
+                continue
+            pr = _pick_pr((node.get("associatedPullRequests") or {}).get("nodes") or [])
+            if pr is not None:
+                resolved[sha] = pr
+    return resolved
 
 
 def categorize(commit: Commit) -> str:
@@ -123,9 +165,8 @@ def categorize(commit: Commit) -> str:
     return _UNCATEGORIZED_HEADER
 
 
-def render_line(commit: Commit, repo: str) -> str:
+def render_line(commit: Commit, pr: tuple[int, str] | None) -> str:
     subject = _TRAILING_PR.sub("", commit.subject)
-    pr = resolve_pr(repo, commit.sha)
     if pr is not None:
         number, login = pr
         credit = f"#{number} by @{login}" if login else f"#{number}"
@@ -134,11 +175,13 @@ def render_line(commit: Commit, repo: str) -> str:
 
 
 def build_notes(commits: list[Commit], repo: str) -> str:
+    included = [c for c in commits if not _SKIP_SUBJECT.match(c.subject)]
+    pr_map = resolve_prs(repo, [c.sha for c in included])
+
     categories = {header: Category(header) for header in _CATEGORY_ORDER}
-    for commit in commits:
-        if _SKIP_SUBJECT.match(commit.subject):
-            continue
-        categories[categorize(commit)].lines.append(render_line(commit, repo))
+    for commit in included:
+        line = render_line(commit, pr_map.get(commit.sha))
+        categories[categorize(commit)].lines.append(line)
 
     sections = [
         f"{cat.header}\n" + "\n".join(cat.lines)

{rekordbox_edit-0.7.0.dev72 → rekordbox_edit-0.8.0.dev6}/.github/workflows/cd.yml

@@ -25,7 +25,7 @@ jobs:
       should_skip: ${{ steps.skip_check.outputs.should_skip }}
     steps:
       - id: skip_check
-        uses: fkirc/skip-duplicate-actions@f75f66ce1886f00957d99748a42c724f4330bdcf # v5
+        uses: fkirc/skip-duplicate-actions@b974a9395958c231af965b70070979a577efa578 # v5
         with:
           concurrent_skipping: "same_content_newer"
           cancel_others: "true"
@@ -93,7 +93,7 @@ jobs:
           git push origin canary-v${{ steps.version.outputs.version }}
 
       - name: Publish to PyPI
-        uses: pypa/gh-action-pypi-publish@ba38be9e461d3875417946c167d0b5f3d385a247 # release/v1
+        uses: pypa/gh-action-pypi-publish@dc37677b2e1c63e2034f94d8a5b11f265b73ba33 # release/v1
         with:
           skip-existing: true
 

{rekordbox_edit-0.7.0.dev72 → rekordbox_edit-0.8.0.dev6}/.github/workflows/publish.yml

@@ -39,7 +39,7 @@ jobs:
           name: dist
           path: dist/
       - name: Publish package distributions 📦 to TestPyPI
-        uses: pypa/gh-action-pypi-publish@ba38be9e461d3875417946c167d0b5f3d385a247 # release/v1
+        uses: pypa/gh-action-pypi-publish@dc37677b2e1c63e2034f94d8a5b11f265b73ba33 # release/v1
         with:
           repository-url: https://test.pypi.org/legacy/
 
@@ -57,4 +57,4 @@ jobs:
           path: dist
           merge-multiple: true
       - name: Publish to PyPI
-        uses: pypa/gh-action-pypi-publish@ba38be9e461d3875417946c167d0b5f3d385a247 # release/v1
+        uses: pypa/gh-action-pypi-publish@dc37677b2e1c63e2034f94d8a5b11f265b73ba33 # release/v1

{rekordbox_edit-0.7.0.dev72 → rekordbox_edit-0.8.0.dev6}/.pre-commit-config.yaml

@@ -18,7 +18,7 @@ repos:
     -   id: check-toml
     -   id: check-case-conflict
 -   repo: https://github.com/commitizen-tools/commitizen
-    rev: v4.16.5
+    rev: v4.17.0
     hooks:
     -   id: commitizen
         stages: [commit-msg]

{rekordbox_edit-0.7.0.dev72 → rekordbox_edit-0.8.0.dev6}/CHANGELOG.md

@@ -1,4 +1,20 @@
-## v0.7.0.dev72 (2026-07-31)
+## v0.8.0.dev6 (2026-08-01)
+
+
+- feat!: replace --exact-path with case-insensitive --resolved-path
+- Path filters now always match case-insensitively, mirroring how NTFS
+and APFS treat paths. --resolved-path makes its argument absolute by
+pure string math instead of Path.resolve(), so results no longer
+depend on mounted drives, on-disk casing, or symlinks.
+- chore(deps): update pre-commit hook commitizen-tools/commitizen to v4.17.0 (#159)
+- Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
+- chore: reduce renovate schedule to weekends
+- docs: add FAQ about converts impact on USB exports
+- chore(deps): update github actions (#151)
+- Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
+- ci: optimize the build_release_notes script
+
+## v0.7.0 (2026-07-31)
 
 
 - ci: more precise changelogs on releases

{rekordbox_edit-0.7.0.dev72 → rekordbox_edit-0.8.0.dev6}/PKG-INFO

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

@@ -2,13 +2,13 @@
 
 Messing with your Rekordbox library is bound to raise some questions and concerns, particularly around preserving all the manual work you've done to organize, catalog, and prepare your library for gigs. This page is dedicated to answering those questions around what the impact and risks are of editing your rekordbox library or the underlying audio files using rekordbox-edit. If your question isn't answered here, please ask it in [a discussion](https://github.com/jviall/rekordbox-edit/discussions/new/choose).
 
-## How Does Rekordbox's Analysis Work?
+## How does Rekordbox's analysis work?
 
 Analysis touches two places in your library. The database gets the summary values for things like tempo, key, and the flags Rekordbox uses to track analysis state. The heavier artifacts live in a per-track folder of analysis files (.ANLZ) containing the beat grid, waveforms, and phrase data. Your cues and loops live in neither; they are separate database records that only your own edits change.
 
 What analysis writes is a deterministic estimate. Deterministic, because the same file analyzed twice produces byte-identical results. An estimate, because tempo, grid, and key are inferred from the audio, and Rekordbox's inference is sometimes wrong. Both aspects are worth considering; when the analysis of a converted file produces a different result, it is simply a different estimate from different data.
 
-## How Does Converting a Track Affect the Analysis?
+## How does converting a track affect its analysis?
 
 The reason conversion is safe comes down to how Rekordbox stores analysis: positions are timestamps. The beat grid is a list of times in milliseconds, cues are stored in milliseconds, and phrases are anchored to beats. None of it references sample counts or byte positions in the audio file. Change the codec, the sample rate, or the bit depth, and every stored position still names the same musical moment.
 
@@ -21,19 +21,19 @@ There are a few minor things left stale by a conversion (without any consequence
 
 Converting *to* FLAC does not create that seek index automatically either; only an analysis can. I have *not* tested (yet) whether that matters in practice, but it makes a stronger case for re-analyzing after a conversion to FLAC than for other targets. FLAC also is not the most ideal target format in general for Rekordbox (even though it's preferred for streaming and music hoarders), because only the more recent Pioneer devices support it. AIFF is what I would pick if you insist on lossless.
 
-## Does Converting to MP3 Shift the Audio?
+## Does converting to MP3 shift the audio?
 
 No. `rbe` uses LAME's gapless-playback encoding to avoid any start-of-file offset, and across many tests the MP3 320 output never differed in timing, sample for sample, from its lossless source. Cues and the beat grid stay exactly in register.
 
 The only artifact is visual: the drawn waveform still reflects the lossless original rather than the MP3. A re-analysis would redraw it, but you'd be hard-pressed to notice the difference.
 
-## Will My Cues and Beatgrid Survive?
+## Does convert impact cues or beatgrids?
 
-Yes. Cues, loops, and memory points are records in your library database, positioned in milliseconds and attached to the track's database entry, and `rbe convert` does not touch them. The beat grid lives in the analysis files, which convert also leaves alone. In all my testing, every cue and beat grid has been completely unchanged by a conversion, and works just as it did prior.
+No. Cues, loops, and memory points are records in your library database, positioned in milliseconds and attached to the track's database entry, and `rbe convert` does not touch them. The beat grid lives in the analysis files, which convert also leaves alone. In all my testing, every cue and beat grid has been completely unchanged by a conversion, and works just as it did prior.
 
 This includes hand-tuned grids. Because convert never rewrites the grid a manually corrected beat grid survives conversion unchanged. The one operation that can replace it is a re-analysis you run yourself; see below.
 
-## Should I Re-Analyze After Converting?
+## Should I re-analyze after converting?
 
 You do not need to. The existing analysis remains correct for the converted file, and Rekordbox never re-analyzes on its own; it waits for you to ask. Skipping re-analysis keeps your grid and cues exactly as they are.
 
@@ -41,10 +41,19 @@ If you do re-analyze, the outcome depends on whether the conversion changed the
 
 One real hazard: re-analysis replaces manually edited beat grids on any track that is not locked. If you plan to re-analyze after a bulk conversion, turn on Analysis Lock first for tracks whose grids you have tuned by hand.
 
-## What Should I Do Before Converting?
+## What if I convert a track that's been exported to a USB?
+
+Conversion only touches your library and the source file--it won't update your USB exports for you. The old version of the track that's on your USB will effectively be orphaned from the library. Depending on the library type (i.e. "Device Library" v.s. "One Device Library") re-syncing will either not do anything, or it will add your new converted versions but leave the stale copies behind. Manually transferring a playlist to a device and overwriting it (by drag-n-dropping in the library explorer tree) will also only add your new versions but not remove the old ones.
+
+Perhaps a more crucial consequence of this orphaning of converted files on your USB, is that any cues, play counts, or other metadata of the converted files that is only on your USB and hasn't been synced back to Rekordbox will also be orphaned, and attempting to sync this back after a conversion won't work.
+
+Ultimately, if you're planning on doing an in-place conversion of tracks in your library using this tool, you should consider making sure the cues, grid, and info on your USB sticks has been synced back to Rekordbox (if so desired), and be prepared to erase and freshly export your USBs in order to avoid any stale files left behind by a re-export.
+
+## What should I do before converting?
 
 - **Preview with `--dry-run`.** See exactly which tracks will convert and where the files will go before anything is written.
 - **Close Rekordbox.** Writing to the database while Rekordbox has it open risks corruption.
-- **Make fresh backups of your music and your Rekordbox database.** Conversion rewrites files and database rows in place; a current backup makes any surprise reversible.
+- **Make fresh backups of your music and your Rekordbox database.** Conversion rewrites files and database rows in place; a current backup makes any mistake reversible.
+- **Sync back cues, grids, and info from your USBs** Converting a track that has been exported will orphan the exported version and any un-synced metadata from your library.
 - **Keep your originals until you are satisfied.** The default `--delete-originals lossless` only deletes a source when no audio information was lost. Be deliberate before choosing `all`.
 - **Lock hand-tuned beat grids if you plan to re-analyze.** Conversion won't mess with your grids, but a later bulk re-analysis replaces grids on unlocked tracks. Analysis Lock exists for exactly this.

{rekordbox_edit-0.7.0.dev72 → rekordbox_edit-0.8.0.dev6}/docs/filtering.md

@@ -18,14 +18,16 @@ Repeating a filter, or combining different filters, matches tracks that satisfy
 | `--playlist TEXT` | playlist name contains `TEXT` |
 | `--exact-playlist TEXT` | playlist name is exactly `TEXT` |
 | `--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) |
+| `--path TEXT` | file path contains `TEXT`, case-insensitive |
+| `--resolved-path TEXT` | file path contains `TEXT` after resolving it to an absolute path, case-insensitive |
 | `--first N` | return only the first N results |
 | `--last N` | return only the last N results |
 
 > [!TIP]
 > Filters that are "exact" are case-sensitive (e.g. `--exact-artist 'HOOBASTANK'` won't match "Hoobastank") whereas their counterparts (`--artist`) are case-insensitive and match substrings. Only one of either the `--first` and `--last` filters can be provided at a time as they're mutually exclusive.
 
+> [!NOTE]
+> Path filters match case-insensitively on every platform because the filesystems Rekordbox supports (NTFS and APFS) treat paths case-insensitively themselves.
 
 ### Examples
 
@@ -45,11 +47,14 @@ rbe search --playlist "house" --playlist "disco"
 # All the songs in my library that aren't in any playlist
 rbe search --playlist ""
 
-# The first 10 tracks whose path contains a folder or filename substring
+# The first 10 tracks in a "Favorites" folder or with "track.wav" in the file path
 rbe search --path "Favorites/" --path "track.wav" --first 10
 
 # The track at an exact location
-rbe search --exact-path "/Users/djmustard/Music/banger.mp3"
+rbe search --resolved-path "/Users/djmustard/Music/banger.mp3"
+
+# Every track under a folder, given relative to the current directory
+rbe search --resolved-path "../Music/house/"
 ```
 
 ## Track ID Arguments

{rekordbox_edit-0.7.0.dev72 → rekordbox_edit-0.8.0.dev6}/pyproject.toml

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

@@ -81,13 +81,14 @@ global_click_filters = [
         "--path",
         type=str,
         multiple=True,
-        help="Find tracks whose file paths include this value",
+        help="Find tracks whose file paths contain this value (case-insensitive)",
     ),
     click.option(
-        "--exact-path",
+        "--resolved-path",
         type=str,
         multiple=True,
-        help="Find tracks whose file paths are exactly this value",
+        help="Find tracks whose file paths contain this value after it is "
+        "resolved to an absolute path (case-insensitive)",
     ),
     click.option(
         "--format",

{rekordbox_edit-0.7.0.dev72 → rekordbox_edit-0.8.0.dev6}/rekordbox_edit/cli/_utils.py

@@ -74,7 +74,7 @@ def _narrow_to_track_ids(args, ids: list[str]):
         "album",
         "exact_album",
         "path",
-        "exact_path",
+        "resolved_path",
         "format",
     ):
         if hasattr(narrowed, field_name):

{rekordbox_edit-0.7.0.dev72 → rekordbox_edit-0.8.0.dev6}/rekordbox_edit/models.py

@@ -45,7 +45,7 @@ class FilterArgs(BaseModel):
     album: list[str] = []
     exact_album: list[str] = []
     path: list[str] = []
-    exact_path: list[str] = []
+    resolved_path: list[str] = []
     format: list[str] = []
     first: int | None = Field(default=None, gt=0)
     last: int | None = Field(default=None, gt=0)

{rekordbox_edit-0.7.0.dev72 → rekordbox_edit-0.8.0.dev6}/rekordbox_edit/query.py

@@ -1,4 +1,5 @@
 import logging
+import os
 from pathlib import Path
 from typing import List, Tuple, Union
 
@@ -148,57 +149,32 @@ class CollectionQuery:
             logger.warning(f"Invalid format: {format_name}")
         return new_inst
 
-    def by_path(self, path_str: str, exact: bool = False) -> "CollectionQuery":
-        """Filter by file path, matching against FolderPath and/or FileNameL.
-
-        Paths get normalized to posix format.
-        --path args arg matched as substrings.
-        --exact-path argsl are resolved to absolute paths and must match exact.
-
-        Args with a trailing '/' only query against FolderPath.
-        Args with no parent folders in the path only query against FileNameL.
+    def by_path(self, path_str: str, resolved: bool = False) -> "CollectionQuery":
+        """Filter by case-insensitive substring of the track's file path.
+        FolderPath holds the full path to the file, including its name and
+        extension.
+
+        Separators get normalized to posix format, and a trailing '/' is kept
+        so the substring only matches directory components.
+        --path args match as given.
+        --resolved-path args are made absolute against the working directory
+        by pure string math (no filesystem access), so casing stays as typed
+        and symlinks are never followed.
         """
-        new_inst = self._copy()
+        if not path_str:
+            return self
 
-        is_dir_only = path_str.endswith("/") or path_str.endswith("\\")
+        new_inst = self._copy()
+        has_trailing_sep = path_str.endswith(("/", "\\"))
 
-        if exact:
-            resolved = Path(path_str).resolve()
-            if is_dir_only:
-                folder_part = resolved.as_posix() + "/"
-                name_part = ""
-            elif "/" not in path_str and "\\" not in path_str:
-                folder_part = ""
-                name_part = resolved.name
-            else:
-                folder_part = resolved.parent.as_posix() + "/"
-                name_part = resolved.name
+        if resolved:
+            pattern = Path(os.path.abspath(path_str)).as_posix()
+            if has_trailing_sep and not pattern.endswith("/"):
+                pattern += "/"
         else:
-            normalized = Path(path_str)
-            if is_dir_only:
-                folder_part = normalized.as_posix()
-                name_part = ""
-            else:
-                parent_str = normalized.parent.as_posix()
-                folder_part = "" if parent_str == "." else parent_str
-                name_part = normalized.name
-
-        conditions: list[ColumnElement[bool]] = []
-        if folder_part:
-            if exact:
-                conditions.append(DjmdContent.FolderPath == folder_part)
-            else:
-                conditions.append(DjmdContent.FolderPath.ilike(f"%{folder_part}%"))
-        if name_part:
-            if exact:
-                conditions.append(DjmdContent.FileNameL == name_part)
-            else:
-                conditions.append(DjmdContent.FileNameL.ilike(f"%{name_part}%"))
-
-        if conditions:
-            combined = and_(*conditions) if len(conditions) > 1 else conditions[0]
-            new_inst._conditions.append(combined)
+            pattern = path_str.replace("\\", "/")
 
+        new_inst._conditions.append(DjmdContent.FolderPath.ilike(f"%{pattern}%"))
         return new_inst
 
     def limit(self, count: int) -> "CollectionQuery":
@@ -317,8 +293,8 @@ def get_filtered_content(
     for path in filters.path:
         query = query.by_path(path)
 
-    for exact_path in filters.exact_path:
-        query = query.by_path(exact_path, exact=True)
+    for resolved_path in filters.resolved_path:
+        query = query.by_path(resolved_path, resolved=True)
 
     if filters.match_all:
         query = query.match_all()

{rekordbox_edit-0.7.0.dev72 → rekordbox_edit-0.8.0.dev6}/renovate.json5

@@ -8,8 +8,8 @@
     ":enablePreCommit",
     ":automergePr",
     "helpers:pinGitHubActionDigests",
-    "schedule:daily",
-    "schedule:automergeDaily",
+    "schedule:weekends",
+    "schedule:automergeEarlyMondays",
   ],
 
   branchPrefix: "chore/deps/",

{rekordbox_edit-0.7.0.dev72 → rekordbox_edit-0.8.0.dev6}/tests/test_query.py

@@ -468,58 +468,44 @@ class TestCollectionQuery:
         assert " and " in stmt_str
         assert " or " not in stmt_str
 
-    def test_by_path_filename_only(self):
-        """A bare filename (no directory) adds a FileNameL ilike condition only.
-        The FolderPath condition is skipped — the filter still runs with just FileNameL.
-        """
+    def test_by_path_substring_against_folderpath_only(self):
+        """A --path arg adds a single case-insensitive substring condition on
+        FolderPath, which holds the full file path. FileNameL is never queried."""
         query = CollectionQuery()
-        new_query = query.by_path("track.mp3")
+        new_query = query.by_path("Daft Punk")
 
         assert new_query is not query
         assert len(new_query._conditions) == 1
         condition_str = str(new_query._conditions[0])
-        assert "FileNameL" in condition_str
+        assert "FolderPath" in condition_str
+        assert "FileNameL" not in condition_str
         assert "LIKE lower" in condition_str
-        assert "FolderPath" not in condition_str
 
-    def test_by_path_folder_only_forward_slash(self):
-        """A trailing-forward-slash string adds a FolderPath ilike condition only.
-        The FileNameL condition is skipped — the filter still runs with just FolderPath.
-        """
+    def test_by_path_wraps_with_wildcards(self):
+        """The substring pattern is wrapped in % wildcards."""
         query = CollectionQuery()
-        new_query = query.by_path("./Test/Folder/")
+        new_query = query.by_path("track.mp3")
 
-        assert new_query is not query
-        assert len(new_query._conditions) == 1
-        condition_str = str(new_query._conditions[0])
-        assert "FileNameL" not in condition_str
-        assert "LIKE lower" in condition_str
-        assert "FolderPath" in condition_str
+        condition_str = _compile(new_query._conditions[0])
+        assert "%track.mp3%" in condition_str
 
-    def test_by_path_folder_and_filename(self):
-        """A path with both parts adds a compound AND condition covering both columns."""
+    def test_by_path_preserves_trailing_slash(self):
+        """A trailing slash stays in the pattern so it only matches directory
+        components, not filename prefixes."""
         query = CollectionQuery()
-        new_query = query.by_path("Music/Artist/track.mp3")
+        new_query = query.by_path("Daft Punk/")
 
-        assert new_query is not query
-        assert len(new_query._conditions) == 1
-        condition_str = str(new_query._conditions[0])
-        assert "FolderPath" in condition_str
-        assert "FileNameL" in condition_str
-        assert " AND " in condition_str
-        assert condition_str.count("LIKE lower") == 2
+        condition_str = _compile(new_query._conditions[0])
+        assert "%Daft Punk/%" in condition_str
 
-    @pytest.mark.skipif(
-        platform.system() != "Windows", reason="backslash path parsing is Windows-only"
-    )
     def test_by_path_backslash_normalised_to_forward_slash(self):
         """Backslash separators in --path input are normalised to forward slashes."""
         query = CollectionQuery()
-        new_query = query.by_path("Music\\Artist\\track.mp3")
+        new_query = query.by_path("Music\\Artist\\")
 
-        query_str = _compile(new_query._conditions[0])
-        assert "\\" not in query_str
-        assert "Music/Artist" in query_str
+        condition_str = _compile(new_query._conditions[0])
+        assert "\\" not in condition_str
+        assert "%Music/Artist/%" in condition_str
 
     def test_by_path_no_resolve(self):
         """by_path does NOT resolve the path."""
@@ -530,87 +516,83 @@ class TestCollectionQuery:
         # The raw string (or parts of it) must appear, not a resolved absolute path
         assert ".." in condition_str and "relative" in condition_str
 
-    def test_by_path_ilike_wraps_with_wildcards(self):
-        """The ilike condition includes % wildcards for substring matching."""
+    def test_by_path_empty_arg_adds_no_condition(self):
+        """An empty --path arg is a no-op rather than matching everything."""
         query = CollectionQuery()
-        new_query = query.by_path("track.mp3")
+        new_query = query.by_path("")
 
-        condition_str = _compile(new_query._conditions[0])
-        assert "%" in condition_str
+        assert new_query._conditions == []
 
-    # --- by_path exact mode ---
+    # --- by_path resolved mode ---
 
-    def test_by_exact_path_filename_only(self):
-        """Exact match on a bare filename produces an equality condition on FileNameL only."""
+    def test_by_resolved_path_resolves_relative_path(self):
+        """Resolved mode makes relative paths absolute against the cwd before querying."""
+        cwd = Path(os.getcwd()).as_posix()
         query = CollectionQuery()
-        new_query = query.by_path("track.mp3", exact=True)
+        new_query = query.by_path("Album/track.mp3", resolved=True)
 
-        assert len(new_query._conditions) == 1
-        condition_str = str(new_query._conditions[0])
-        assert "FolderPath" not in condition_str
-        assert "FileNameL" in condition_str
-        assert "=" in condition_str
-        assert "LIKE lower" not in condition_str
+        condition_str = _compile(new_query._conditions[0])
+        assert f"%{cwd}/Album/track.mp3%" in condition_str
 
-    def test_by_exact_path_folder_only(self):
-        """Exact match on a only folder path produces equality check on FolderPath only."""
+    def test_by_resolved_path_substring_case_insensitive(self):
+        """Resolved mode is a case-insensitive substring check on FolderPath,
+        same as fuzzy mode, so a resolved folder path matches every track under it."""
         query = CollectionQuery()
-        # Build a cross-platform absolute path using pathlib
-        path = "/Test/Artist/"
-        new_query = query.by_path(path, exact=True)
+        new_query = query.by_path("/Test/Artist/file.mp3", resolved=True)
 
         assert len(new_query._conditions) == 1
-        condition_str = _compile(new_query._conditions[0])
+        condition_str = str(new_query._conditions[0])
         assert "FolderPath" in condition_str
         assert "FileNameL" not in condition_str
-        assert "=" in condition_str
-        assert path in condition_str
-        assert "like lower" not in condition_str
+        assert "LIKE lower" in condition_str
 
-    def test_by_exact_path_folder_and_filename(self):
-        """Exact match on a full path produces a compound AND with equality on both columns."""
+    def test_by_resolved_path_is_lexical_and_preserves_casing(self):
+        """Resolution is pure string math: even for a directory that exists on
+        disk, the casing stays as typed instead of being rewritten to the
+        on-disk casing (Path.resolve would rewrite it on Windows)."""
+        miscased_cwd = Path(os.getcwd()).as_posix().swapcase()
         query = CollectionQuery()
-        # Build a cross-platform absolute path using pathlib
-        abs_path = "/Artist/track.mp3"
-        new_query = query.by_path(abs_path, exact=True)
+        new_query = query.by_path(f"{miscased_cwd}/track.mp3", resolved=True)
 
-        assert len(new_query._conditions) == 1
-        condition_str = str(new_query._conditions[0])
-        assert "FolderPath" in condition_str
-        assert "FileNameL" in condition_str
-        assert " AND " in condition_str
-        assert "LIKE lower" not in condition_str
+        condition_str = _compile(new_query._conditions[0])
+        assert f"{miscased_cwd}/track.mp3" in condition_str
 
-    def test_by_exact_path_resolves_relative_path(self):
-        """Exact match resolves relative paths to absolute before querying."""
-        cwd = Path(os.getcwd()).as_posix()
+    def test_by_resolved_path_preserves_trailing_slash(self):
+        """A trailing slash survives resolution so the pattern only matches
+        directory components."""
         query = CollectionQuery()
-        new_query = query.by_path("Album/track.mp3", exact=True)
+        new_query = query.by_path("Album/", resolved=True)
 
         condition_str = _compile(new_query._conditions[0])
-        # cwd should appear as the resolved folder part
-        assert cwd in condition_str
+        assert f"{Path(os.getcwd()).as_posix()}/Album/" in condition_str
 
     @pytest.mark.skipif(
         platform.system() != "Windows", reason="backslash path parsing is Windows-only"
     )
-    def test_by_exact_path_backslash_normalised_to_forward_slash(self):
-        """Backslash separators in --exact-path input are normalised via as_posix()."""
+    def test_by_resolved_path_backslash_normalised_to_forward_slash(self):
+        """Backslash separators in --resolved-path input are normalised via as_posix()."""
         query = CollectionQuery()
         # Pass a Windows-style absolute path; as_posix() must produce forward slashes
         new_query = query.by_path(
-            "C:\\Users\\foo\\music\\Artist\\track.mp3", exact=True
+            "C:\\Users\\foo\\music\\Artist\\track.mp3", resolved=True
         )
 
         condition_str = _compile(new_query._conditions[0])
         assert "\\" not in condition_str
-        assert "/" in condition_str
+        assert "C:/Users/foo/music/Artist/track.mp3" in condition_str
+
+    def test_by_resolved_path_empty_arg_adds_no_condition(self):
+        """An empty --resolved-path arg is a no-op rather than matching everything."""
+        query = CollectionQuery()
+        new_query = query.by_path("", resolved=True)
+
+        assert new_query._conditions == []
 
     def test_by_path_returns_new_instance(self):
         """by_path always returns a new CollectionQuery instance."""
         query = CollectionQuery()
         assert query.by_path("track.mp3") is not query
-        assert query.by_path("track.mp3", exact=True) is not query
+        assert query.by_path("track.mp3", resolved=True) is not query
 
 
 @pytest.fixture
@@ -699,9 +681,9 @@ class TestGetFilteredContent:
         get_filtered_content(mock_db, FilterArgs(path=["Music/track.mp3"]))
         mock_query.by_path.assert_called_once_with("Music/track.mp3")
 
-    def test_exact_path(self, mock_db, mock_query):
-        get_filtered_content(mock_db, FilterArgs(exact_path=["/Music/track.wav"]))
-        mock_query.by_path.assert_called_once_with("/Music/track.wav", exact=True)
+    def test_resolved_path(self, mock_db, mock_query):
+        get_filtered_content(mock_db, FilterArgs(resolved_path=["/Music/track.wav"]))
+        mock_query.by_path.assert_called_once_with("/Music/track.wav", resolved=True)
 
     def test_format(self, mock_db, mock_query):
         get_filtered_content(mock_db, FilterArgs(format=["flac"]))

{rekordbox_edit-0.7.0.dev72 → rekordbox_edit-0.8.0.dev6}/uv.lock

@@ -1268,7 +1268,7 @@ wheels = [
 
 [[package]]
 name = "rekordbox-edit"
-version = "0.7.0.dev72"
+version = "0.8.0.dev6"
 source = { editable = "." }
 dependencies = [
     { name = "click" },