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

rekordbox_edit-0.8.0.dev6/.github/actions/build-release-notes/action.yml

@@ -0,0 +1,25 @@
+name: "Build Release Notes"
+description: "Generate categorized, per-commit release notes with each commit's PR resolved and its author credited"
+inputs:
+  from_tag:
+    description: "Tag to start the changelog range from (exclusive). Leave empty for full history."
+    required: false
+    default: ""
+  to_tag:
+    description: "Tag to end the changelog range at (inclusive)"
+    required: true
+  github_token:
+    description: "GitHub token for API access"
+    required: true
+runs:
+  using: "composite"
+  steps:
+    - name: Generate release notes
+      shell: bash
+      run: python3 "${GITHUB_ACTION_PATH}/build_release_notes.py"
+      env:
+        FROM_TAG: ${{ inputs.from_tag }}
+        TO_TAG: ${{ inputs.to_tag }}
+        OUTPUT_FILE: release-notes.md
+        REPO: ${{ github.repository }}
+        GH_TOKEN: ${{ inputs.github_token }}

rekordbox_edit-0.8.0.dev6/.github/actions/build-release-notes/build_release_notes.py

@@ -0,0 +1,212 @@
+#!/usr/bin/env python3
+"""Build categorized release notes from commits, linking each commit's PR.
+
+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. 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
+
+import json
+import os
+import re
+import subprocess
+import sys
+from dataclasses import dataclass, field
+
+# Category matchers, evaluated in order; first match wins. Mirrors the
+# conventional-commit types accepted by the project's commitizen schema.
+_BREAKING_TITLE = re.compile(r"^(BREAKING(\(.*\))?:|(\w+)?(\(.*\))?!:)")
+_BREAKING_BODY = re.compile(r"BREAKING[\- ]CHANGE")
+_CATEGORY_TITLE_RULES: list[tuple[str, re.Pattern[str]]] = [
+    ("## Features", re.compile(r"^feat(\(.*\))?:")),
+    ("## Fixes", re.compile(r"^fix(?!\(deps\))(\(.*\))?:")),
+    (
+        "## Chores",
+        re.compile(
+            r"^(chore(?!\(deps\))|refactor|ci|docs|style|perf|test|build)(\(.*\))?:"
+        ),
+    ),
+    ("## Dependency Updates", re.compile(r"^(chore|fix)\(deps\):")),
+]
+_BREAKING_TITLE_HEADER = "## Breaking Changes"
+_UNCATEGORIZED_HEADER = "## Uncategorized"
+_CATEGORY_ORDER = [
+    _BREAKING_TITLE_HEADER,
+    "## Features",
+    "## Fixes",
+    "## Chores",
+    "## Dependency Updates",
+    _UNCATEGORIZED_HEADER,
+]
+
+# Commits that are noise in a changelog: merge commits are dropped at the
+# ``git log`` level (--no-merges); version-bump commits are filtered here.
+_SKIP_SUBJECT = re.compile(r"^bump:")
+# A trailing "(#NN)" left by squash merges, stripped so it is not duplicated
+# alongside the resolved reference.
+_TRAILING_PR = re.compile(r"\s*\(#\d+\)\s*$")
+
+_RECORD_SEP = "\x1e"
+_FIELD_SEP = "\x1f"
+
+
+@dataclass
+class Commit:
+    sha: str
+    subject: str
+    body: str
+    author: str
+
+
+@dataclass
+class Category:
+    header: str
+    lines: list[str] = field(default_factory=list)
+
+
+def _run(args: list[str]) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(args, capture_output=True, text=True, encoding="utf-8")
+
+
+def read_commits(from_tag: str, to_tag: str) -> list[Commit]:
+    rng = f"{from_tag}..{to_tag}" if from_tag else to_tag
+    fmt = _FIELD_SEP.join(["%H", "%s", "%b", "%an"]) + _RECORD_SEP
+    result = _run(["git", "log", "--no-merges", f"--format={fmt}", rng])
+    if result.returncode != 0:
+        raise SystemExit(f"git log failed for range '{rng}': {result.stderr.strip()}")
+
+    commits: list[Commit] = []
+    for record in result.stdout.split(_RECORD_SEP):
+        record = record.strip("\n")
+        if not record:
+            continue
+        sha, subject, body, author = (record.split(_FIELD_SEP) + ["", "", ""])[:4]
+        commits.append(
+            Commit(
+                sha=sha,
+                subject=subject.strip(),
+                body=body.strip(),
+                author=author.strip(),
+            )
+        )
+    return commits
+
+
+# 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
+    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:
+    if _BREAKING_TITLE.match(commit.subject) or _BREAKING_BODY.search(commit.body):
+        return _BREAKING_TITLE_HEADER
+    for header, pattern in _CATEGORY_TITLE_RULES:
+        if pattern.match(commit.subject):
+            return header
+    return _UNCATEGORIZED_HEADER
+
+
+def render_line(commit: Commit, pr: tuple[int, str] | None) -> str:
+    subject = _TRAILING_PR.sub("", commit.subject)
+    if pr is not None:
+        number, login = pr
+        credit = f"#{number} by @{login}" if login else f"#{number}"
+        return f"- {subject} ({credit})"
+    return f"- {subject} ({commit.sha[:7]} by {commit.author})"
+
+
+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 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)
+        for header in _CATEGORY_ORDER
+        if (cat := categories[header]).lines
+    ]
+    return "\n\n".join(sections) if sections else "_No changes._"
+
+
+def main() -> None:
+    to_tag = os.environ.get("TO_TAG", "").strip()
+    if not to_tag:
+        raise SystemExit("TO_TAG is required")
+    from_tag = os.environ.get("FROM_TAG", "").strip()
+    repo = os.environ.get("REPO") or os.environ.get("GITHUB_REPOSITORY", "")
+    if not repo:
+        raise SystemExit("REPO (or GITHUB_REPOSITORY) is required")
+    output_file = os.environ.get("OUTPUT_FILE", "release-notes.md")
+
+    commits = read_commits(from_tag, to_tag)
+    notes = build_notes(commits, repo)
+    with open(output_file, "w", encoding="utf-8") as handle:
+        handle.write(notes + "\n")
+    print(notes, file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()

{rekordbox_edit-0.7.0.dev71 → 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.dev71 → 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.dev71 → 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.dev71 → rekordbox_edit-0.8.0.dev6}/CHANGELOG.md

@@ -1,6 +1,23 @@
-## v0.7.0.dev71 (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
 - chore: update AGENTS.md
 - docs: pave FAQ page based on convert + analysis research
 - feat(convert): verify source codec against FileType before converting

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

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "rekordbox-edit"
-version = "0.7.0.dev71"
+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"
@@ -91,8 +91,8 @@ message_template = "{{change_type}}{{scope}}: {{message}}"
 example = "feat(convert): add new conversion feature"
 schema = "<type>(<scope>): <body>"
 schema_pattern = "^(BREAKING|feat|fix|refactor|ci|test|docs|chore)(\\([^)]*\\))?!?: .+"
-bump_pattern = "^(BREAKING|feat|fix|perf|hotfix|refactor)"
-bump_map = { "BREAKING" = "MAJOR", "feat" = "MINOR", "fix" = "PATCH", "refactor" = "PATCH" }
+bump_pattern = "^((BREAKING[\\-\\ ]CHANGE|BREAKING|feat|fix|perf|hotfix|refactor)(\\(.+\\))?!?):"
+bump_map = { "^.+!$" = "MAJOR", "^BREAKING" = "MAJOR", "^feat" = "MINOR", "^fix" = "PATCH", "^refactor" = "PATCH" }
 
 [[tool.commitizen.customize.questions]]
 type = "list"

{rekordbox_edit-0.7.0.dev71 → 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.dev71 → 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.dev71 → 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.dev71 → 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.dev71 → 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/",